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