src/librustc_middle/ty/context.rs

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