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