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