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