src/librustc/ty/context.rs

   1 //! Type context book-keeping.
   2
   3 use crate::arena::Arena;
   4 use crate::dep_graph::DepGraph;
   5 use crate::dep_graph::{self, DepNode, DepConstructor};
   6 use crate::session::Session;
   7 use crate::session::config::{BorrowckMode, OutputFilenames};
   8 use crate::session::config::CrateType;
   9 use crate::middle;
  10 use crate::hir::{self, TraitCandidate, HirId, ItemKind, ItemLocalId, Node};
  11 use crate::hir::def::{Res, DefKind, Export};
  12 use crate::hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
  13 use crate::hir::map as hir_map;
  14 use crate::hir::map::DefPathHash;
  15 use crate::lint::{self, Lint};
  16 use crate::ich::{StableHashingContext, NodeIdHashingMode};
  17 use crate::infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos};
  18 use crate::infer::outlives::free_region_map::FreeRegionMap;
  19 use crate::middle::cstore::CrateStoreDyn;
  20 use crate::middle::cstore::EncodedMetadata;
  21 use crate::middle::lang_items;
  22 use crate::middle::resolve_lifetime::{self, ObjectLifetimeDefault};
  23 use crate::middle::stability;
  24 use crate::mir::{Body, interpret, ProjectionKind, Promoted};
  25 use crate::mir::interpret::{ConstValue, Allocation, Scalar};
  26 use crate::ty::subst::{GenericArg, InternalSubsts, SubstsRef, Subst};
  27 use crate::ty::ReprOptions;
  28 use crate::traits;
  29 use crate::traits::{Clause, Clauses, GoalKind, Goal, Goals};
  30 use crate::ty::{self, DefIdTree, Ty, TypeAndMut};
  31 use crate::ty::{TyS, TyKind, List};
  32 use crate::ty::{AdtKind, AdtDef, ClosureSubsts, GeneratorSubsts, Region, Const};
  33 use crate::ty::{PolyFnSig, InferTy, ParamTy, ProjectionTy, ExistentialPredicate, Predicate};
  34 use crate::ty::RegionKind;
  35 use crate::ty::{TyVar, TyVid, IntVar, IntVid, FloatVar, FloatVid, ConstVid};
  36 use crate::ty::TyKind::*;
  37 use crate::ty::{InferConst, ParamConst};
  38 use crate::ty::GenericParamDefKind;
  39 use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx};
  40 use crate::ty::query;
  41 use crate::ty::steal::Steal;
  42 use crate::ty::subst::{UserSubsts, GenericArgKind};
  43 use crate::ty::{BoundVar, BindingMode};
  44 use crate::ty::CanonicalPolyFnSig;
  45 use crate::util::common::ErrorReported;
  46 use crate::util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap, ItemLocalSet};
  47 use crate::util::nodemap::{FxHashMap, FxHashSet};
  48 use crate::util::profiling::SelfProfilerRef;
  49
  50 use errors::DiagnosticBuilder;
  51 use arena::SyncDroplessArena;
  52 use smallvec::SmallVec;
  53 use rustc_data_structures::stable_hasher::{
  54     HashStable, StableHasher, StableVec, hash_stable_hashmap,
  55 };
  56 use rustc_index::vec::{Idx, IndexVec};
  57 use rustc_data_structures::sharded::ShardedHashMap;
  58 use rustc_data_structures::sync::{Lrc, Lock, WorkerLocal};
  59 use std::any::Any;
  60 use std::borrow::Borrow;
  61 use std::cmp::Ordering;
  62 use std::collections::hash_map::{self, Entry};
  63 use std::hash::{Hash, Hasher};
  64 use std::fmt;
  65 use std::mem;
  66 use std::ops::{Deref, Bound};
  67 use std::iter;
  68 use std::sync::Arc;
  69 use rustc_target::spec::abi;
  70 use rustc_macros::HashStable;
  71 use syntax::ast;
  72 use syntax::attr;
  73 use syntax::source_map::MultiSpan;
  74 use syntax::feature_gate;
  75 use syntax::symbol::{Symbol, InternedString, kw, sym};
  76 use syntax_pos::Span;
  77
  78 pub struct AllArenas {
  79     pub interner: SyncDroplessArena,
  80 }
  81
  82 impl AllArenas {
  83     pub fn new() -> Self {
  84         AllArenas {
  85             interner: SyncDroplessArena::default(),
  86         }
  87     }
  88 }
  89
  90 type InternedSet<'tcx, T> = ShardedHashMap<Interned<'tcx, T>, ()>;
  91
  92 pub struct CtxtInterners<'tcx> {
  93     /// The arena that types, regions, etc. are allocated from.
  94     arena: &'tcx SyncDroplessArena,
  95
  96     /// Specifically use a speedy hash algorithm for these hash sets, since
  97     /// they're accessed quite often.
  98     type_: InternedSet<'tcx, TyS<'tcx>>,
  99     type_list: InternedSet<'tcx, List<Ty<'tcx>>>,
 100     substs: InternedSet<'tcx, InternalSubsts<'tcx>>,
 101     canonical_var_infos: InternedSet<'tcx, List<CanonicalVarInfo>>,
 102     region: InternedSet<'tcx, RegionKind>,
 103     existential_predicates: InternedSet<'tcx, List<ExistentialPredicate<'tcx>>>,
 104     predicates: InternedSet<'tcx, List<Predicate<'tcx>>>,
 105     clauses: InternedSet<'tcx, List<Clause<'tcx>>>,
 106     goal: InternedSet<'tcx, GoalKind<'tcx>>,
 107     goal_list: InternedSet<'tcx, List<Goal<'tcx>>>,
 108     projs: InternedSet<'tcx, List<ProjectionKind>>,
 109     const_: InternedSet<'tcx, Const<'tcx>>,
 110 }
 111
 112 impl<'tcx> CtxtInterners<'tcx> {
 113     fn new(arena: &'tcx SyncDroplessArena) -> CtxtInterners<'tcx> {
 114         CtxtInterners {
 115             arena,
 116             type_: Default::default(),
 117             type_list: Default::default(),
 118             substs: Default::default(),
 119             region: Default::default(),
 120             existential_predicates: Default::default(),
 121             canonical_var_infos: Default::default(),
 122             predicates: Default::default(),
 123             clauses: Default::default(),
 124             goal: Default::default(),
 125             goal_list: Default::default(),
 126             projs: Default::default(),
 127             const_: Default::default(),
 128         }
 129     }
 130
 131     /// Interns a type.
 132     #[allow(rustc::usage_of_ty_tykind)]
 133     #[inline(never)]
 134     fn intern_ty(&self,
 135         kind: TyKind<'tcx>
 136     ) -> Ty<'tcx> {
 137         self.type_.intern(kind, |kind| {
 138             let flags = super::flags::FlagComputation::for_kind(&kind);
 139
 140             let ty_struct = TyS {
 141                 kind,
 142                 flags: flags.flags,
 143                 outer_exclusive_binder: flags.outer_exclusive_binder,
 144             };
 145
 146             Interned(self.arena.alloc(ty_struct))
 147         }).0
 148     }
 149 }
 150
 151 pub struct Common<'tcx> {
 152     pub empty_predicates: ty::GenericPredicates<'tcx>,
 153 }
 154
 155 pub struct CommonTypes<'tcx> {
 156     pub unit: Ty<'tcx>,
 157     pub bool: Ty<'tcx>,
 158     pub char: Ty<'tcx>,
 159     pub isize: Ty<'tcx>,
 160     pub i8: Ty<'tcx>,
 161     pub i16: Ty<'tcx>,
 162     pub i32: Ty<'tcx>,
 163     pub i64: Ty<'tcx>,
 164     pub i128: Ty<'tcx>,
 165     pub usize: Ty<'tcx>,
 166     pub u8: Ty<'tcx>,
 167     pub u16: Ty<'tcx>,
 168     pub u32: Ty<'tcx>,
 169     pub u64: Ty<'tcx>,
 170     pub u128: Ty<'tcx>,
 171     pub f32: Ty<'tcx>,
 172     pub f64: Ty<'tcx>,
 173     pub never: Ty<'tcx>,
 174     pub self_param: Ty<'tcx>,
 175     pub err: Ty<'tcx>,
 176
 177     /// Dummy type used for the `Self` of a `TraitRef` created for converting
 178     /// a trait object, and which gets removed in `ExistentialTraitRef`.
 179     /// This type must not appear anywhere in other converted types.
 180     pub trait_object_dummy_self: Ty<'tcx>,
 181 }
 182
 183 pub struct CommonLifetimes<'tcx> {
 184     pub re_empty: Region<'tcx>,
 185     pub re_static: Region<'tcx>,
 186     pub re_erased: Region<'tcx>,
 187 }
 188
 189 pub struct CommonConsts<'tcx> {
 190     pub err: &'tcx Const<'tcx>,
 191 }
 192
 193 pub struct LocalTableInContext<'a, V> {
 194     local_id_root: Option<DefId>,
 195     data: &'a ItemLocalMap<V>
 196 }
 197
 198 /// Validate that the given HirId (respectively its `local_id` part) can be
 199 /// safely used as a key in the tables of a TypeckTable. For that to be
 200 /// the case, the HirId must have the same `owner` as all the other IDs in
 201 /// this table (signified by `local_id_root`). Otherwise the HirId
 202 /// would be in a different frame of reference and using its `local_id`
 203 /// would result in lookup errors, or worse, in silently wrong data being
 204 /// stored/returned.
 205 fn validate_hir_id_for_typeck_tables(local_id_root: Option<DefId>,
 206                                      hir_id: hir::HirId,
 207                                      mut_access: bool) {
 208     if let Some(local_id_root) = local_id_root {
 209         if hir_id.owner != local_id_root.index {
 210             ty::tls::with(|tcx| {
 211                 bug!("node {} with HirId::owner {:?} cannot be placed in \
 212                         TypeckTables with local_id_root {:?}",
 213                         tcx.hir().node_to_string(hir_id),
 214                         DefId::local(hir_id.owner),
 215                         local_id_root)
 216             });
 217         }
 218     } else {
 219         // We use "Null Object" TypeckTables in some of the analysis passes.
 220         // These are just expected to be empty and their `local_id_root` is
 221         // `None`. Therefore we cannot verify whether a given `HirId` would
 222         // be a valid key for the given table. Instead we make sure that
 223         // nobody tries to write to such a Null Object table.
 224         if mut_access {
 225             bug!("access to invalid TypeckTables")
 226         }
 227     }
 228 }
 229
 230 impl<'a, V> LocalTableInContext<'a, V> {
 231     pub fn contains_key(&self, id: hir::HirId) -> bool {
 232         validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
 233         self.data.contains_key(&id.local_id)
 234     }
 235
 236     pub fn get(&self, id: hir::HirId) -> Option<&V> {
 237         validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
 238         self.data.get(&id.local_id)
 239     }
 240
 241     pub fn iter(&self) -> hash_map::Iter<'_, hir::ItemLocalId, V> {
 242         self.data.iter()
 243     }
 244 }
 245
 246 impl<'a, V> ::std::ops::Index<hir::HirId> for LocalTableInContext<'a, V> {
 247     type Output = V;
 248
 249     fn index(&self, key: hir::HirId) -> &V {
 250         self.get(key).expect("LocalTableInContext: key not found")
 251     }
 252 }
 253
 254 pub struct LocalTableInContextMut<'a, V> {
 255     local_id_root: Option<DefId>,
 256     data: &'a mut ItemLocalMap<V>
 257 }
 258
 259 impl<'a, V> LocalTableInContextMut<'a, V> {
 260     pub fn get_mut(&mut self, id: hir::HirId) -> Option<&mut V> {
 261         validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
 262         self.data.get_mut(&id.local_id)
 263     }
 264
 265     pub fn entry(&mut self, id: hir::HirId) -> Entry<'_, hir::ItemLocalId, V> {
 266         validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
 267         self.data.entry(id.local_id)
 268     }
 269
 270     pub fn insert(&mut self, id: hir::HirId, val: V) -> Option<V> {
 271         validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
 272         self.data.insert(id.local_id, val)
 273     }
 274
 275     pub fn remove(&mut self, id: hir::HirId) -> Option<V> {
 276         validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
 277         self.data.remove(&id.local_id)
 278     }
 279 }
 280
 281 /// All information necessary to validate and reveal an `impl Trait`.
 282 #[derive(RustcEncodable, RustcDecodable, Debug, HashStable)]
 283 pub struct ResolvedOpaqueTy<'tcx> {
 284     /// The revealed type as seen by this function.
 285     pub concrete_type: Ty<'tcx>,
 286     /// Generic parameters on the opaque type as passed by this function.
 287     /// For `type Foo<A, B> = impl Bar<A, B>; fn foo<T, U>() -> Foo<T, U> { .. }`
 288     /// this is `[T, U]`, not `[A, B]`.
 289     pub substs: SubstsRef<'tcx>,
 290 }
 291
 292 /// Whenever a value may be live across a generator yield, the type of that value winds up in the
 293 /// `GeneratorInteriorTypeCause` struct. This struct adds additional information about such
 294 /// captured types that can be useful for diagnostics. In particular, it stores the span that
 295 /// caused a given type to be recorded, along with the scope that enclosed the value (which can
 296 /// be used to find the await that the value is live across).
 297 ///
 298 /// For example:
 299 ///
 300 /// ```ignore (pseudo-Rust)
 301 /// async move {
 302 ///     let x: T = ...;
 303 ///     foo.await
 304 ///     ...
 305 /// }
 306 /// ```
 307 ///
 308 /// Here, we would store the type `T`, the span of the value `x`, and the "scope-span" for
 309 /// the scope that contains `x`.
 310 #[derive(RustcEncodable, RustcDecodable, Clone, Debug, Eq, Hash, HashStable, PartialEq)]
 311 pub struct GeneratorInteriorTypeCause<'tcx> {
 312     /// Type of the captured binding.
 313     pub ty: Ty<'tcx>,
 314     /// Span of the binding that was captured.
 315     pub span: Span,
 316     /// Span of the scope of the captured binding.
 317     pub scope_span: Option<Span>,
 318 }
 319
 320 #[derive(RustcEncodable, RustcDecodable, Debug)]
 321 pub struct TypeckTables<'tcx> {
 322     /// The HirId::owner all ItemLocalIds in this table are relative to.
 323     pub local_id_root: Option<DefId>,
 324
 325     /// Resolved definitions for `<T>::X` associated paths and
 326     /// method calls, including those of overloaded operators.
 327     type_dependent_defs: ItemLocalMap<Result<(DefKind, DefId), ErrorReported>>,
 328
 329     /// Resolved field indices for field accesses in expressions (`S { field }`, `obj.field`)
 330     /// or patterns (`S { field }`). The index is often useful by itself, but to learn more
 331     /// about the field you also need definition of the variant to which the field
 332     /// belongs, but it may not exist if it's a tuple field (`tuple.0`).
 333     field_indices: ItemLocalMap<usize>,
 334
 335     /// Stores the types for various nodes in the AST. Note that this table
 336     /// is not guaranteed to be populated until after typeck. See
 337     /// typeck::check::fn_ctxt for details.
 338     node_types: ItemLocalMap<Ty<'tcx>>,
 339
 340     /// Stores the type parameters which were substituted to obtain the type
 341     /// of this node. This only applies to nodes that refer to entities
 342     /// parameterized by type parameters, such as generic fns, types, or
 343     /// other items.
 344     node_substs: ItemLocalMap<SubstsRef<'tcx>>,
 345
 346     /// This will either store the canonicalized types provided by the user
 347     /// or the substitutions that the user explicitly gave (if any) attached
 348     /// to `id`. These will not include any inferred values. The canonical form
 349     /// is used to capture things like `_` or other unspecified values.
 350     ///
 351     /// For example, if the user wrote `foo.collect::<Vec<_>>()`, then the
 352     /// canonical substitutions would include only `for<X> { Vec<X> }`.
 353     ///
 354     /// See also `AscribeUserType` statement in MIR.
 355     user_provided_types: ItemLocalMap<CanonicalUserType<'tcx>>,
 356
 357     /// Stores the canonicalized types provided by the user. See also
 358     /// `AscribeUserType` statement in MIR.
 359     pub user_provided_sigs: DefIdMap<CanonicalPolyFnSig<'tcx>>,
 360
 361     adjustments: ItemLocalMap<Vec<ty::adjustment::Adjustment<'tcx>>>,
 362
 363     /// Stores the actual binding mode for all instances of hir::BindingAnnotation.
 364     pat_binding_modes: ItemLocalMap<BindingMode>,
 365
 366     /// Stores the types which were implicitly dereferenced in pattern binding modes
 367     /// for later usage in HAIR lowering. For example,
 368     ///
 369     /// ```
 370     /// match &&Some(5i32) {
 371     ///     Some(n) => {},
 372     ///     _ => {},
 373     /// }
 374     /// ```
 375     /// leads to a `vec![&&Option<i32>, &Option<i32>]`. Empty vectors are not stored.
 376     ///
 377     /// See:
 378     /// https://github.com/rust-lang/rfcs/blob/master/text/2005-match-ergonomics.md#definitions
 379     pat_adjustments: ItemLocalMap<Vec<Ty<'tcx>>>,
 380
 381     /// Borrows
 382     pub upvar_capture_map: ty::UpvarCaptureMap<'tcx>,
 383
 384     /// Records the reasons that we picked the kind of each closure;
 385     /// not all closures are present in the map.
 386     closure_kind_origins: ItemLocalMap<(Span, ast::Name)>,
 387
 388     /// For each fn, records the "liberated" types of its arguments
 389     /// and return type. Liberated means that all bound regions
 390     /// (including late-bound regions) are replaced with free
 391     /// equivalents. This table is not used in codegen (since regions
 392     /// are erased there) and hence is not serialized to metadata.
 393     liberated_fn_sigs: ItemLocalMap<ty::FnSig<'tcx>>,
 394
 395     /// For each FRU expression, record the normalized types of the fields
 396     /// of the struct - this is needed because it is non-trivial to
 397     /// normalize while preserving regions. This table is used only in
 398     /// MIR construction and hence is not serialized to metadata.
 399     fru_field_types: ItemLocalMap<Vec<Ty<'tcx>>>,
 400
 401     /// For every coercion cast we add the HIR node ID of the cast
 402     /// expression to this set.
 403     coercion_casts: ItemLocalSet,
 404
 405     /// Set of trait imports actually used in the method resolution.
 406     /// This is used for warning unused imports. During type
 407     /// checking, this `Lrc` should not be cloned: it must have a ref-count
 408     /// of 1 so that we can insert things into the set mutably.
 409     pub used_trait_imports: Lrc<DefIdSet>,
 410
 411     /// If any errors occurred while type-checking this body,
 412     /// this field will be set to `true`.
 413     pub tainted_by_errors: bool,
 414
 415     /// Stores the free-region relationships that were deduced from
 416     /// its where-clauses and parameter types. These are then
 417     /// read-again by borrowck.
 418     pub free_region_map: FreeRegionMap<'tcx>,
 419
 420     /// All the opaque types that are restricted to concrete types
 421     /// by this function.
 422     pub concrete_opaque_types: FxHashMap<DefId, ResolvedOpaqueTy<'tcx>>,
 423
 424     /// Given the closure ID this map provides the list of UpvarIDs used by it.
 425     /// The upvarID contains the HIR node ID and it also contains the full path
 426     /// leading to the member of the struct or tuple that is used instead of the
 427     /// entire variable.
 428     pub upvar_list: ty::UpvarListMap,
 429
 430     /// Stores the type, span and optional scope span of all types
 431     /// that are live across the yield of this generator (if a generator).
 432     pub generator_interior_types: Vec<GeneratorInteriorTypeCause<'tcx>>,
 433 }
 434
 435 impl<'tcx> TypeckTables<'tcx> {
 436     pub fn empty(local_id_root: Option<DefId>) -> TypeckTables<'tcx> {
 437         TypeckTables {
 438             local_id_root,
 439             type_dependent_defs: Default::default(),
 440             field_indices: Default::default(),
 441             user_provided_types: Default::default(),
 442             user_provided_sigs: Default::default(),
 443             node_types: Default::default(),
 444             node_substs: Default::default(),
 445             adjustments: Default::default(),
 446             pat_binding_modes: Default::default(),
 447             pat_adjustments: Default::default(),
 448             upvar_capture_map: Default::default(),
 449             closure_kind_origins: Default::default(),
 450             liberated_fn_sigs: Default::default(),
 451             fru_field_types: Default::default(),
 452             coercion_casts: Default::default(),
 453             used_trait_imports: Lrc::new(Default::default()),
 454             tainted_by_errors: false,
 455             free_region_map: Default::default(),
 456             concrete_opaque_types: Default::default(),
 457             upvar_list: Default::default(),
 458             generator_interior_types: Default::default(),
 459         }
 460     }
 461
 462     /// Returns the final resolution of a `QPath` in an `Expr` or `Pat` node.
 463     pub fn qpath_res(&self, qpath: &hir::QPath, id: hir::HirId) -> Res {
 464         match *qpath {
 465             hir::QPath::Resolved(_, ref path) => path.res,
 466             hir::QPath::TypeRelative(..) => self.type_dependent_def(id)
 467                 .map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)),
 468         }
 469     }
 470
 471     pub fn type_dependent_defs(
 472         &self,
 473     ) -> LocalTableInContext<'_, Result<(DefKind, DefId), ErrorReported>> {
 474         LocalTableInContext {
 475             local_id_root: self.local_id_root,
 476             data: &self.type_dependent_defs
 477         }
 478     }
 479
 480     pub fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
 481         validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
 482         self.type_dependent_defs.get(&id.local_id).cloned().and_then(|r| r.ok())
 483     }
 484
 485     pub fn type_dependent_def_id(&self, id: HirId) -> Option<DefId> {
 486         self.type_dependent_def(id).map(|(_, def_id)| def_id)
 487     }
 488
 489     pub fn type_dependent_defs_mut(
 490         &mut self,
 491     ) -> LocalTableInContextMut<'_, Result<(DefKind, DefId), ErrorReported>> {
 492         LocalTableInContextMut {
 493             local_id_root: self.local_id_root,
 494             data: &mut self.type_dependent_defs
 495         }
 496     }
 497
 498     pub fn field_indices(&self) -> LocalTableInContext<'_, usize> {
 499         LocalTableInContext {
 500             local_id_root: self.local_id_root,
 501             data: &self.field_indices
 502         }
 503     }
 504
 505     pub fn field_indices_mut(&mut self) -> LocalTableInContextMut<'_, usize> {
 506         LocalTableInContextMut {
 507             local_id_root: self.local_id_root,
 508             data: &mut self.field_indices
 509         }
 510     }
 511
 512     pub fn user_provided_types(
 513         &self
 514     ) -> LocalTableInContext<'_, CanonicalUserType<'tcx>> {
 515         LocalTableInContext {
 516             local_id_root: self.local_id_root,
 517             data: &self.user_provided_types
 518         }
 519     }
 520
 521     pub fn user_provided_types_mut(
 522         &mut self
 523     ) -> LocalTableInContextMut<'_, CanonicalUserType<'tcx>> {
 524         LocalTableInContextMut {
 525             local_id_root: self.local_id_root,
 526             data: &mut self.user_provided_types
 527         }
 528     }
 529
 530     pub fn node_types(&self) -> LocalTableInContext<'_, Ty<'tcx>> {
 531         LocalTableInContext {
 532             local_id_root: self.local_id_root,
 533             data: &self.node_types
 534         }
 535     }
 536
 537     pub fn node_types_mut(&mut self) -> LocalTableInContextMut<'_, Ty<'tcx>> {
 538         LocalTableInContextMut {
 539             local_id_root: self.local_id_root,
 540             data: &mut self.node_types
 541         }
 542     }
 543
 544     pub fn node_type(&self, id: hir::HirId) -> Ty<'tcx> {
 545         self.node_type_opt(id).unwrap_or_else(||
 546             bug!("node_type: no type for node `{}`",
 547                  tls::with(|tcx| tcx.hir().node_to_string(id)))
 548         )
 549     }
 550
 551     pub fn node_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
 552         validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
 553         self.node_types.get(&id.local_id).cloned()
 554     }
 555
 556     pub fn node_substs_mut(&mut self) -> LocalTableInContextMut<'_, SubstsRef<'tcx>> {
 557         LocalTableInContextMut {
 558             local_id_root: self.local_id_root,
 559             data: &mut self.node_substs
 560         }
 561     }
 562
 563     pub fn node_substs(&self, id: hir::HirId) -> SubstsRef<'tcx> {
 564         validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
 565         self.node_substs.get(&id.local_id).cloned().unwrap_or_else(|| InternalSubsts::empty())
 566     }
 567
 568     pub fn node_substs_opt(&self, id: hir::HirId) -> Option<SubstsRef<'tcx>> {
 569         validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
 570         self.node_substs.get(&id.local_id).cloned()
 571     }
 572
 573     // Returns the type of a pattern as a monotype. Like @expr_ty, this function
 574     // doesn't provide type parameter substitutions.
 575     pub fn pat_ty(&self, pat: &hir::Pat) -> Ty<'tcx> {
 576         self.node_type(pat.hir_id)
 577     }
 578
 579     pub fn pat_ty_opt(&self, pat: &hir::Pat) -> Option<Ty<'tcx>> {
 580         self.node_type_opt(pat.hir_id)
 581     }
 582
 583     // Returns the type of an expression as a monotype.
 584     //
 585     // NB (1): This is the PRE-ADJUSTMENT TYPE for the expression.  That is, in
 586     // some cases, we insert `Adjustment` annotations such as auto-deref or
 587     // auto-ref.  The type returned by this function does not consider such
 588     // adjustments.  See `expr_ty_adjusted()` instead.
 589     //
 590     // NB (2): This type doesn't provide type parameter substitutions; e.g., if you
 591     // ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize"
 592     // instead of "fn(ty) -> T with T = isize".
 593     pub fn expr_ty(&self, expr: &hir::Expr) -> Ty<'tcx> {
 594         self.node_type(expr.hir_id)
 595     }
 596
 597     pub fn expr_ty_opt(&self, expr: &hir::Expr) -> Option<Ty<'tcx>> {
 598         self.node_type_opt(expr.hir_id)
 599     }
 600
 601     pub fn adjustments(&self) -> LocalTableInContext<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
 602         LocalTableInContext {
 603             local_id_root: self.local_id_root,
 604             data: &self.adjustments
 605         }
 606     }
 607
 608     pub fn adjustments_mut(&mut self)
 609                            -> LocalTableInContextMut<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
 610         LocalTableInContextMut {
 611             local_id_root: self.local_id_root,
 612             data: &mut self.adjustments
 613         }
 614     }
 615
 616     pub fn expr_adjustments(&self, expr: &hir::Expr)
 617                             -> &[ty::adjustment::Adjustment<'tcx>] {
 618         validate_hir_id_for_typeck_tables(self.local_id_root, expr.hir_id, false);
 619         self.adjustments.get(&expr.hir_id.local_id).map_or(&[], |a| &a[..])
 620     }
 621
 622     /// Returns the type of `expr`, considering any `Adjustment`
 623     /// entry recorded for that expression.
 624     pub fn expr_ty_adjusted(&self, expr: &hir::Expr) -> Ty<'tcx> {
 625         self.expr_adjustments(expr)
 626             .last()
 627             .map_or_else(|| self.expr_ty(expr), |adj| adj.target)
 628     }
 629
 630     pub fn expr_ty_adjusted_opt(&self, expr: &hir::Expr) -> Option<Ty<'tcx>> {
 631         self.expr_adjustments(expr)
 632             .last()
 633             .map(|adj| adj.target)
 634             .or_else(|| self.expr_ty_opt(expr))
 635     }
 636
 637     pub fn is_method_call(&self, expr: &hir::Expr) -> bool {
 638         // Only paths and method calls/overloaded operators have
 639         // entries in type_dependent_defs, ignore the former here.
 640         if let hir::ExprKind::Path(_) = expr.kind {
 641             return false;
 642         }
 643
 644         match self.type_dependent_defs().get(expr.hir_id) {
 645             Some(Ok((DefKind::Method, _))) => true,
 646             _ => false
 647         }
 648     }
 649
 650     pub fn pat_binding_modes(&self) -> LocalTableInContext<'_, BindingMode> {
 651         LocalTableInContext {
 652             local_id_root: self.local_id_root,
 653             data: &self.pat_binding_modes
 654         }
 655     }
 656
 657     pub fn pat_binding_modes_mut(&mut self)
 658                            -> LocalTableInContextMut<'_, BindingMode> {
 659         LocalTableInContextMut {
 660             local_id_root: self.local_id_root,
 661             data: &mut self.pat_binding_modes
 662         }
 663     }
 664
 665     pub fn pat_adjustments(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
 666         LocalTableInContext {
 667             local_id_root: self.local_id_root,
 668             data: &self.pat_adjustments,
 669         }
 670     }
 671
 672     pub fn pat_adjustments_mut(&mut self)
 673                                -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
 674         LocalTableInContextMut {
 675             local_id_root: self.local_id_root,
 676             data: &mut self.pat_adjustments,
 677         }
 678     }
 679
 680     pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> ty::UpvarCapture<'tcx> {
 681         self.upvar_capture_map[&upvar_id]
 682     }
 683
 684     pub fn closure_kind_origins(&self) -> LocalTableInContext<'_, (Span, ast::Name)> {
 685         LocalTableInContext {
 686             local_id_root: self.local_id_root,
 687             data: &self.closure_kind_origins
 688         }
 689     }
 690
 691     pub fn closure_kind_origins_mut(&mut self) -> LocalTableInContextMut<'_, (Span, ast::Name)> {
 692         LocalTableInContextMut {
 693             local_id_root: self.local_id_root,
 694             data: &mut self.closure_kind_origins
 695         }
 696     }
 697
 698     pub fn liberated_fn_sigs(&self) -> LocalTableInContext<'_, ty::FnSig<'tcx>> {
 699         LocalTableInContext {
 700             local_id_root: self.local_id_root,
 701             data: &self.liberated_fn_sigs
 702         }
 703     }
 704
 705     pub fn liberated_fn_sigs_mut(&mut self) -> LocalTableInContextMut<'_, ty::FnSig<'tcx>> {
 706         LocalTableInContextMut {
 707             local_id_root: self.local_id_root,
 708             data: &mut self.liberated_fn_sigs
 709         }
 710     }
 711
 712     pub fn fru_field_types(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
 713         LocalTableInContext {
 714             local_id_root: self.local_id_root,
 715             data: &self.fru_field_types
 716         }
 717     }
 718
 719     pub fn fru_field_types_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
 720         LocalTableInContextMut {
 721             local_id_root: self.local_id_root,
 722             data: &mut self.fru_field_types
 723         }
 724     }
 725
 726     pub fn is_coercion_cast(&self, hir_id: hir::HirId) -> bool {
 727         validate_hir_id_for_typeck_tables(self.local_id_root, hir_id, true);
 728         self.coercion_casts.contains(&hir_id.local_id)
 729     }
 730
 731     pub fn set_coercion_cast(&mut self, id: ItemLocalId) {
 732         self.coercion_casts.insert(id);
 733     }
 734
 735     pub fn coercion_casts(&self) -> &ItemLocalSet {
 736         &self.coercion_casts
 737     }
 738
 739 }
 740
 741 impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> {
 742     fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
 743         let ty::TypeckTables {
 744             local_id_root,
 745             ref type_dependent_defs,
 746             ref field_indices,
 747             ref user_provided_types,
 748             ref user_provided_sigs,
 749             ref node_types,
 750             ref node_substs,
 751             ref adjustments,
 752             ref pat_binding_modes,
 753             ref pat_adjustments,
 754             ref upvar_capture_map,
 755             ref closure_kind_origins,
 756             ref liberated_fn_sigs,
 757             ref fru_field_types,
 758
 759             ref coercion_casts,
 760
 761             ref used_trait_imports,
 762             tainted_by_errors,
 763             ref free_region_map,
 764             ref concrete_opaque_types,
 765             ref upvar_list,
 766             ref generator_interior_types,
 767
 768         } = *self;
 769
 770         hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
 771             type_dependent_defs.hash_stable(hcx, hasher);
 772             field_indices.hash_stable(hcx, hasher);
 773             user_provided_types.hash_stable(hcx, hasher);
 774             user_provided_sigs.hash_stable(hcx, hasher);
 775             node_types.hash_stable(hcx, hasher);
 776             node_substs.hash_stable(hcx, hasher);
 777             adjustments.hash_stable(hcx, hasher);
 778             pat_binding_modes.hash_stable(hcx, hasher);
 779             pat_adjustments.hash_stable(hcx, hasher);
 780             hash_stable_hashmap(hcx, hasher, upvar_capture_map, |up_var_id, hcx| {
 781                 let ty::UpvarId {
 782                     var_path,
 783                     closure_expr_id
 784                 } = *up_var_id;
 785
 786                 let local_id_root =
 787                     local_id_root.expect("trying to hash invalid TypeckTables");
 788
 789                 let var_owner_def_id = DefId {
 790                     krate: local_id_root.krate,
 791                     index: var_path.hir_id.owner,
 792                 };
 793                 let closure_def_id = DefId {
 794                     krate: local_id_root.krate,
 795                     index: closure_expr_id.to_def_id().index,
 796                 };
 797                 (hcx.def_path_hash(var_owner_def_id),
 798                  var_path.hir_id.local_id,
 799                  hcx.def_path_hash(closure_def_id))
 800             });
 801
 802             closure_kind_origins.hash_stable(hcx, hasher);
 803             liberated_fn_sigs.hash_stable(hcx, hasher);
 804             fru_field_types.hash_stable(hcx, hasher);
 805             coercion_casts.hash_stable(hcx, hasher);
 806             used_trait_imports.hash_stable(hcx, hasher);
 807             tainted_by_errors.hash_stable(hcx, hasher);
 808             free_region_map.hash_stable(hcx, hasher);
 809             concrete_opaque_types.hash_stable(hcx, hasher);
 810             upvar_list.hash_stable(hcx, hasher);
 811             generator_interior_types.hash_stable(hcx, hasher);
 812         })
 813     }
 814 }
 815
 816 rustc_index::newtype_index! {
 817     pub struct UserTypeAnnotationIndex {
 818         derive [HashStable]
 819         DEBUG_FORMAT = "UserType({})",
 820         const START_INDEX = 0,
 821     }
 822 }
 823
 824 /// Mapping of type annotation indices to canonical user type annotations.
 825 pub type CanonicalUserTypeAnnotations<'tcx> =
 826     IndexVec<UserTypeAnnotationIndex, CanonicalUserTypeAnnotation<'tcx>>;
 827
 828 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)]
 829 pub struct CanonicalUserTypeAnnotation<'tcx> {
 830     pub user_ty: CanonicalUserType<'tcx>,
 831     pub span: Span,
 832     pub inferred_ty: Ty<'tcx>,
 833 }
 834
 835 BraceStructTypeFoldableImpl! {
 836     impl<'tcx> TypeFoldable<'tcx> for CanonicalUserTypeAnnotation<'tcx> {
 837         user_ty, span, inferred_ty
 838     }
 839 }
 840
 841 BraceStructLiftImpl! {
 842     impl<'a, 'tcx> Lift<'tcx> for CanonicalUserTypeAnnotation<'a> {
 843         type Lifted = CanonicalUserTypeAnnotation<'tcx>;
 844         user_ty, span, inferred_ty
 845     }
 846 }
 847
 848 /// Canonicalized user type annotation.
 849 pub type CanonicalUserType<'tcx> = Canonical<'tcx, UserType<'tcx>>;
 850
 851 impl CanonicalUserType<'tcx> {
 852     /// Returns `true` if this represents a substitution of the form `[?0, ?1, ?2]`,
 853     /// i.e., each thing is mapped to a canonical variable with the same index.
 854     pub fn is_identity(&self) -> bool {
 855         match self.value {
 856             UserType::Ty(_) => false,
 857             UserType::TypeOf(_, user_substs) => {
 858                 if user_substs.user_self_ty.is_some() {
 859                     return false;
 860                 }
 861
 862                 user_substs.substs.iter().zip(BoundVar::new(0)..).all(|(kind, cvar)| {
 863                     match kind.unpack() {
 864                         GenericArgKind::Type(ty) => match ty.kind {
 865                             ty::Bound(debruijn, b) => {
 866                                 // We only allow a `ty::INNERMOST` index in substitutions.
 867                                 assert_eq!(debruijn, ty::INNERMOST);
 868                                 cvar == b.var
 869                             }
 870                             _ => false,
 871                         },
 872
 873                         GenericArgKind::Lifetime(r) => match r {
 874                             ty::ReLateBound(debruijn, br) => {
 875                                 // We only allow a `ty::INNERMOST` index in substitutions.
 876                                 assert_eq!(*debruijn, ty::INNERMOST);
 877                                 cvar == br.assert_bound_var()
 878                             }
 879                             _ => false,
 880                         },
 881
 882                         GenericArgKind::Const(ct) => match ct.val {
 883                             ConstValue::Infer(InferConst::Canonical(debruijn, b)) => {
 884                                 // We only allow a `ty::INNERMOST` index in substitutions.
 885                                 assert_eq!(debruijn, ty::INNERMOST);
 886                                 cvar == b
 887                             }
 888                             _ => false,
 889                         },
 890                     }
 891                 })
 892             },
 893         }
 894     }
 895 }
 896
 897 /// A user-given type annotation attached to a constant. These arise
 898 /// from constants that are named via paths, like `Foo::<A>::new` and
 899 /// so forth.
 900 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, HashStable)]
 901 pub enum UserType<'tcx> {
 902     Ty(Ty<'tcx>),
 903
 904     /// The canonical type is the result of `type_of(def_id)` with the
 905     /// given substitutions applied.
 906     TypeOf(DefId, UserSubsts<'tcx>),
 907 }
 908
 909 EnumTypeFoldableImpl! {
 910     impl<'tcx> TypeFoldable<'tcx> for UserType<'tcx> {
 911         (UserType::Ty)(ty),
 912         (UserType::TypeOf)(def, substs),
 913     }
 914 }
 915
 916 EnumLiftImpl! {
 917     impl<'a, 'tcx> Lift<'tcx> for UserType<'a> {
 918         type Lifted = UserType<'tcx>;
 919         (UserType::Ty)(ty),
 920         (UserType::TypeOf)(def, substs),
 921     }
 922 }
 923
 924 impl<'tcx> CommonTypes<'tcx> {
 925     fn new(interners: &CtxtInterners<'tcx>) -> CommonTypes<'tcx> {
 926         let mk = |ty| interners.intern_ty(ty);
 927
 928         CommonTypes {
 929             unit: mk(Tuple(List::empty())),
 930             bool: mk(Bool),
 931             char: mk(Char),
 932             never: mk(Never),
 933             err: mk(Error),
 934             isize: mk(Int(ast::IntTy::Isize)),
 935             i8: mk(Int(ast::IntTy::I8)),
 936             i16: mk(Int(ast::IntTy::I16)),
 937             i32: mk(Int(ast::IntTy::I32)),
 938             i64: mk(Int(ast::IntTy::I64)),
 939             i128: mk(Int(ast::IntTy::I128)),
 940             usize: mk(Uint(ast::UintTy::Usize)),
 941             u8: mk(Uint(ast::UintTy::U8)),
 942             u16: mk(Uint(ast::UintTy::U16)),
 943             u32: mk(Uint(ast::UintTy::U32)),
 944             u64: mk(Uint(ast::UintTy::U64)),
 945             u128: mk(Uint(ast::UintTy::U128)),
 946             f32: mk(Float(ast::FloatTy::F32)),
 947             f64: mk(Float(ast::FloatTy::F64)),
 948             self_param: mk(ty::Param(ty::ParamTy {
 949                 index: 0,
 950                 name: kw::SelfUpper.as_interned_str(),
 951             })),
 952
 953             trait_object_dummy_self: mk(Infer(ty::FreshTy(0))),
 954         }
 955     }
 956 }
 957
 958 impl<'tcx> CommonLifetimes<'tcx> {
 959     fn new(interners: &CtxtInterners<'tcx>) -> CommonLifetimes<'tcx> {
 960         let mk = |r| {
 961             interners.region.intern(r, |r| {
 962                 Interned(interners.arena.alloc(r))
 963             }).0
 964         };
 965
 966         CommonLifetimes {
 967             re_empty: mk(RegionKind::ReEmpty),
 968             re_static: mk(RegionKind::ReStatic),
 969             re_erased: mk(RegionKind::ReErased),
 970         }
 971     }
 972 }
 973
 974 impl<'tcx> CommonConsts<'tcx> {
 975     fn new(interners: &CtxtInterners<'tcx>, types: &CommonTypes<'tcx>) -> CommonConsts<'tcx> {
 976         let mk_const = |c| {
 977             interners.const_.intern(c, |c| {
 978                 Interned(interners.arena.alloc(c))
 979             }).0
 980         };
 981
 982         CommonConsts {
 983             err: mk_const(ty::Const {
 984                 val: ConstValue::Scalar(Scalar::zst()),
 985                 ty: types.err,
 986             }),
 987         }
 988     }
 989 }
 990
 991 // This struct contains information regarding the `ReFree(FreeRegion)` corresponding to a lifetime
 992 // conflict.
 993 #[derive(Debug)]
 994 pub struct FreeRegionInfo {
 995     // def id corresponding to FreeRegion
 996     pub def_id: DefId,
 997     // the bound region corresponding to FreeRegion
 998     pub boundregion: ty::BoundRegion,
 999     // checks if bound region is in Impl Item
1000     pub is_impl_item: bool,
1001 }
1002
1003 /// The central data structure of the compiler. It stores references
1004 /// to the various **arenas** and also houses the results of the
1005 /// various **compiler queries** that have been performed. See the
1006 /// [rustc guide] for more details.
1007 ///
1008 /// [rustc guide]: https://rust-lang.github.io/rustc-guide/ty.html
1009 #[derive(Copy, Clone)]
1010 #[rustc_diagnostic_item = "TyCtxt"]
1011 pub struct TyCtxt<'tcx> {
1012     gcx: &'tcx GlobalCtxt<'tcx>,
1013 }
1014
1015 impl<'tcx> Deref for TyCtxt<'tcx> {
1016     type Target = &'tcx GlobalCtxt<'tcx>;
1017     #[inline(always)]
1018     fn deref(&self) -> &Self::Target {
1019         &self.gcx
1020     }
1021 }
1022
1023 pub struct GlobalCtxt<'tcx> {
1024     pub arena: WorkerLocal<Arena<'tcx>>,
1025
1026     interners: CtxtInterners<'tcx>,
1027
1028     cstore: &'tcx CrateStoreDyn,
1029
1030     pub sess: &'tcx Session,
1031
1032     pub dep_graph: DepGraph,
1033
1034     pub prof: SelfProfilerRef,
1035
1036     /// Common objects.
1037     pub common: Common<'tcx>,
1038
1039     /// Common types, pre-interned for your convenience.
1040     pub types: CommonTypes<'tcx>,
1041
1042     /// Common lifetimes, pre-interned for your convenience.
1043     pub lifetimes: CommonLifetimes<'tcx>,
1044
1045     /// Common consts, pre-interned for your convenience.
1046     pub consts: CommonConsts<'tcx>,
1047
1048     /// Map indicating what traits are in scope for places where this
1049     /// is relevant; generated by resolve.
1050     trait_map: FxHashMap<DefIndex,
1051                          FxHashMap<ItemLocalId,
1052                                    StableVec<TraitCandidate>>>,
1053
1054     /// Export map produced by name resolution.
1055     export_map: FxHashMap<DefId, Vec<Export<hir::HirId>>>,
1056
1057     hir_map: hir_map::Map<'tcx>,
1058
1059     /// A map from `DefPathHash` -> `DefId`. Includes `DefId`s from the local crate
1060     /// as well as all upstream crates. Only populated in incremental mode.
1061     pub def_path_hash_to_def_id: Option<FxHashMap<DefPathHash, DefId>>,
1062
1063     pub queries: query::Queries<'tcx>,
1064
1065     maybe_unused_trait_imports: FxHashSet<DefId>,
1066     maybe_unused_extern_crates: Vec<(DefId, Span)>,
1067     /// A map of glob use to a set of names it actually imports. Currently only
1068     /// used in save-analysis.
1069     glob_map: FxHashMap<DefId, FxHashSet<ast::Name>>,
1070     /// Extern prelude entries. The value is `true` if the entry was introduced
1071     /// via `extern crate` item and not `--extern` option or compiler built-in.
1072     pub extern_prelude: FxHashMap<ast::Name, bool>,
1073
1074     // Internal cache for metadata decoding. No need to track deps on this.
1075     pub rcache: Lock<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
1076
1077     /// Caches the results of trait selection. This cache is used
1078     /// for things that do not have to do with the parameters in scope.
1079     pub selection_cache: traits::SelectionCache<'tcx>,
1080
1081     /// Caches the results of trait evaluation. This cache is used
1082     /// for things that do not have to do with the parameters in scope.
1083     /// Merge this with `selection_cache`?
1084     pub evaluation_cache: traits::EvaluationCache<'tcx>,
1085
1086     /// The definite name of the current crate after taking into account
1087     /// attributes, commandline parameters, etc.
1088     pub crate_name: Symbol,
1089
1090     /// Data layout specification for the current target.
1091     pub data_layout: TargetDataLayout,
1092
1093     stability_interner: ShardedHashMap<&'tcx attr::Stability, ()>,
1094
1095     /// Stores the value of constants (and deduplicates the actual memory)
1096     allocation_interner: ShardedHashMap<&'tcx Allocation, ()>,
1097
1098     pub alloc_map: Lock<interpret::AllocMap<'tcx>>,
1099
1100     layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>,
1101
1102     output_filenames: Arc<OutputFilenames>,
1103 }
1104
1105 impl<'tcx> TyCtxt<'tcx> {
1106     #[inline(always)]
1107     pub fn hir(self) -> &'tcx hir_map::Map<'tcx> {
1108         &self.hir_map
1109     }
1110
1111     pub fn alloc_steal_mir(self, mir: Body<'tcx>) -> &'tcx Steal<Body<'tcx>> {
1112         self.arena.alloc(Steal::new(mir))
1113     }
1114
1115     pub fn alloc_steal_promoted(self, promoted: IndexVec<Promoted, Body<'tcx>>) ->
1116         &'tcx Steal<IndexVec<Promoted, Body<'tcx>>> {
1117         self.arena.alloc(Steal::new(promoted))
1118     }
1119
1120     pub fn intern_promoted(self, promoted: IndexVec<Promoted, Body<'tcx>>) ->
1121         &'tcx IndexVec<Promoted, Body<'tcx>> {
1122         self.arena.alloc(promoted)
1123     }
1124
1125     pub fn alloc_adt_def(
1126         self,
1127         did: DefId,
1128         kind: AdtKind,
1129         variants: IndexVec<VariantIdx, ty::VariantDef>,
1130         repr: ReprOptions,
1131     ) -> &'tcx ty::AdtDef {
1132         let def = ty::AdtDef::new(self, did, kind, variants, repr);
1133         self.arena.alloc(def)
1134     }
1135
1136     pub fn intern_const_alloc(self, alloc: Allocation) -> &'tcx Allocation {
1137         self.allocation_interner.intern(alloc, |alloc| {
1138             self.arena.alloc(alloc)
1139         })
1140     }
1141
1142     /// Allocates a read-only byte or string literal for `mir::interpret`.
1143     pub fn allocate_bytes(self, bytes: &[u8]) -> interpret::AllocId {
1144         // Create an allocation that just contains these bytes.
1145         let alloc = interpret::Allocation::from_byte_aligned_bytes(bytes);
1146         let alloc = self.intern_const_alloc(alloc);
1147         self.alloc_map.lock().create_memory_alloc(alloc)
1148     }
1149
1150     pub fn intern_stability(self, stab: attr::Stability) -> &'tcx attr::Stability {
1151         self.stability_interner.intern(stab, |stab| {
1152             self.arena.alloc(stab)
1153         })
1154     }
1155
1156     pub fn intern_layout(self, layout: LayoutDetails) -> &'tcx LayoutDetails {
1157         self.layout_interner.intern(layout, |layout| {
1158             self.arena.alloc(layout)
1159         })
1160     }
1161
1162     /// Returns a range of the start/end indices specified with the
1163     /// `rustc_layout_scalar_valid_range` attribute.
1164     pub fn layout_scalar_valid_range(self, def_id: DefId) -> (Bound<u128>, Bound<u128>) {
1165         let attrs = self.get_attrs(def_id);
1166         let get = |name| {
1167             let attr = match attrs.iter().find(|a| a.check_name(name)) {
1168                 Some(attr) => attr,
1169                 None => return Bound::Unbounded,
1170             };
1171             for meta in attr.meta_item_list().expect("rustc_layout_scalar_valid_range takes args") {
1172                 match meta.literal().expect("attribute takes lit").kind {
1173                     ast::LitKind::Int(a, _) => return Bound::Included(a),
1174                     _ => span_bug!(attr.span, "rustc_layout_scalar_valid_range expects int arg"),
1175                 }
1176             }
1177             span_bug!(attr.span, "no arguments to `rustc_layout_scalar_valid_range` attribute");
1178         };
1179         (get(sym::rustc_layout_scalar_valid_range_start),
1180          get(sym::rustc_layout_scalar_valid_range_end))
1181     }
1182
1183     pub fn lift<T: ?Sized + Lift<'tcx>>(self, value: &T) -> Option<T::Lifted> {
1184         value.lift_to_tcx(self)
1185     }
1186
1187     /// Creates a type context and call the closure with a `TyCtxt` reference
1188     /// to the context. The closure enforces that the type context and any interned
1189     /// value (types, substs, etc.) can only be used while `ty::tls` has a valid
1190     /// reference to the context, to allow formatting values that need it.
1191     pub fn create_global_ctxt(
1192         s: &'tcx Session,
1193         cstore: &'tcx CrateStoreDyn,
1194         local_providers: ty::query::Providers<'tcx>,
1195         extern_providers: ty::query::Providers<'tcx>,
1196         arenas: &'tcx AllArenas,
1197         resolutions: ty::Resolutions,
1198         hir: hir_map::Map<'tcx>,
1199         on_disk_query_result_cache: query::OnDiskCache<'tcx>,
1200         crate_name: &str,
1201         output_filenames: &OutputFilenames,
1202     ) -> GlobalCtxt<'tcx> {
1203         let data_layout = TargetDataLayout::parse(&s.target.target).unwrap_or_else(|err| {
1204             s.fatal(&err);
1205         });
1206         let interners = CtxtInterners::new(&arenas.interner);
1207         let common = Common {
1208             empty_predicates: ty::GenericPredicates {
1209                 parent: None,
1210                 predicates: vec![],
1211             },
1212         };
1213         let common_types = CommonTypes::new(&interners);
1214         let common_lifetimes = CommonLifetimes::new(&interners);
1215         let common_consts = CommonConsts::new(&interners, &common_types);
1216         let dep_graph = hir.dep_graph.clone();
1217         let max_cnum = cstore.crates_untracked().iter().map(|c| c.as_usize()).max().unwrap_or(0);
1218         let mut providers = IndexVec::from_elem_n(extern_providers, max_cnum + 1);
1219         providers[LOCAL_CRATE] = local_providers;
1220
1221         let def_path_hash_to_def_id = if s.opts.build_dep_graph() {
1222             let upstream_def_path_tables: Vec<(CrateNum, Lrc<_>)> = cstore
1223                 .crates_untracked()
1224                 .iter()
1225                 .map(|&cnum| (cnum, cstore.def_path_table(cnum)))
1226                 .collect();
1227
1228             let def_path_tables = || {
1229                 upstream_def_path_tables
1230                     .iter()
1231                     .map(|&(cnum, ref rc)| (cnum, &**rc))
1232                     .chain(iter::once((LOCAL_CRATE, hir.definitions().def_path_table())))
1233             };
1234
1235             // Precompute the capacity of the hashmap so we don't have to
1236             // re-allocate when populating it.
1237             let capacity = def_path_tables().map(|(_, t)| t.size()).sum::<usize>();
1238
1239             let mut map: FxHashMap<_, _> = FxHashMap::with_capacity_and_hasher(
1240                 capacity,
1241                 ::std::default::Default::default()
1242             );
1243
1244             for (cnum, def_path_table) in def_path_tables() {
1245                 def_path_table.add_def_path_hashes_to(cnum, &mut map);
1246             }
1247
1248             Some(map)
1249         } else {
1250             None
1251         };
1252
1253         let mut trait_map: FxHashMap<_, FxHashMap<_, _>> = FxHashMap::default();
1254         for (k, v) in resolutions.trait_map {
1255             let hir_id = hir.node_to_hir_id(k);
1256             let map = trait_map.entry(hir_id.owner).or_default();
1257             map.insert(hir_id.local_id, StableVec::new(v));
1258         }
1259
1260         GlobalCtxt {
1261             sess: s,
1262             cstore,
1263             arena: WorkerLocal::new(|_| Arena::default()),
1264             interners,
1265             dep_graph,
1266             prof: s.prof.clone(),
1267             common,
1268             types: common_types,
1269             lifetimes: common_lifetimes,
1270             consts: common_consts,
1271             trait_map,
1272             export_map: resolutions.export_map.into_iter().map(|(k, v)| {
1273                 let exports: Vec<_> = v.into_iter().map(|e| {
1274                     e.map_id(|id| hir.node_to_hir_id(id))
1275                 }).collect();
1276                 (k, exports)
1277             }).collect(),
1278             maybe_unused_trait_imports:
1279                 resolutions.maybe_unused_trait_imports
1280                     .into_iter()
1281                     .map(|id| hir.local_def_id_from_node_id(id))
1282                     .collect(),
1283             maybe_unused_extern_crates:
1284                 resolutions.maybe_unused_extern_crates
1285                     .into_iter()
1286                     .map(|(id, sp)| (hir.local_def_id_from_node_id(id), sp))
1287                     .collect(),
1288             glob_map: resolutions.glob_map.into_iter().map(|(id, names)| {
1289                 (hir.local_def_id_from_node_id(id), names)
1290             }).collect(),
1291             extern_prelude: resolutions.extern_prelude,
1292             hir_map: hir,
1293             def_path_hash_to_def_id,
1294             queries: query::Queries::new(
1295                 providers,
1296                 extern_providers,
1297                 on_disk_query_result_cache,
1298             ),
1299             rcache: Default::default(),
1300             selection_cache: Default::default(),
1301             evaluation_cache: Default::default(),
1302             crate_name: Symbol::intern(crate_name),
1303             data_layout,
1304             layout_interner: Default::default(),
1305             stability_interner: Default::default(),
1306             allocation_interner: Default::default(),
1307             alloc_map: Lock::new(interpret::AllocMap::new()),
1308             output_filenames: Arc::new(output_filenames.clone()),
1309         }
1310     }
1311
1312     pub fn consider_optimizing<T: Fn() -> String>(&self, msg: T) -> bool {
1313         let cname = self.crate_name(LOCAL_CRATE).as_str();
1314         self.sess.consider_optimizing(&cname, msg)
1315     }
1316
1317     pub fn lib_features(self) -> &'tcx middle::lib_features::LibFeatures {
1318         self.get_lib_features(LOCAL_CRATE)
1319     }
1320
1321     /// Obtain all lang items of this crate and all dependencies (recursively)
1322     pub fn lang_items(self) -> &'tcx middle::lang_items::LanguageItems {
1323         self.get_lang_items(LOCAL_CRATE)
1324     }
1325
1326     /// Obtain the given diagnostic item's `DefId`. Use `is_diagnostic_item` if you just want to
1327     /// compare against another `DefId`, since `is_diagnostic_item` is cheaper.
1328     pub fn get_diagnostic_item(self, name: Symbol) -> Option<DefId> {
1329         self.all_diagnostic_items(LOCAL_CRATE).get(&name).copied()
1330     }
1331
1332     /// Check whether the diagnostic item with the given `name` has the given `DefId`.
1333     pub fn is_diagnostic_item(self, name: Symbol, did: DefId) -> bool {
1334         self.diagnostic_items(did.krate).get(&name) == Some(&did)
1335     }
1336
1337     pub fn stability(self) -> &'tcx stability::Index<'tcx> {
1338         self.stability_index(LOCAL_CRATE)
1339     }
1340
1341     pub fn crates(self) -> &'tcx [CrateNum] {
1342         self.all_crate_nums(LOCAL_CRATE)
1343     }
1344
1345     pub fn features(self) -> &'tcx feature_gate::Features {
1346         self.features_query(LOCAL_CRATE)
1347     }
1348
1349     pub fn def_key(self, id: DefId) -> hir_map::DefKey {
1350         if id.is_local() {
1351             self.hir().def_key(id)
1352         } else {
1353             self.cstore.def_key(id)
1354         }
1355     }
1356
1357     /// Converts a `DefId` into its fully expanded `DefPath` (every
1358     /// `DefId` is really just an interned `DefPath`).
1359     ///
1360     /// Note that if `id` is not local to this crate, the result will
1361     ///  be a non-local `DefPath`.
1362     pub fn def_path(self, id: DefId) -> hir_map::DefPath {
1363         if id.is_local() {
1364             self.hir().def_path(id)
1365         } else {
1366             self.cstore.def_path(id)
1367         }
1368     }
1369
1370     /// Returns whether or not the crate with CrateNum 'cnum'
1371     /// is marked as a private dependency
1372     pub fn is_private_dep(self, cnum: CrateNum) -> bool {
1373         if cnum == LOCAL_CRATE {
1374             false
1375         } else {
1376             self.cstore.crate_is_private_dep_untracked(cnum)
1377         }
1378     }
1379
1380     #[inline]
1381     pub fn def_path_hash(self, def_id: DefId) -> hir_map::DefPathHash {
1382         if def_id.is_local() {
1383             self.hir().definitions().def_path_hash(def_id.index)
1384         } else {
1385             self.cstore.def_path_hash(def_id)
1386         }
1387     }
1388
1389     pub fn def_path_debug_str(self, def_id: DefId) -> String {
1390         // We are explicitly not going through queries here in order to get
1391         // crate name and disambiguator since this code is called from debug!()
1392         // statements within the query system and we'd run into endless
1393         // recursion otherwise.
1394         let (crate_name, crate_disambiguator) = if def_id.is_local() {
1395             (self.crate_name.clone(),
1396              self.sess.local_crate_disambiguator())
1397         } else {
1398             (self.cstore.crate_name_untracked(def_id.krate),
1399              self.cstore.crate_disambiguator_untracked(def_id.krate))
1400         };
1401
1402         format!("{}[{}]{}",
1403                 crate_name,
1404                 // Don't print the whole crate disambiguator. That's just
1405                 // annoying in debug output.
1406                 &(crate_disambiguator.to_fingerprint().to_hex())[..4],
1407                 self.def_path(def_id).to_string_no_crate())
1408     }
1409
1410     pub fn metadata_encoding_version(self) -> Vec<u8> {
1411         self.cstore.metadata_encoding_version().to_vec()
1412     }
1413
1414     pub fn encode_metadata(self)-> EncodedMetadata {
1415         self.cstore.encode_metadata(self)
1416     }
1417
1418     // Note that this is *untracked* and should only be used within the query
1419     // system if the result is otherwise tracked through queries
1420     pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Lrc<dyn Any> {
1421         self.cstore.crate_data_as_rc_any(cnum)
1422     }
1423
1424     #[inline(always)]
1425     pub fn create_stable_hashing_context(self) -> StableHashingContext<'tcx> {
1426         let krate = self.gcx.hir_map.forest.untracked_krate();
1427
1428         StableHashingContext::new(self.sess,
1429                                   krate,
1430                                   self.hir().definitions(),
1431                                   self.cstore)
1432     }
1433
1434     // This method makes sure that we have a DepNode and a Fingerprint for
1435     // every upstream crate. It needs to be called once right after the tcx is
1436     // created.
1437     // With full-fledged red/green, the method will probably become unnecessary
1438     // as this will be done on-demand.
1439     pub fn allocate_metadata_dep_nodes(self) {
1440         // We cannot use the query versions of crates() and crate_hash(), since
1441         // those would need the DepNodes that we are allocating here.
1442         for cnum in self.cstore.crates_untracked() {
1443             let dep_node = DepNode::new(self, DepConstructor::CrateMetadata(cnum));
1444             let crate_hash = self.cstore.crate_hash_untracked(cnum);
1445             self.dep_graph.with_task(dep_node,
1446                                      self,
1447                                      crate_hash,
1448                                      |_, x| x, // No transformation needed
1449                                      dep_graph::hash_result,
1450             );
1451         }
1452     }
1453
1454     pub fn serialize_query_result_cache<E>(self,
1455                                            encoder: &mut E)
1456                                            -> Result<(), E::Error>
1457         where E: ty::codec::TyEncoder
1458     {
1459         self.queries.on_disk_cache.serialize(self, encoder)
1460     }
1461
1462     /// If `true`, we should use the MIR-based borrowck, but also
1463     /// fall back on the AST borrowck if the MIR-based one errors.
1464     pub fn migrate_borrowck(self) -> bool {
1465         self.borrowck_mode().migrate()
1466     }
1467
1468     /// If `true`, make MIR codegen for `match` emit a temp that holds a
1469     /// borrow of the input to the match expression.
1470     pub fn generate_borrow_of_any_match_input(&self) -> bool {
1471         self.emit_read_for_match()
1472     }
1473
1474     /// If `true`, make MIR codegen for `match` emit FakeRead
1475     /// statements (which simulate the maximal effect of executing the
1476     /// patterns in a match arm).
1477     pub fn emit_read_for_match(&self) -> bool {
1478         !self.sess.opts.debugging_opts.nll_dont_emit_read_for_match
1479     }
1480
1481     /// What mode(s) of borrowck should we run? AST? MIR? both?
1482     /// (Also considers the `#![feature(nll)]` setting.)
1483     pub fn borrowck_mode(&self) -> BorrowckMode {
1484         // Here are the main constraints we need to deal with:
1485         //
1486         // 1. An opts.borrowck_mode of `BorrowckMode::Migrate` is
1487         //    synonymous with no `-Z borrowck=...` flag at all.
1488         //
1489         // 2. We want to allow developers on the Nightly channel
1490         //    to opt back into the "hard error" mode for NLL,
1491         //    (which they can do via specifying `#![feature(nll)]`
1492         //    explicitly in their crate).
1493         //
1494         // So, this precedence list is how pnkfelix chose to work with
1495         // the above constraints:
1496         //
1497         // * `#![feature(nll)]` *always* means use NLL with hard
1498         //   errors. (To simplify the code here, it now even overrides
1499         //   a user's attempt to specify `-Z borrowck=compare`, which
1500         //   we arguably do not need anymore and should remove.)
1501         //
1502         // * Otherwise, if no `-Z borrowck=...` then use migrate mode
1503         //
1504         // * Otherwise, use the behavior requested via `-Z borrowck=...`
1505
1506         if self.features().nll { return BorrowckMode::Mir; }
1507
1508         self.sess.opts.borrowck_mode
1509     }
1510
1511     #[inline]
1512     pub fn local_crate_exports_generics(self) -> bool {
1513         debug_assert!(self.sess.opts.share_generics());
1514
1515         self.sess.crate_types.borrow().iter().any(|crate_type| {
1516             match crate_type {
1517                 CrateType::Executable |
1518                 CrateType::Staticlib  |
1519                 CrateType::ProcMacro  |
1520                 CrateType::Dylib      |
1521                 CrateType::Cdylib     => false,
1522                 CrateType::Rlib       => true,
1523             }
1524         })
1525     }
1526
1527     // Returns the `DefId` and the `BoundRegion` corresponding to the given region.
1528     pub fn is_suitable_region(&self, region: Region<'tcx>) -> Option<FreeRegionInfo> {
1529         let (suitable_region_binding_scope, bound_region) = match *region {
1530             ty::ReFree(ref free_region) => (free_region.scope, free_region.bound_region),
1531             ty::ReEarlyBound(ref ebr) => (
1532                 self.parent(ebr.def_id).unwrap(),
1533                 ty::BoundRegion::BrNamed(ebr.def_id, ebr.name),
1534             ),
1535             _ => return None, // not a free region
1536         };
1537
1538         let hir_id = self.hir()
1539             .as_local_hir_id(suitable_region_binding_scope)
1540             .unwrap();
1541         let is_impl_item = match self.hir().find(hir_id) {
1542             Some(Node::Item(..)) | Some(Node::TraitItem(..)) => false,
1543             Some(Node::ImplItem(..)) => {
1544                 self.is_bound_region_in_impl_item(suitable_region_binding_scope)
1545             }
1546             _ => return None,
1547         };
1548
1549         return Some(FreeRegionInfo {
1550             def_id: suitable_region_binding_scope,
1551             boundregion: bound_region,
1552             is_impl_item: is_impl_item,
1553         });
1554     }
1555
1556     pub fn return_type_impl_trait(
1557         &self,
1558         scope_def_id: DefId,
1559     ) -> Option<Ty<'tcx>> {
1560         // HACK: `type_of_def_id()` will fail on these (#55796), so return `None`.
1561         let hir_id = self.hir().as_local_hir_id(scope_def_id).unwrap();
1562         match self.hir().get(hir_id) {
1563             Node::Item(item) => {
1564                 match item.kind {
1565                     ItemKind::Fn(..) => { /* `type_of_def_id()` will work */ }
1566                     _ => {
1567                         return None;
1568                     }
1569                 }
1570             }
1571             _ => { /* `type_of_def_id()` will work or panic */ }
1572         }
1573
1574         let ret_ty = self.type_of(scope_def_id);
1575         match ret_ty.kind {
1576             ty::FnDef(_, _) => {
1577                 let sig = ret_ty.fn_sig(*self);
1578                 let output = self.erase_late_bound_regions(&sig.output());
1579                 if output.is_impl_trait() {
1580                     Some(output)
1581                 } else {
1582                     None
1583                 }
1584             }
1585             _ => None
1586         }
1587     }
1588
1589     // Checks if the bound region is in Impl Item.
1590     pub fn is_bound_region_in_impl_item(
1591         &self,
1592         suitable_region_binding_scope: DefId,
1593     ) -> bool {
1594         let container_id = self.associated_item(suitable_region_binding_scope)
1595             .container
1596             .id();
1597         if self.impl_trait_ref(container_id).is_some() {
1598             // For now, we do not try to target impls of traits. This is
1599             // because this message is going to suggest that the user
1600             // change the fn signature, but they may not be free to do so,
1601             // since the signature must match the trait.
1602             //
1603             // FIXME(#42706) -- in some cases, we could do better here.
1604             return true;
1605         }
1606         false
1607     }
1608
1609     /// Determines whether identifiers in the assembly have strict naming rules.
1610     /// Currently, only NVPTX* targets need it.
1611     pub fn has_strict_asm_symbol_naming(&self) -> bool {
1612         self.sess.target.target.arch.contains("nvptx")
1613     }
1614 }
1615
1616 impl<'tcx> GlobalCtxt<'tcx> {
1617     /// Calls the closure with a local `TyCtxt` using the given arena.
1618     /// `interners` is a slot passed so we can create a CtxtInterners
1619     /// with the same lifetime as `arena`.
1620     pub fn enter_local<F, R>(&'tcx self, f: F) -> R
1621     where
1622         F: FnOnce(TyCtxt<'tcx>) -> R,
1623     {
1624         let tcx = TyCtxt {
1625             gcx: self,
1626         };
1627         ty::tls::with_related_context(tcx, |icx| {
1628             let new_icx = ty::tls::ImplicitCtxt {
1629                 tcx,
1630                 query: icx.query.clone(),
1631                 diagnostics: icx.diagnostics,
1632                 layout_depth: icx.layout_depth,
1633                 task_deps: icx.task_deps,
1634             };
1635             ty::tls::enter_context(&new_icx, |_| {
1636                 f(tcx)
1637             })
1638         })
1639     }
1640 }
1641
1642 /// A trait implemented for all `X<'a>` types that can be safely and
1643 /// efficiently converted to `X<'tcx>` as long as they are part of the
1644 /// provided `TyCtxt<'tcx>`.
1645 /// This can be done, for example, for `Ty<'tcx>` or `SubstsRef<'tcx>`
1646 /// by looking them up in their respective interners.
1647 ///
1648 /// However, this is still not the best implementation as it does
1649 /// need to compare the components, even for interned values.
1650 /// It would be more efficient if `TypedArena` provided a way to
1651 /// determine whether the address is in the allocated range.
1652 ///
1653 /// `None` is returned if the value or one of the components is not part
1654 /// of the provided context.
1655 /// For `Ty`, `None` can be returned if either the type interner doesn't
1656 /// contain the `TyKind` key or if the address of the interned
1657 /// pointer differs. The latter case is possible if a primitive type,
1658 /// e.g., `()` or `u8`, was interned in a different context.
1659 pub trait Lift<'tcx>: fmt::Debug {
1660     type Lifted: fmt::Debug + 'tcx;
1661     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>;
1662 }
1663
1664 macro_rules! nop_lift {
1665     ($ty:ty => $lifted:ty) => {
1666         impl<'a, 'tcx> Lift<'tcx> for $ty {
1667                     type Lifted = $lifted;
1668                     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1669                         if tcx.interners.arena.in_arena(*self as *const _) {
1670                             Some(unsafe { mem::transmute(*self) })
1671                         } else {
1672                             None
1673                         }
1674                     }
1675                 }
1676     };
1677 }
1678
1679 macro_rules! nop_list_lift {
1680     ($ty:ty => $lifted:ty) => {
1681         impl<'a, 'tcx> Lift<'tcx> for &'a List<$ty> {
1682                     type Lifted = &'tcx List<$lifted>;
1683                     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1684                         if self.is_empty() {
1685                             return Some(List::empty());
1686                         }
1687                         if tcx.interners.arena.in_arena(*self as *const _) {
1688                             Some(unsafe { mem::transmute(*self) })
1689                         } else {
1690                             None
1691                         }
1692                     }
1693                 }
1694     };
1695 }
1696
1697 nop_lift!{Ty<'a> => Ty<'tcx>}
1698 nop_lift!{Region<'a> => Region<'tcx>}
1699 nop_lift!{Goal<'a> => Goal<'tcx>}
1700 nop_lift!{&'a Const<'a> => &'tcx Const<'tcx>}
1701
1702 nop_list_lift!{Goal<'a> => Goal<'tcx>}
1703 nop_list_lift!{Clause<'a> => Clause<'tcx>}
1704 nop_list_lift!{Ty<'a> => Ty<'tcx>}
1705 nop_list_lift!{ExistentialPredicate<'a> => ExistentialPredicate<'tcx>}
1706 nop_list_lift!{Predicate<'a> => Predicate<'tcx>}
1707 nop_list_lift!{CanonicalVarInfo => CanonicalVarInfo}
1708 nop_list_lift!{ProjectionKind => ProjectionKind}
1709
1710 // This is the impl for `&'a InternalSubsts<'a>`.
1711 nop_list_lift!{GenericArg<'a> => GenericArg<'tcx>}
1712
1713 pub mod tls {
1714     use super::{GlobalCtxt, TyCtxt, ptr_eq};
1715
1716     use std::fmt;
1717     use std::mem;
1718     use syntax_pos;
1719     use crate::ty::query;
1720     use errors::{Diagnostic, TRACK_DIAGNOSTICS};
1721     use rustc_data_structures::OnDrop;
1722     use rustc_data_structures::sync::{self, Lrc, Lock};
1723     use rustc_data_structures::thin_vec::ThinVec;
1724     use crate::dep_graph::TaskDeps;
1725
1726     #[cfg(not(parallel_compiler))]
1727     use std::cell::Cell;
1728
1729     #[cfg(parallel_compiler)]
1730     use rustc_rayon_core as rayon_core;
1731
1732     /// This is the implicit state of rustc. It contains the current
1733     /// `TyCtxt` and query. It is updated when creating a local interner or
1734     /// executing a new query. Whenever there's a `TyCtxt` value available
1735     /// you should also have access to an `ImplicitCtxt` through the functions
1736     /// in this module.
1737     #[derive(Clone)]
1738     pub struct ImplicitCtxt<'a, 'tcx> {
1739         /// The current `TyCtxt`. Initially created by `enter_global` and updated
1740         /// by `enter_local` with a new local interner.
1741         pub tcx: TyCtxt<'tcx>,
1742
1743         /// The current query job, if any. This is updated by `JobOwner::start` in
1744         /// `ty::query::plumbing` when executing a query.
1745         pub query: Option<Lrc<query::QueryJob<'tcx>>>,
1746
1747         /// Where to store diagnostics for the current query job, if any.
1748         /// This is updated by `JobOwner::start` in `ty::query::plumbing` when executing a query.
1749         pub diagnostics: Option<&'a Lock<ThinVec<Diagnostic>>>,
1750
1751         /// Used to prevent layout from recursing too deeply.
1752         pub layout_depth: usize,
1753
1754         /// The current dep graph task. This is used to add dependencies to queries
1755         /// when executing them.
1756         pub task_deps: Option<&'a Lock<TaskDeps>>,
1757     }
1758
1759     /// Sets Rayon's thread-local variable, which is preserved for Rayon jobs
1760     /// to `value` during the call to `f`. It is restored to its previous value after.
1761     /// This is used to set the pointer to the new `ImplicitCtxt`.
1762     #[cfg(parallel_compiler)]
1763     #[inline]
1764     fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
1765         rayon_core::tlv::with(value, f)
1766     }
1767
1768     /// Gets Rayon's thread-local variable, which is preserved for Rayon jobs.
1769     /// This is used to get the pointer to the current `ImplicitCtxt`.
1770     #[cfg(parallel_compiler)]
1771     #[inline]
1772     fn get_tlv() -> usize {
1773         rayon_core::tlv::get()
1774     }
1775
1776     #[cfg(not(parallel_compiler))]
1777     thread_local! {
1778         /// A thread local variable that stores a pointer to the current `ImplicitCtxt`.
1779         static TLV: Cell<usize> = Cell::new(0);
1780     }
1781
1782     /// Sets TLV to `value` during the call to `f`.
1783     /// It is restored to its previous value after.
1784     /// This is used to set the pointer to the new `ImplicitCtxt`.
1785     #[cfg(not(parallel_compiler))]
1786     #[inline]
1787     fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
1788         let old = get_tlv();
1789         let _reset = OnDrop(move || TLV.with(|tlv| tlv.set(old)));
1790         TLV.with(|tlv| tlv.set(value));
1791         f()
1792     }
1793
1794     /// Gets the pointer to the current `ImplicitCtxt`.
1795     #[cfg(not(parallel_compiler))]
1796     fn get_tlv() -> usize {
1797         TLV.with(|tlv| tlv.get())
1798     }
1799
1800     /// This is a callback from libsyntax as it cannot access the implicit state
1801     /// in librustc otherwise.
1802     fn span_debug(span: syntax_pos::Span, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1803         with_opt(|tcx| {
1804             if let Some(tcx) = tcx {
1805                 write!(f, "{}", tcx.sess.source_map().span_to_string(span))
1806             } else {
1807                 syntax_pos::default_span_debug(span, f)
1808             }
1809         })
1810     }
1811
1812     /// This is a callback from libsyntax as it cannot access the implicit state
1813     /// in librustc otherwise. It is used to when diagnostic messages are
1814     /// emitted and stores them in the current query, if there is one.
1815     fn track_diagnostic(diagnostic: &Diagnostic) {
1816         with_context_opt(|icx| {
1817             if let Some(icx) = icx {
1818                 if let Some(ref diagnostics) = icx.diagnostics {
1819                     let mut diagnostics = diagnostics.lock();
1820                     diagnostics.extend(Some(diagnostic.clone()));
1821                 }
1822             }
1823         })
1824     }
1825
1826     /// Sets up the callbacks from libsyntax on the current thread.
1827     pub fn with_thread_locals<F, R>(f: F) -> R
1828         where F: FnOnce() -> R
1829     {
1830         syntax_pos::SPAN_DEBUG.with(|span_dbg| {
1831             let original_span_debug = span_dbg.get();
1832             span_dbg.set(span_debug);
1833
1834             let _on_drop = OnDrop(move || {
1835                 span_dbg.set(original_span_debug);
1836             });
1837
1838             TRACK_DIAGNOSTICS.with(|current| {
1839                 let original = current.get();
1840                 current.set(track_diagnostic);
1841
1842                 let _on_drop = OnDrop(move || {
1843                     current.set(original);
1844                 });
1845
1846                 f()
1847             })
1848         })
1849     }
1850
1851     /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`.
1852     #[inline]
1853     pub fn enter_context<'a, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'tcx>, f: F) -> R
1854     where
1855         F: FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
1856     {
1857         set_tlv(context as *const _ as usize, || {
1858             f(&context)
1859         })
1860     }
1861
1862     /// Enters `GlobalCtxt` by setting up libsyntax callbacks and
1863     /// creating a initial `TyCtxt` and `ImplicitCtxt`.
1864     /// This happens once per rustc session and `TyCtxt`s only exists
1865     /// inside the `f` function.
1866     pub fn enter_global<'tcx, F, R>(gcx: &'tcx GlobalCtxt<'tcx>, f: F) -> R
1867     where
1868         F: FnOnce(TyCtxt<'tcx>) -> R,
1869     {
1870         // Update `GCX_PTR` to indicate there's a `GlobalCtxt` available.
1871         GCX_PTR.with(|lock| {
1872             *lock.lock() = gcx as *const _ as usize;
1873         });
1874         // Set `GCX_PTR` back to 0 when we exit.
1875         let _on_drop = OnDrop(move || {
1876             GCX_PTR.with(|lock| *lock.lock() = 0);
1877         });
1878
1879         let tcx = TyCtxt {
1880             gcx,
1881         };
1882         let icx = ImplicitCtxt {
1883             tcx,
1884             query: None,
1885             diagnostics: None,
1886             layout_depth: 0,
1887             task_deps: None,
1888         };
1889         enter_context(&icx, |_| {
1890             f(tcx)
1891         })
1892     }
1893
1894     scoped_thread_local! {
1895         /// Stores a pointer to the `GlobalCtxt` if one is available.
1896         /// This is used to access the `GlobalCtxt` in the deadlock handler given to Rayon.
1897         pub static GCX_PTR: Lock<usize>
1898     }
1899
1900     /// Creates a `TyCtxt` and `ImplicitCtxt` based on the `GCX_PTR` thread local.
1901     /// This is used in the deadlock handler.
1902     pub unsafe fn with_global<F, R>(f: F) -> R
1903     where
1904         F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
1905     {
1906         let gcx = GCX_PTR.with(|lock| *lock.lock());
1907         assert!(gcx != 0);
1908         let gcx = &*(gcx as *const GlobalCtxt<'_>);
1909         let tcx = TyCtxt {
1910             gcx,
1911         };
1912         let icx = ImplicitCtxt {
1913             query: None,
1914             diagnostics: None,
1915             tcx,
1916             layout_depth: 0,
1917             task_deps: None,
1918         };
1919         enter_context(&icx, |_| f(tcx))
1920     }
1921
1922     /// Allows access to the current `ImplicitCtxt` in a closure if one is available.
1923     #[inline]
1924     pub fn with_context_opt<F, R>(f: F) -> R
1925     where
1926         F: for<'a, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'tcx>>) -> R,
1927     {
1928         let context = get_tlv();
1929         if context == 0 {
1930             f(None)
1931         } else {
1932             // We could get a `ImplicitCtxt` pointer from another thread.
1933             // Ensure that `ImplicitCtxt` is `Sync`.
1934             sync::assert_sync::<ImplicitCtxt<'_, '_>>();
1935
1936             unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) }
1937         }
1938     }
1939
1940     /// Allows access to the current `ImplicitCtxt`.
1941     /// Panics if there is no `ImplicitCtxt` available.
1942     #[inline]
1943     pub fn with_context<F, R>(f: F) -> R
1944     where
1945         F: for<'a, 'tcx> FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
1946     {
1947         with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
1948     }
1949
1950     /// Allows access to the current `ImplicitCtxt` whose tcx field has the same global
1951     /// interner as the tcx argument passed in. This means the closure is given an `ImplicitCtxt`
1952     /// with the same `'tcx` lifetime as the `TyCtxt` passed in.
1953     /// This will panic if you pass it a `TyCtxt` which has a different global interner from
1954     /// the current `ImplicitCtxt`'s `tcx` field.
1955     #[inline]
1956     pub fn with_related_context<'tcx, F, R>(tcx: TyCtxt<'tcx>, f: F) -> R
1957     where
1958         F: FnOnce(&ImplicitCtxt<'_, 'tcx>) -> R,
1959     {
1960         with_context(|context| {
1961             unsafe {
1962                 assert!(ptr_eq(context.tcx.gcx, tcx.gcx));
1963                 let context: &ImplicitCtxt<'_, '_> = mem::transmute(context);
1964                 f(context)
1965             }
1966         })
1967     }
1968
1969     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
1970     /// Panics if there is no `ImplicitCtxt` available.
1971     #[inline]
1972     pub fn with<F, R>(f: F) -> R
1973     where
1974         F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
1975     {
1976         with_context(|context| f(context.tcx))
1977     }
1978
1979     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
1980     /// The closure is passed None if there is no `ImplicitCtxt` available.
1981     #[inline]
1982     pub fn with_opt<F, R>(f: F) -> R
1983     where
1984         F: for<'tcx> FnOnce(Option<TyCtxt<'tcx>>) -> R,
1985     {
1986         with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
1987     }
1988 }
1989
1990 macro_rules! sty_debug_print {
1991     ($ctxt: expr, $($variant: ident),*) => {{
1992         // Curious inner module to allow variant names to be used as
1993         // variable names.
1994         #[allow(non_snake_case)]
1995         mod inner {
1996             use crate::ty::{self, TyCtxt};
1997             use crate::ty::context::Interned;
1998
1999             #[derive(Copy, Clone)]
2000             struct DebugStat {
2001                 total: usize,
2002                 lt_infer: usize,
2003                 ty_infer: usize,
2004                 ct_infer: usize,
2005                 all_infer: usize,
2006             }
2007
2008             pub fn go(tcx: TyCtxt<'_>) {
2009                 let mut total = DebugStat {
2010                     total: 0,
2011                     lt_infer: 0,
2012                     ty_infer: 0,
2013                     ct_infer: 0,
2014                     all_infer: 0,
2015                 };
2016                 $(let mut $variant = total;)*
2017
2018                 let shards = tcx.interners.type_.lock_shards();
2019                 let types = shards.iter().flat_map(|shard| shard.keys());
2020                 for &Interned(t) in types {
2021                     let variant = match t.kind {
2022                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
2023                             ty::Float(..) | ty::Str | ty::Never => continue,
2024                         ty::Error => /* unimportant */ continue,
2025                         $(ty::$variant(..) => &mut $variant,)*
2026                     };
2027                     let lt = t.flags.intersects(ty::TypeFlags::HAS_RE_INFER);
2028                     let ty = t.flags.intersects(ty::TypeFlags::HAS_TY_INFER);
2029                     let ct = t.flags.intersects(ty::TypeFlags::HAS_CT_INFER);
2030
2031                     variant.total += 1;
2032                     total.total += 1;
2033                     if lt { total.lt_infer += 1; variant.lt_infer += 1 }
2034                     if ty { total.ty_infer += 1; variant.ty_infer += 1 }
2035                     if ct { total.ct_infer += 1; variant.ct_infer += 1 }
2036                     if lt && ty && ct { total.all_infer += 1; variant.all_infer += 1 }
2037                 }
2038                 println!("Ty interner             total           ty lt ct all");
2039                 $(println!("    {:18}: {uses:6} {usespc:4.1}%, \
2040                             {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
2041                     stringify!($variant),
2042                     uses = $variant.total,
2043                     usespc = $variant.total as f64 * 100.0 / total.total as f64,
2044                     ty = $variant.ty_infer as f64 * 100.0  / total.total as f64,
2045                     lt = $variant.lt_infer as f64 * 100.0  / total.total as f64,
2046                     ct = $variant.ct_infer as f64 * 100.0  / total.total as f64,
2047                     all = $variant.all_infer as f64 * 100.0  / total.total as f64);
2048                 )*
2049                 println!("                  total {uses:6}        \
2050                           {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
2051                     uses = total.total,
2052                     ty = total.ty_infer as f64 * 100.0  / total.total as f64,
2053                     lt = total.lt_infer as f64 * 100.0  / total.total as f64,
2054                     ct = total.ct_infer as f64 * 100.0  / total.total as f64,
2055                     all = total.all_infer as f64 * 100.0  / total.total as f64)
2056             }
2057         }
2058
2059         inner::go($ctxt)
2060     }}
2061 }
2062
2063 impl<'tcx> TyCtxt<'tcx> {
2064     pub fn print_debug_stats(self) {
2065         sty_debug_print!(
2066             self,
2067             Adt, Array, Slice, RawPtr, Ref, FnDef, FnPtr, Placeholder,
2068             Generator, GeneratorWitness, Dynamic, Closure, Tuple, Bound,
2069             Param, Infer, UnnormalizedProjection, Projection, Opaque, Foreign);
2070
2071         println!("InternalSubsts interner: #{}", self.interners.substs.len());
2072         println!("Region interner: #{}", self.interners.region.len());
2073         println!("Stability interner: #{}", self.stability_interner.len());
2074         println!("Allocation interner: #{}", self.allocation_interner.len());
2075         println!("Layout interner: #{}", self.layout_interner.len());
2076     }
2077 }
2078
2079
2080 /// An entry in an interner.
2081 struct Interned<'tcx, T: ?Sized>(&'tcx T);
2082
2083 impl<'tcx, T: 'tcx+?Sized> Clone for Interned<'tcx, T> {
2084     fn clone(&self) -> Self {
2085         Interned(self.0)
2086     }
2087 }
2088 impl<'tcx, T: 'tcx+?Sized> Copy for Interned<'tcx, T> {}
2089
2090 // N.B., an `Interned<Ty>` compares and hashes as a `TyKind`.
2091 impl<'tcx> PartialEq for Interned<'tcx, TyS<'tcx>> {
2092     fn eq(&self, other: &Interned<'tcx, TyS<'tcx>>) -> bool {
2093         self.0.kind == other.0.kind
2094     }
2095 }
2096
2097 impl<'tcx> Eq for Interned<'tcx, TyS<'tcx>> {}
2098
2099 impl<'tcx> Hash for Interned<'tcx, TyS<'tcx>> {
2100     fn hash<H: Hasher>(&self, s: &mut H) {
2101         self.0.kind.hash(s)
2102     }
2103 }
2104
2105 #[allow(rustc::usage_of_ty_tykind)]
2106 impl<'tcx> Borrow<TyKind<'tcx>> for Interned<'tcx, TyS<'tcx>> {
2107     fn borrow<'a>(&'a self) -> &'a TyKind<'tcx> {
2108         &self.0.kind
2109     }
2110 }
2111
2112 // N.B., an `Interned<List<T>>` compares and hashes as its elements.
2113 impl<'tcx, T: PartialEq> PartialEq for Interned<'tcx, List<T>> {
2114     fn eq(&self, other: &Interned<'tcx, List<T>>) -> bool {
2115         self.0[..] == other.0[..]
2116     }
2117 }
2118
2119 impl<'tcx, T: Eq> Eq for Interned<'tcx, List<T>> {}
2120
2121 impl<'tcx, T: Hash> Hash for Interned<'tcx, List<T>> {
2122     fn hash<H: Hasher>(&self, s: &mut H) {
2123         self.0[..].hash(s)
2124     }
2125 }
2126
2127 impl<'tcx> Borrow<[Ty<'tcx>]> for Interned<'tcx, List<Ty<'tcx>>> {
2128     fn borrow<'a>(&'a self) -> &'a [Ty<'tcx>] {
2129         &self.0[..]
2130     }
2131 }
2132
2133 impl<'tcx> Borrow<[CanonicalVarInfo]> for Interned<'tcx, List<CanonicalVarInfo>> {
2134     fn borrow(&self) -> &[CanonicalVarInfo] {
2135         &self.0[..]
2136     }
2137 }
2138
2139 impl<'tcx> Borrow<[GenericArg<'tcx>]> for Interned<'tcx, InternalSubsts<'tcx>> {
2140     fn borrow<'a>(&'a self) -> &'a [GenericArg<'tcx>] {
2141         &self.0[..]
2142     }
2143 }
2144
2145 impl<'tcx> Borrow<[ProjectionKind]>
2146     for Interned<'tcx, List<ProjectionKind>> {
2147     fn borrow(&self) -> &[ProjectionKind] {
2148         &self.0[..]
2149     }
2150 }
2151
2152 impl<'tcx> Borrow<RegionKind> for Interned<'tcx, RegionKind> {
2153     fn borrow(&self) -> &RegionKind {
2154         &self.0
2155     }
2156 }
2157
2158 impl<'tcx> Borrow<GoalKind<'tcx>> for Interned<'tcx, GoalKind<'tcx>> {
2159     fn borrow<'a>(&'a self) -> &'a GoalKind<'tcx> {
2160         &self.0
2161     }
2162 }
2163
2164 impl<'tcx> Borrow<[ExistentialPredicate<'tcx>]>
2165     for Interned<'tcx, List<ExistentialPredicate<'tcx>>>
2166 {
2167     fn borrow<'a>(&'a self) -> &'a [ExistentialPredicate<'tcx>] {
2168         &self.0[..]
2169     }
2170 }
2171
2172 impl<'tcx> Borrow<[Predicate<'tcx>]> for Interned<'tcx, List<Predicate<'tcx>>> {
2173     fn borrow<'a>(&'a self) -> &'a [Predicate<'tcx>] {
2174         &self.0[..]
2175     }
2176 }
2177
2178 impl<'tcx> Borrow<Const<'tcx>> for Interned<'tcx, Const<'tcx>> {
2179     fn borrow<'a>(&'a self) -> &'a Const<'tcx> {
2180         &self.0
2181     }
2182 }
2183
2184 impl<'tcx> Borrow<[Clause<'tcx>]> for Interned<'tcx, List<Clause<'tcx>>> {
2185     fn borrow<'a>(&'a self) -> &'a [Clause<'tcx>] {
2186         &self.0[..]
2187     }
2188 }
2189
2190 impl<'tcx> Borrow<[Goal<'tcx>]> for Interned<'tcx, List<Goal<'tcx>>> {
2191     fn borrow<'a>(&'a self) -> &'a [Goal<'tcx>] {
2192         &self.0[..]
2193     }
2194 }
2195
2196 macro_rules! direct_interners {
2197     ($($name:ident: $method:ident($ty:ty)),+) => {
2198         $(impl<'tcx> PartialEq for Interned<'tcx, $ty> {
2199             fn eq(&self, other: &Self) -> bool {
2200                 self.0 == other.0
2201             }
2202         }
2203
2204         impl<'tcx> Eq for Interned<'tcx, $ty> {}
2205
2206         impl<'tcx> Hash for Interned<'tcx, $ty> {
2207             fn hash<H: Hasher>(&self, s: &mut H) {
2208                 self.0.hash(s)
2209             }
2210         }
2211
2212         impl<'tcx> TyCtxt<'tcx> {
2213             pub fn $method(self, v: $ty) -> &'tcx $ty {
2214                 self.interners.$name.intern_ref(&v, || {
2215                     Interned(self.interners.arena.alloc(v))
2216                 }).0
2217             }
2218         })+
2219     }
2220 }
2221
2222 pub fn keep_local<'tcx, T: ty::TypeFoldable<'tcx>>(x: &T) -> bool {
2223     x.has_type_flags(ty::TypeFlags::KEEP_IN_LOCAL_TCX)
2224 }
2225
2226 direct_interners!(
2227     region: mk_region(RegionKind),
2228     goal: mk_goal(GoalKind<'tcx>),
2229     const_: mk_const(Const<'tcx>)
2230 );
2231
2232 macro_rules! slice_interners {
2233     ($($field:ident: $method:ident($ty:ty)),+) => (
2234         $(impl<'tcx> TyCtxt<'tcx> {
2235             pub fn $method(self, v: &[$ty]) -> &'tcx List<$ty> {
2236                 self.interners.$field.intern_ref(v, || {
2237                     Interned(List::from_arena(&self.interners.arena, v))
2238                 }).0
2239             }
2240         })+
2241     );
2242 }
2243
2244 slice_interners!(
2245     type_list: _intern_type_list(Ty<'tcx>),
2246     substs: _intern_substs(GenericArg<'tcx>),
2247     canonical_var_infos: _intern_canonical_var_infos(CanonicalVarInfo),
2248     existential_predicates: _intern_existential_predicates(ExistentialPredicate<'tcx>),
2249     predicates: _intern_predicates(Predicate<'tcx>),
2250     clauses: _intern_clauses(Clause<'tcx>),
2251     goal_list: _intern_goals(Goal<'tcx>),
2252     projs: _intern_projs(ProjectionKind)
2253 );
2254
2255 impl<'tcx> TyCtxt<'tcx> {
2256     /// Given a `fn` type, returns an equivalent `unsafe fn` type;
2257     /// that is, a `fn` type that is equivalent in every way for being
2258     /// unsafe.
2259     pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
2260         assert_eq!(sig.unsafety(), hir::Unsafety::Normal);
2261         self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig {
2262             unsafety: hir::Unsafety::Unsafe,
2263             ..sig
2264         }))
2265     }
2266
2267     /// Given a closure signature `sig`, returns an equivalent `fn`
2268     /// type with the same signature. Detuples and so forth -- so
2269     /// e.g., if we have a sig with `Fn<(u32, i32)>` then you would get
2270     /// a `fn(u32, i32)`.
2271     /// `unsafety` determines the unsafety of the `fn` type. If you pass
2272     /// `hir::Unsafety::Unsafe` in the previous example, then you would get
2273     /// an `unsafe fn (u32, i32)`.
2274     /// It cannot convert a closure that requires unsafe.
2275     pub fn coerce_closure_fn_ty(self, sig: PolyFnSig<'tcx>, unsafety: hir::Unsafety) -> Ty<'tcx> {
2276         let converted_sig = sig.map_bound(|s| {
2277             let params_iter = match s.inputs()[0].kind {
2278                 ty::Tuple(params) => {
2279                     params.into_iter().map(|k| k.expect_ty())
2280                 }
2281                 _ => bug!(),
2282             };
2283             self.mk_fn_sig(
2284                 params_iter,
2285                 s.output(),
2286                 s.c_variadic,
2287                 unsafety,
2288                 abi::Abi::Rust,
2289             )
2290         });
2291
2292         self.mk_fn_ptr(converted_sig)
2293     }
2294
2295     #[allow(rustc::usage_of_ty_tykind)]
2296     #[inline]
2297     pub fn mk_ty(&self, st: TyKind<'tcx>) -> Ty<'tcx> {
2298         self.interners.intern_ty(st)
2299     }
2300
2301     pub fn mk_mach_int(self, tm: ast::IntTy) -> Ty<'tcx> {
2302         match tm {
2303             ast::IntTy::Isize   => self.types.isize,
2304             ast::IntTy::I8   => self.types.i8,
2305             ast::IntTy::I16  => self.types.i16,
2306             ast::IntTy::I32  => self.types.i32,
2307             ast::IntTy::I64  => self.types.i64,
2308             ast::IntTy::I128  => self.types.i128,
2309         }
2310     }
2311
2312     pub fn mk_mach_uint(self, tm: ast::UintTy) -> Ty<'tcx> {
2313         match tm {
2314             ast::UintTy::Usize   => self.types.usize,
2315             ast::UintTy::U8   => self.types.u8,
2316             ast::UintTy::U16  => self.types.u16,
2317             ast::UintTy::U32  => self.types.u32,
2318             ast::UintTy::U64  => self.types.u64,
2319             ast::UintTy::U128  => self.types.u128,
2320         }
2321     }
2322
2323     pub fn mk_mach_float(self, tm: ast::FloatTy) -> Ty<'tcx> {
2324         match tm {
2325             ast::FloatTy::F32  => self.types.f32,
2326             ast::FloatTy::F64  => self.types.f64,
2327         }
2328     }
2329
2330     #[inline]
2331     pub fn mk_str(self) -> Ty<'tcx> {
2332         self.mk_ty(Str)
2333     }
2334
2335     #[inline]
2336     pub fn mk_static_str(self) -> Ty<'tcx> {
2337         self.mk_imm_ref(self.lifetimes.re_static, self.mk_str())
2338     }
2339
2340     #[inline]
2341     pub fn mk_adt(self, def: &'tcx AdtDef, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2342         // Take a copy of substs so that we own the vectors inside.
2343         self.mk_ty(Adt(def, substs))
2344     }
2345
2346     #[inline]
2347     pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {
2348         self.mk_ty(Foreign(def_id))
2349     }
2350
2351     fn mk_generic_adt(self, wrapper_def_id: DefId, ty_param: Ty<'tcx>) -> Ty<'tcx> {
2352         let adt_def = self.adt_def(wrapper_def_id);
2353         let substs = InternalSubsts::for_item(self, wrapper_def_id, |param, substs| {
2354             match param.kind {
2355                 GenericParamDefKind::Lifetime |
2356                 GenericParamDefKind::Const => {
2357                     bug!()
2358                 }
2359                 GenericParamDefKind::Type { has_default, .. } => {
2360                     if param.index == 0 {
2361                         ty_param.into()
2362                     } else {
2363                         assert!(has_default);
2364                         self.type_of(param.def_id).subst(self, substs).into()
2365                     }
2366                 }
2367             }
2368         });
2369         self.mk_ty(Adt(adt_def, substs))
2370     }
2371
2372     #[inline]
2373     pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2374         let def_id = self.require_lang_item(lang_items::OwnedBoxLangItem, None);
2375         self.mk_generic_adt(def_id, ty)
2376     }
2377
2378     #[inline]
2379     pub fn mk_lang_item(self, ty: Ty<'tcx>, item: lang_items::LangItem)  -> Option<Ty<'tcx>> {
2380         let def_id = self.lang_items().require(item).ok()?;
2381         Some(self.mk_generic_adt(def_id, ty))
2382     }
2383
2384     #[inline]
2385     pub fn mk_maybe_uninit(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2386         let def_id = self.require_lang_item(lang_items::MaybeUninitLangItem, None);
2387         self.mk_generic_adt(def_id, ty)
2388     }
2389
2390     #[inline]
2391     pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
2392         self.mk_ty(RawPtr(tm))
2393     }
2394
2395     #[inline]
2396     pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
2397         self.mk_ty(Ref(r, tm.ty, tm.mutbl))
2398     }
2399
2400     #[inline]
2401     pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
2402         self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutMutable})
2403     }
2404
2405     #[inline]
2406     pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
2407         self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutImmutable})
2408     }
2409
2410     #[inline]
2411     pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2412         self.mk_ptr(TypeAndMut {ty: ty, mutbl: hir::MutMutable})
2413     }
2414
2415     #[inline]
2416     pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2417         self.mk_ptr(TypeAndMut {ty: ty, mutbl: hir::MutImmutable})
2418     }
2419
2420     #[inline]
2421     pub fn mk_nil_ptr(self) -> Ty<'tcx> {
2422         self.mk_imm_ptr(self.mk_unit())
2423     }
2424
2425     #[inline]
2426     pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
2427         self.mk_ty(Array(ty, ty::Const::from_usize(self, n)))
2428     }
2429
2430     #[inline]
2431     pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2432         self.mk_ty(Slice(ty))
2433     }
2434
2435     #[inline]
2436     pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
2437         let kinds: Vec<_> = ts.into_iter().map(|&t| GenericArg::from(t)).collect();
2438         self.mk_ty(Tuple(self.intern_substs(&kinds)))
2439     }
2440
2441     pub fn mk_tup<I: InternAs<[Ty<'tcx>], Ty<'tcx>>>(self, iter: I) -> I::Output {
2442         iter.intern_with(|ts| {
2443             let kinds: Vec<_> = ts.into_iter().map(|&t| GenericArg::from(t)).collect();
2444             self.mk_ty(Tuple(self.intern_substs(&kinds)))
2445         })
2446     }
2447
2448     #[inline]
2449     pub fn mk_unit(self) -> Ty<'tcx> {
2450         self.types.unit
2451     }
2452
2453     #[inline]
2454     pub fn mk_diverging_default(self) -> Ty<'tcx> {
2455         if self.features().never_type {
2456             self.types.never
2457         } else {
2458             self.intern_tup(&[])
2459         }
2460     }
2461
2462     #[inline]
2463     pub fn mk_bool(self) -> Ty<'tcx> {
2464         self.mk_ty(Bool)
2465     }
2466
2467     #[inline]
2468     pub fn mk_fn_def(self, def_id: DefId,
2469                      substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2470         self.mk_ty(FnDef(def_id, substs))
2471     }
2472
2473     #[inline]
2474     pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
2475         self.mk_ty(FnPtr(fty))
2476     }
2477
2478     #[inline]
2479     pub fn mk_dynamic(
2480         self,
2481         obj: ty::Binder<&'tcx List<ExistentialPredicate<'tcx>>>,
2482         reg: ty::Region<'tcx>
2483     ) -> Ty<'tcx> {
2484         self.mk_ty(Dynamic(obj, reg))
2485     }
2486
2487     #[inline]
2488     pub fn mk_projection(self,
2489                          item_def_id: DefId,
2490                          substs: SubstsRef<'tcx>)
2491         -> Ty<'tcx> {
2492             self.mk_ty(Projection(ProjectionTy {
2493                 item_def_id,
2494                 substs,
2495             }))
2496         }
2497
2498     #[inline]
2499     pub fn mk_closure(self, closure_id: DefId, closure_substs: ClosureSubsts<'tcx>)
2500                       -> Ty<'tcx> {
2501         self.mk_ty(Closure(closure_id, closure_substs))
2502     }
2503
2504     #[inline]
2505     pub fn mk_generator(self,
2506                         id: DefId,
2507                         generator_substs: GeneratorSubsts<'tcx>,
2508                         movability: hir::GeneratorMovability)
2509                         -> Ty<'tcx> {
2510         self.mk_ty(Generator(id, generator_substs, movability))
2511     }
2512
2513     #[inline]
2514     pub fn mk_generator_witness(self, types: ty::Binder<&'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {
2515         self.mk_ty(GeneratorWitness(types))
2516     }
2517
2518     #[inline]
2519     pub fn mk_ty_var(self, v: TyVid) -> Ty<'tcx> {
2520         self.mk_ty_infer(TyVar(v))
2521     }
2522
2523     #[inline]
2524     pub fn mk_const_var(self, v: ConstVid<'tcx>, ty: Ty<'tcx>) -> &'tcx Const<'tcx> {
2525         self.mk_const(ty::Const {
2526             val: ConstValue::Infer(InferConst::Var(v)),
2527             ty,
2528         })
2529     }
2530
2531     #[inline]
2532     pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {
2533         self.mk_ty_infer(IntVar(v))
2534     }
2535
2536     #[inline]
2537     pub fn mk_float_var(self, v: FloatVid) -> Ty<'tcx> {
2538         self.mk_ty_infer(FloatVar(v))
2539     }
2540
2541     #[inline]
2542     pub fn mk_ty_infer(self, it: InferTy) -> Ty<'tcx> {
2543         self.mk_ty(Infer(it))
2544     }
2545
2546     #[inline]
2547     pub fn mk_const_infer(
2548         self,
2549         ic: InferConst<'tcx>,
2550         ty: Ty<'tcx>,
2551     ) -> &'tcx ty::Const<'tcx> {
2552         self.mk_const(ty::Const {
2553             val: ConstValue::Infer(ic),
2554             ty,
2555         })
2556     }
2557
2558     #[inline]
2559     pub fn mk_ty_param(self, index: u32, name: InternedString) -> Ty<'tcx> {
2560         self.mk_ty(Param(ParamTy { index, name: name }))
2561     }
2562
2563     #[inline]
2564     pub fn mk_const_param(
2565         self,
2566         index: u32,
2567         name: InternedString,
2568         ty: Ty<'tcx>
2569     ) -> &'tcx Const<'tcx> {
2570         self.mk_const(ty::Const {
2571             val: ConstValue::Param(ParamConst { index, name }),
2572             ty,
2573         })
2574     }
2575
2576
2577     pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
2578         match param.kind {
2579             GenericParamDefKind::Lifetime => {
2580                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
2581             }
2582             GenericParamDefKind::Type { .. } => self.mk_ty_param(param.index, param.name).into(),
2583             GenericParamDefKind::Const => {
2584                 self.mk_const_param(param.index, param.name, self.type_of(param.def_id)).into()
2585             }
2586         }
2587     }
2588
2589     #[inline]
2590     pub fn mk_opaque(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2591         self.mk_ty(Opaque(def_id, substs))
2592     }
2593
2594     pub fn intern_existential_predicates(self, eps: &[ExistentialPredicate<'tcx>])
2595         -> &'tcx List<ExistentialPredicate<'tcx>> {
2596         assert!(!eps.is_empty());
2597         assert!(eps.windows(2).all(|w| w[0].stable_cmp(self, &w[1]) != Ordering::Greater));
2598         self._intern_existential_predicates(eps)
2599     }
2600
2601     pub fn intern_predicates(self, preds: &[Predicate<'tcx>])
2602         -> &'tcx List<Predicate<'tcx>> {
2603         // FIXME consider asking the input slice to be sorted to avoid
2604         // re-interning permutations, in which case that would be asserted
2605         // here.
2606         if preds.len() == 0 {
2607             // The macro-generated method below asserts we don't intern an empty slice.
2608             List::empty()
2609         } else {
2610             self._intern_predicates(preds)
2611         }
2612     }
2613
2614     pub fn intern_type_list(self, ts: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
2615         if ts.len() == 0 {
2616             List::empty()
2617         } else {
2618             self._intern_type_list(ts)
2619         }
2620     }
2621
2622     pub fn intern_substs(self, ts: &[GenericArg<'tcx>]) -> &'tcx List<GenericArg<'tcx>> {
2623         if ts.len() == 0 {
2624             List::empty()
2625         } else {
2626             self._intern_substs(ts)
2627         }
2628     }
2629
2630     pub fn intern_projs(self, ps: &[ProjectionKind]) -> &'tcx List<ProjectionKind> {
2631         if ps.len() == 0 {
2632             List::empty()
2633         } else {
2634             self._intern_projs(ps)
2635         }
2636     }
2637
2638     pub fn intern_canonical_var_infos(self, ts: &[CanonicalVarInfo]) -> CanonicalVarInfos<'tcx> {
2639         if ts.len() == 0 {
2640             List::empty()
2641         } else {
2642             self._intern_canonical_var_infos(ts)
2643         }
2644     }
2645
2646     pub fn intern_clauses(self, ts: &[Clause<'tcx>]) -> Clauses<'tcx> {
2647         if ts.len() == 0 {
2648             List::empty()
2649         } else {
2650             self._intern_clauses(ts)
2651         }
2652     }
2653
2654     pub fn intern_goals(self, ts: &[Goal<'tcx>]) -> Goals<'tcx> {
2655         if ts.len() == 0 {
2656             List::empty()
2657         } else {
2658             self._intern_goals(ts)
2659         }
2660     }
2661
2662     pub fn mk_fn_sig<I>(self,
2663                         inputs: I,
2664                         output: I::Item,
2665                         c_variadic: bool,
2666                         unsafety: hir::Unsafety,
2667                         abi: abi::Abi)
2668         -> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
2669     where
2670         I: Iterator<Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>,
2671     {
2672         inputs.chain(iter::once(output)).intern_with(|xs| ty::FnSig {
2673             inputs_and_output: self.intern_type_list(xs),
2674             c_variadic, unsafety, abi
2675         })
2676     }
2677
2678     pub fn mk_existential_predicates<I: InternAs<[ExistentialPredicate<'tcx>],
2679                                      &'tcx List<ExistentialPredicate<'tcx>>>>(self, iter: I)
2680                                      -> I::Output {
2681         iter.intern_with(|xs| self.intern_existential_predicates(xs))
2682     }
2683
2684     pub fn mk_predicates<I: InternAs<[Predicate<'tcx>],
2685                                      &'tcx List<Predicate<'tcx>>>>(self, iter: I)
2686                                      -> I::Output {
2687         iter.intern_with(|xs| self.intern_predicates(xs))
2688     }
2689
2690     pub fn mk_type_list<I: InternAs<[Ty<'tcx>],
2691                         &'tcx List<Ty<'tcx>>>>(self, iter: I) -> I::Output {
2692         iter.intern_with(|xs| self.intern_type_list(xs))
2693     }
2694
2695     pub fn mk_substs<I: InternAs<[GenericArg<'tcx>],
2696                      &'tcx List<GenericArg<'tcx>>>>(self, iter: I) -> I::Output {
2697         iter.intern_with(|xs| self.intern_substs(xs))
2698     }
2699
2700     pub fn mk_substs_trait(self,
2701                      self_ty: Ty<'tcx>,
2702                      rest: &[GenericArg<'tcx>])
2703                     -> SubstsRef<'tcx>
2704     {
2705         self.mk_substs(iter::once(self_ty.into()).chain(rest.iter().cloned()))
2706     }
2707
2708     pub fn mk_clauses<I: InternAs<[Clause<'tcx>], Clauses<'tcx>>>(self, iter: I) -> I::Output {
2709         iter.intern_with(|xs| self.intern_clauses(xs))
2710     }
2711
2712     pub fn mk_goals<I: InternAs<[Goal<'tcx>], Goals<'tcx>>>(self, iter: I) -> I::Output {
2713         iter.intern_with(|xs| self.intern_goals(xs))
2714     }
2715
2716     pub fn lint_hir<S: Into<MultiSpan>>(self,
2717                                         lint: &'static Lint,
2718                                         hir_id: HirId,
2719                                         span: S,
2720                                         msg: &str) {
2721         self.struct_span_lint_hir(lint, hir_id, span.into(), msg).emit()
2722     }
2723
2724     pub fn lint_hir_note<S: Into<MultiSpan>>(self,
2725                                              lint: &'static Lint,
2726                                              hir_id: HirId,
2727                                              span: S,
2728                                              msg: &str,
2729                                              note: &str) {
2730         let mut err = self.struct_span_lint_hir(lint, hir_id, span.into(), msg);
2731         err.note(note);
2732         err.emit()
2733     }
2734
2735     pub fn lint_node_note<S: Into<MultiSpan>>(self,
2736                                               lint: &'static Lint,
2737                                               id: hir::HirId,
2738                                               span: S,
2739                                               msg: &str,
2740                                               note: &str) {
2741         let mut err = self.struct_span_lint_hir(lint, id, span.into(), msg);
2742         err.note(note);
2743         err.emit()
2744     }
2745
2746     /// Walks upwards from `id` to find a node which might change lint levels with attributes.
2747     /// It stops at `bound` and just returns it if reached.
2748     pub fn maybe_lint_level_root_bounded(
2749         self,
2750         mut id: hir::HirId,
2751         bound: hir::HirId,
2752     ) -> hir::HirId {
2753         loop {
2754             if id == bound {
2755                 return bound;
2756             }
2757             if lint::maybe_lint_level_root(self, id) {
2758                 return id;
2759             }
2760             let next = self.hir().get_parent_node(id);
2761             if next == id {
2762                 bug!("lint traversal reached the root of the crate");
2763             }
2764             id = next;
2765         }
2766     }
2767
2768     pub fn lint_level_at_node(
2769         self,
2770         lint: &'static Lint,
2771         mut id: hir::HirId
2772     ) -> (lint::Level, lint::LintSource) {
2773         let sets = self.lint_levels(LOCAL_CRATE);
2774         loop {
2775             if let Some(pair) = sets.level_and_source(lint, id, self.sess) {
2776                 return pair
2777             }
2778             let next = self.hir().get_parent_node(id);
2779             if next == id {
2780                 bug!("lint traversal reached the root of the crate");
2781             }
2782             id = next;
2783         }
2784     }
2785
2786     pub fn struct_span_lint_hir<S: Into<MultiSpan>>(self,
2787                                                     lint: &'static Lint,
2788                                                     hir_id: HirId,
2789                                                     span: S,
2790                                                     msg: &str)
2791         -> DiagnosticBuilder<'tcx>
2792     {
2793         let (level, src) = self.lint_level_at_node(lint, hir_id);
2794         lint::struct_lint_level(self.sess, lint, level, src, Some(span.into()), msg)
2795     }
2796
2797     pub fn struct_lint_node(self, lint: &'static Lint, id: HirId, msg: &str)
2798         -> DiagnosticBuilder<'tcx>
2799     {
2800         let (level, src) = self.lint_level_at_node(lint, id);
2801         lint::struct_lint_level(self.sess, lint, level, src, None, msg)
2802     }
2803
2804     pub fn in_scope_traits(self, id: HirId) -> Option<&'tcx StableVec<TraitCandidate>> {
2805         self.in_scope_traits_map(id.owner)
2806             .and_then(|map| map.get(&id.local_id))
2807     }
2808
2809     pub fn named_region(self, id: HirId) -> Option<resolve_lifetime::Region> {
2810         self.named_region_map(id.owner)
2811             .and_then(|map| map.get(&id.local_id).cloned())
2812     }
2813
2814     pub fn is_late_bound(self, id: HirId) -> bool {
2815         self.is_late_bound_map(id.owner)
2816             .map(|set| set.contains(&id.local_id))
2817             .unwrap_or(false)
2818     }
2819
2820     pub fn object_lifetime_defaults(self, id: HirId) -> Option<&'tcx [ObjectLifetimeDefault]> {
2821         self.object_lifetime_defaults_map(id.owner)
2822             .and_then(|map| map.get(&id.local_id).map(|v| &**v))
2823     }
2824 }
2825
2826 pub trait InternAs<T: ?Sized, R> {
2827     type Output;
2828     fn intern_with<F>(self, f: F) -> Self::Output
2829         where F: FnOnce(&T) -> R;
2830 }
2831
2832 impl<I, T, R, E> InternAs<[T], R> for I
2833     where E: InternIteratorElement<T, R>,
2834           I: Iterator<Item=E> {
2835     type Output = E::Output;
2836     fn intern_with<F>(self, f: F) -> Self::Output
2837         where F: FnOnce(&[T]) -> R {
2838         E::intern_with(self, f)
2839     }
2840 }
2841
2842 pub trait InternIteratorElement<T, R>: Sized {
2843     type Output;
2844     fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output;
2845 }
2846
2847 impl<T, R> InternIteratorElement<T, R> for T {
2848     type Output = R;
2849     fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
2850         f(&iter.collect::<SmallVec<[_; 8]>>())
2851     }
2852 }
2853
2854 impl<'a, T, R> InternIteratorElement<T, R> for &'a T
2855     where T: Clone + 'a
2856 {
2857     type Output = R;
2858     fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
2859         f(&iter.cloned().collect::<SmallVec<[_; 8]>>())
2860     }
2861 }
2862
2863 impl<T, R, E> InternIteratorElement<T, R> for Result<T, E> {
2864     type Output = Result<R, E>;
2865     fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
2866         Ok(f(&iter.collect::<Result<SmallVec<[_; 8]>, _>>()?))
2867     }
2868 }
2869
2870 // We are comparing types with different invariant lifetimes, so `ptr::eq`
2871 // won't work for us.
2872 fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
2873     t as *const () == u as *const ()
2874 }
2875
2876 pub fn provide(providers: &mut ty::query::Providers<'_>) {
2877     providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id);
2878     providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).map(|v| &v[..]);
2879     providers.crate_name = |tcx, id| {
2880         assert_eq!(id, LOCAL_CRATE);
2881         tcx.crate_name
2882     };
2883     providers.get_lib_features = |tcx, id| {
2884         assert_eq!(id, LOCAL_CRATE);
2885         tcx.arena.alloc(middle::lib_features::collect(tcx))
2886     };
2887     providers.get_lang_items = |tcx, id| {
2888         assert_eq!(id, LOCAL_CRATE);
2889         tcx.arena.alloc(middle::lang_items::collect(tcx))
2890     };
2891     providers.diagnostic_items = |tcx, id| {
2892         assert_eq!(id, LOCAL_CRATE);
2893         middle::diagnostic_items::collect(tcx)
2894     };
2895     providers.all_diagnostic_items = |tcx, id| {
2896         assert_eq!(id, LOCAL_CRATE);
2897         middle::diagnostic_items::collect_all(tcx)
2898     };
2899     providers.maybe_unused_trait_import = |tcx, id| {
2900         tcx.maybe_unused_trait_imports.contains(&id)
2901     };
2902     providers.maybe_unused_extern_crates = |tcx, cnum| {
2903         assert_eq!(cnum, LOCAL_CRATE);
2904         &tcx.maybe_unused_extern_crates[..]
2905     };
2906     providers.names_imported_by_glob_use = |tcx, id| {
2907         assert_eq!(id.krate, LOCAL_CRATE);
2908         Lrc::new(tcx.glob_map.get(&id).cloned().unwrap_or_default())
2909     };
2910
2911     providers.stability_index = |tcx, cnum| {
2912         assert_eq!(cnum, LOCAL_CRATE);
2913         tcx.arena.alloc(stability::Index::new(tcx))
2914     };
2915     providers.lookup_stability = |tcx, id| {
2916         assert_eq!(id.krate, LOCAL_CRATE);
2917         let id = tcx.hir().definitions().def_index_to_hir_id(id.index);
2918         tcx.stability().local_stability(id)
2919     };
2920     providers.lookup_deprecation_entry = |tcx, id| {
2921         assert_eq!(id.krate, LOCAL_CRATE);
2922         let id = tcx.hir().definitions().def_index_to_hir_id(id.index);
2923         tcx.stability().local_deprecation_entry(id)
2924     };
2925     providers.extern_mod_stmt_cnum = |tcx, id| {
2926         let id = tcx.hir().as_local_node_id(id).unwrap();
2927         tcx.cstore.extern_mod_stmt_cnum_untracked(id)
2928     };
2929     providers.all_crate_nums = |tcx, cnum| {
2930         assert_eq!(cnum, LOCAL_CRATE);
2931         tcx.arena.alloc_slice(&tcx.cstore.crates_untracked())
2932     };
2933     providers.postorder_cnums = |tcx, cnum| {
2934         assert_eq!(cnum, LOCAL_CRATE);
2935         tcx.arena.alloc_slice(&tcx.cstore.postorder_cnums_untracked())
2936     };
2937     providers.output_filenames = |tcx, cnum| {
2938         assert_eq!(cnum, LOCAL_CRATE);
2939         tcx.output_filenames.clone()
2940     };
2941     providers.features_query = |tcx, cnum| {
2942         assert_eq!(cnum, LOCAL_CRATE);
2943         tcx.arena.alloc(tcx.sess.features_untracked().clone())
2944     };
2945     providers.is_panic_runtime = |tcx, cnum| {
2946         assert_eq!(cnum, LOCAL_CRATE);
2947         attr::contains_name(tcx.hir().krate_attrs(), sym::panic_runtime)
2948     };
2949     providers.is_compiler_builtins = |tcx, cnum| {
2950         assert_eq!(cnum, LOCAL_CRATE);
2951         attr::contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
2952     };
2953 }