src/librustc/ty/context.rs

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