src/librustc_middle/ty/context.rs

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