src/librustc/ty/context.rs

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