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     // def id corresponding to FreeRegion
 877     pub def_id: DefId,
 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) => (free_region.scope, free_region.bound_region),
1416             ty::ReEarlyBound(ref ebr) => {
1417                 (self.parent(ebr.def_id).unwrap(), ty::BoundRegion::BrNamed(ebr.def_id, ebr.name))
1418             }
1419             _ => return None, // not a free region
1420         };
1421
1422         let hir_id = self.hir().as_local_hir_id(suitable_region_binding_scope.expect_local());
1423         let is_impl_item = match self.hir().find(hir_id) {
1424             Some(Node::Item(..) | Node::TraitItem(..)) => false,
1425             Some(Node::ImplItem(..)) => {
1426                 self.is_bound_region_in_impl_item(suitable_region_binding_scope)
1427             }
1428             _ => return None,
1429         };
1430
1431         Some(FreeRegionInfo {
1432             def_id: suitable_region_binding_scope,
1433             boundregion: bound_region,
1434             is_impl_item,
1435         })
1436     }
1437
1438     /// Given a `DefId` for an `fn`, return all the `dyn` and `impl` traits in its return type.
1439     pub fn return_type_impl_or_dyn_traits(
1440         &self,
1441         scope_def_id: LocalDefId,
1442     ) -> Vec<&'tcx hir::Ty<'tcx>> {
1443         let hir_id = self.hir().as_local_hir_id(scope_def_id);
1444         let hir_output = match self.hir().get(hir_id) {
1445             Node::Item(hir::Item {
1446                 kind:
1447                     ItemKind::Fn(
1448                         hir::FnSig {
1449                             decl: hir::FnDecl { output: hir::FnRetTy::Return(ty), .. },
1450                             ..
1451                         },
1452                         ..,
1453                     ),
1454                 ..
1455             })
1456             | Node::ImplItem(hir::ImplItem {
1457                 kind:
1458                     hir::ImplItemKind::Fn(
1459                         hir::FnSig {
1460                             decl: hir::FnDecl { output: hir::FnRetTy::Return(ty), .. },
1461                             ..
1462                         },
1463                         _,
1464                     ),
1465                 ..
1466             })
1467             | Node::TraitItem(hir::TraitItem {
1468                 kind:
1469                     hir::TraitItemKind::Fn(
1470                         hir::FnSig {
1471                             decl: hir::FnDecl { output: hir::FnRetTy::Return(ty), .. },
1472                             ..
1473                         },
1474                         _,
1475                     ),
1476                 ..
1477             }) => ty,
1478             _ => return vec![],
1479         };
1480
1481         let mut v = TraitObjectVisitor(vec![], self.hir());
1482         v.visit_ty(hir_output);
1483         v.0
1484     }
1485
1486     pub fn return_type_impl_trait(&self, scope_def_id: LocalDefId) -> Option<(Ty<'tcx>, Span)> {
1487         // HACK: `type_of_def_id()` will fail on these (#55796), so return `None`.
1488         let hir_id = self.hir().as_local_hir_id(scope_def_id);
1489         match self.hir().get(hir_id) {
1490             Node::Item(item) => {
1491                 match item.kind {
1492                     ItemKind::Fn(..) => { /* `type_of_def_id()` will work */ }
1493                     _ => {
1494                         return None;
1495                     }
1496                 }
1497             }
1498             _ => { /* `type_of_def_id()` will work or panic */ }
1499         }
1500
1501         let ret_ty = self.type_of(scope_def_id);
1502         match ret_ty.kind {
1503             ty::FnDef(_, _) => {
1504                 let sig = ret_ty.fn_sig(*self);
1505                 let output = self.erase_late_bound_regions(&sig.output());
1506                 if output.is_impl_trait() {
1507                     let fn_decl = self.hir().fn_decl_by_hir_id(hir_id).unwrap();
1508                     Some((output, fn_decl.output.span()))
1509                 } else {
1510                     None
1511                 }
1512             }
1513             _ => None,
1514         }
1515     }
1516
1517     // Checks if the bound region is in Impl Item.
1518     pub fn is_bound_region_in_impl_item(&self, suitable_region_binding_scope: DefId) -> bool {
1519         let container_id = self.associated_item(suitable_region_binding_scope).container.id();
1520         if self.impl_trait_ref(container_id).is_some() {
1521             // For now, we do not try to target impls of traits. This is
1522             // because this message is going to suggest that the user
1523             // change the fn signature, but they may not be free to do so,
1524             // since the signature must match the trait.
1525             //
1526             // FIXME(#42706) -- in some cases, we could do better here.
1527             return true;
1528         }
1529         false
1530     }
1531
1532     /// Determines whether identifiers in the assembly have strict naming rules.
1533     /// Currently, only NVPTX* targets need it.
1534     pub fn has_strict_asm_symbol_naming(&self) -> bool {
1535         self.sess.target.target.arch.contains("nvptx")
1536     }
1537
1538     /// Returns `&'static core::panic::Location<'static>`.
1539     pub fn caller_location_ty(&self) -> Ty<'tcx> {
1540         self.mk_imm_ref(
1541             self.lifetimes.re_static,
1542             self.type_of(self.require_lang_item(PanicLocationLangItem, None))
1543                 .subst(*self, self.mk_substs([self.lifetimes.re_static.into()].iter())),
1544         )
1545     }
1546
1547     /// Returns a displayable description and article for the given `def_id` (e.g. `("a", "struct")`).
1548     pub fn article_and_description(&self, def_id: DefId) -> (&'static str, &'static str) {
1549         match self.def_kind(def_id) {
1550             DefKind::Generator => match self.generator_kind(def_id).unwrap() {
1551                 rustc_hir::GeneratorKind::Async(..) => ("an", "async closure"),
1552                 rustc_hir::GeneratorKind::Gen => ("a", "generator"),
1553             },
1554             def_kind => (def_kind.article(), def_kind.descr(def_id)),
1555         }
1556     }
1557 }
1558
1559 impl<'tcx> GlobalCtxt<'tcx> {
1560     /// Calls the closure with a local `TyCtxt` using the given arena.
1561     /// `interners` is a slot passed so we can create a CtxtInterners
1562     /// with the same lifetime as `arena`.
1563     pub fn enter_local<F, R>(&'tcx self, f: F) -> R
1564     where
1565         F: FnOnce(TyCtxt<'tcx>) -> R,
1566     {
1567         let tcx = TyCtxt { gcx: self };
1568         ty::tls::with_related_context(tcx, |icx| {
1569             let new_icx = ty::tls::ImplicitCtxt {
1570                 tcx,
1571                 query: icx.query,
1572                 diagnostics: icx.diagnostics,
1573                 layout_depth: icx.layout_depth,
1574                 task_deps: icx.task_deps,
1575             };
1576             ty::tls::enter_context(&new_icx, |_| f(tcx))
1577         })
1578     }
1579 }
1580
1581 /// A trait implemented for all `X<'a>` types that can be safely and
1582 /// efficiently converted to `X<'tcx>` as long as they are part of the
1583 /// provided `TyCtxt<'tcx>`.
1584 /// This can be done, for example, for `Ty<'tcx>` or `SubstsRef<'tcx>`
1585 /// by looking them up in their respective interners.
1586 ///
1587 /// However, this is still not the best implementation as it does
1588 /// need to compare the components, even for interned values.
1589 /// It would be more efficient if `TypedArena` provided a way to
1590 /// determine whether the address is in the allocated range.
1591 ///
1592 /// `None` is returned if the value or one of the components is not part
1593 /// of the provided context.
1594 /// For `Ty`, `None` can be returned if either the type interner doesn't
1595 /// contain the `TyKind` key or if the address of the interned
1596 /// pointer differs. The latter case is possible if a primitive type,
1597 /// e.g., `()` or `u8`, was interned in a different context.
1598 pub trait Lift<'tcx>: fmt::Debug {
1599     type Lifted: fmt::Debug + 'tcx;
1600     fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>;
1601 }
1602
1603 macro_rules! nop_lift {
1604     ($set:ident; $ty:ty => $lifted:ty) => {
1605         impl<'a, 'tcx> Lift<'tcx> for $ty {
1606             type Lifted = $lifted;
1607             fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1608                 if tcx.interners.$set.contains_pointer_to(&Interned(*self)) {
1609                     Some(unsafe { mem::transmute(*self) })
1610                 } else {
1611                     None
1612                 }
1613             }
1614         }
1615     };
1616 }
1617
1618 macro_rules! nop_list_lift {
1619     ($set:ident; $ty:ty => $lifted:ty) => {
1620         impl<'a, 'tcx> Lift<'tcx> for &'a List<$ty> {
1621             type Lifted = &'tcx List<$lifted>;
1622             fn lift_to_tcx(&self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1623                 if self.is_empty() {
1624                     return Some(List::empty());
1625                 }
1626                 if tcx.interners.$set.contains_pointer_to(&Interned(*self)) {
1627                     Some(unsafe { mem::transmute(*self) })
1628                 } else {
1629                     None
1630                 }
1631             }
1632         }
1633     };
1634 }
1635
1636 nop_lift! {type_; Ty<'a> => Ty<'tcx>}
1637 nop_lift! {region; Region<'a> => Region<'tcx>}
1638 nop_lift! {const_; &'a Const<'a> => &'tcx Const<'tcx>}
1639 nop_lift! {predicate; &'a PredicateInner<'a> => &'tcx PredicateInner<'tcx>}
1640
1641 nop_list_lift! {type_list; Ty<'a> => Ty<'tcx>}
1642 nop_list_lift! {existential_predicates; ExistentialPredicate<'a> => ExistentialPredicate<'tcx>}
1643 nop_list_lift! {predicates; Predicate<'a> => Predicate<'tcx>}
1644 nop_list_lift! {canonical_var_infos; CanonicalVarInfo => CanonicalVarInfo}
1645 nop_list_lift! {projs; ProjectionKind => ProjectionKind}
1646
1647 // This is the impl for `&'a InternalSubsts<'a>`.
1648 nop_list_lift! {substs; GenericArg<'a> => GenericArg<'tcx>}
1649
1650 pub mod tls {
1651     use super::{ptr_eq, GlobalCtxt, TyCtxt};
1652
1653     use crate::dep_graph::{DepKind, TaskDeps};
1654     use crate::ty::query;
1655     use rustc_data_structures::sync::{self, Lock};
1656     use rustc_data_structures::thin_vec::ThinVec;
1657     use rustc_data_structures::OnDrop;
1658     use rustc_errors::Diagnostic;
1659     use std::mem;
1660
1661     #[cfg(not(parallel_compiler))]
1662     use std::cell::Cell;
1663
1664     #[cfg(parallel_compiler)]
1665     use rustc_rayon_core as rayon_core;
1666
1667     /// This is the implicit state of rustc. It contains the current
1668     /// `TyCtxt` and query. It is updated when creating a local interner or
1669     /// executing a new query. Whenever there's a `TyCtxt` value available
1670     /// you should also have access to an `ImplicitCtxt` through the functions
1671     /// in this module.
1672     #[derive(Clone)]
1673     pub struct ImplicitCtxt<'a, 'tcx> {
1674         /// The current `TyCtxt`. Initially created by `enter_global` and updated
1675         /// by `enter_local` with a new local interner.
1676         pub tcx: TyCtxt<'tcx>,
1677
1678         /// The current query job, if any. This is updated by `JobOwner::start` in
1679         /// `ty::query::plumbing` when executing a query.
1680         pub query: Option<query::QueryJobId<DepKind>>,
1681
1682         /// Where to store diagnostics for the current query job, if any.
1683         /// This is updated by `JobOwner::start` in `ty::query::plumbing` when executing a query.
1684         pub diagnostics: Option<&'a Lock<ThinVec<Diagnostic>>>,
1685
1686         /// Used to prevent layout from recursing too deeply.
1687         pub layout_depth: usize,
1688
1689         /// The current dep graph task. This is used to add dependencies to queries
1690         /// when executing them.
1691         pub task_deps: Option<&'a Lock<TaskDeps>>,
1692     }
1693
1694     /// Sets Rayon's thread-local variable, which is preserved for Rayon jobs
1695     /// to `value` during the call to `f`. It is restored to its previous value after.
1696     /// This is used to set the pointer to the new `ImplicitCtxt`.
1697     #[cfg(parallel_compiler)]
1698     #[inline]
1699     fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
1700         rayon_core::tlv::with(value, f)
1701     }
1702
1703     /// Gets Rayon's thread-local variable, which is preserved for Rayon jobs.
1704     /// This is used to get the pointer to the current `ImplicitCtxt`.
1705     #[cfg(parallel_compiler)]
1706     #[inline]
1707     fn get_tlv() -> usize {
1708         rayon_core::tlv::get()
1709     }
1710
1711     #[cfg(not(parallel_compiler))]
1712     thread_local! {
1713         /// A thread local variable that stores a pointer to the current `ImplicitCtxt`.
1714         static TLV: Cell<usize> = Cell::new(0);
1715     }
1716
1717     /// Sets TLV to `value` during the call to `f`.
1718     /// It is restored to its previous value after.
1719     /// This is used to set the pointer to the new `ImplicitCtxt`.
1720     #[cfg(not(parallel_compiler))]
1721     #[inline]
1722     fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
1723         let old = get_tlv();
1724         let _reset = OnDrop(move || TLV.with(|tlv| tlv.set(old)));
1725         TLV.with(|tlv| tlv.set(value));
1726         f()
1727     }
1728
1729     /// Gets the pointer to the current `ImplicitCtxt`.
1730     #[cfg(not(parallel_compiler))]
1731     #[inline]
1732     fn get_tlv() -> usize {
1733         TLV.with(|tlv| tlv.get())
1734     }
1735
1736     /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`.
1737     #[inline]
1738     pub fn enter_context<'a, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'tcx>, f: F) -> R
1739     where
1740         F: FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
1741     {
1742         set_tlv(context as *const _ as usize, || f(&context))
1743     }
1744
1745     /// Enters `GlobalCtxt` by setting up librustc_ast callbacks and
1746     /// creating a initial `TyCtxt` and `ImplicitCtxt`.
1747     /// This happens once per rustc session and `TyCtxt`s only exists
1748     /// inside the `f` function.
1749     pub fn enter_global<'tcx, F, R>(gcx: &'tcx GlobalCtxt<'tcx>, f: F) -> R
1750     where
1751         F: FnOnce(TyCtxt<'tcx>) -> R,
1752     {
1753         // Update `GCX_PTR` to indicate there's a `GlobalCtxt` available.
1754         GCX_PTR.with(|lock| {
1755             *lock.lock() = gcx as *const _ as usize;
1756         });
1757         // Set `GCX_PTR` back to 0 when we exit.
1758         let _on_drop = OnDrop(move || {
1759             GCX_PTR.with(|lock| *lock.lock() = 0);
1760         });
1761
1762         let tcx = TyCtxt { gcx };
1763         let icx =
1764             ImplicitCtxt { tcx, query: None, diagnostics: None, layout_depth: 0, task_deps: None };
1765         enter_context(&icx, |_| f(tcx))
1766     }
1767
1768     scoped_thread_local! {
1769         /// Stores a pointer to the `GlobalCtxt` if one is available.
1770         /// This is used to access the `GlobalCtxt` in the deadlock handler given to Rayon.
1771         pub static GCX_PTR: Lock<usize>
1772     }
1773
1774     /// Creates a `TyCtxt` and `ImplicitCtxt` based on the `GCX_PTR` thread local.
1775     /// This is used in the deadlock handler.
1776     pub unsafe fn with_global<F, R>(f: F) -> R
1777     where
1778         F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
1779     {
1780         let gcx = GCX_PTR.with(|lock| *lock.lock());
1781         assert!(gcx != 0);
1782         let gcx = &*(gcx as *const GlobalCtxt<'_>);
1783         let tcx = TyCtxt { gcx };
1784         let icx =
1785             ImplicitCtxt { query: None, diagnostics: None, tcx, layout_depth: 0, task_deps: None };
1786         enter_context(&icx, |_| f(tcx))
1787     }
1788
1789     /// Allows access to the current `ImplicitCtxt` in a closure if one is available.
1790     #[inline]
1791     pub fn with_context_opt<F, R>(f: F) -> R
1792     where
1793         F: for<'a, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'tcx>>) -> R,
1794     {
1795         let context = get_tlv();
1796         if context == 0 {
1797             f(None)
1798         } else {
1799             // We could get a `ImplicitCtxt` pointer from another thread.
1800             // Ensure that `ImplicitCtxt` is `Sync`.
1801             sync::assert_sync::<ImplicitCtxt<'_, '_>>();
1802
1803             unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) }
1804         }
1805     }
1806
1807     /// Allows access to the current `ImplicitCtxt`.
1808     /// Panics if there is no `ImplicitCtxt` available.
1809     #[inline]
1810     pub fn with_context<F, R>(f: F) -> R
1811     where
1812         F: for<'a, 'tcx> FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
1813     {
1814         with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
1815     }
1816
1817     /// Allows access to the current `ImplicitCtxt` whose tcx field has the same global
1818     /// interner as the tcx argument passed in. This means the closure is given an `ImplicitCtxt`
1819     /// with the same `'tcx` lifetime as the `TyCtxt` passed in.
1820     /// This will panic if you pass it a `TyCtxt` which has a different global interner from
1821     /// the current `ImplicitCtxt`'s `tcx` field.
1822     #[inline]
1823     pub fn with_related_context<'tcx, F, R>(tcx: TyCtxt<'tcx>, f: F) -> R
1824     where
1825         F: FnOnce(&ImplicitCtxt<'_, 'tcx>) -> R,
1826     {
1827         with_context(|context| unsafe {
1828             assert!(ptr_eq(context.tcx.gcx, tcx.gcx));
1829             let context: &ImplicitCtxt<'_, '_> = mem::transmute(context);
1830             f(context)
1831         })
1832     }
1833
1834     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
1835     /// Panics if there is no `ImplicitCtxt` available.
1836     #[inline]
1837     pub fn with<F, R>(f: F) -> R
1838     where
1839         F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
1840     {
1841         with_context(|context| f(context.tcx))
1842     }
1843
1844     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
1845     /// The closure is passed None if there is no `ImplicitCtxt` available.
1846     #[inline]
1847     pub fn with_opt<F, R>(f: F) -> R
1848     where
1849         F: for<'tcx> FnOnce(Option<TyCtxt<'tcx>>) -> R,
1850     {
1851         with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
1852     }
1853 }
1854
1855 macro_rules! sty_debug_print {
1856     ($ctxt: expr, $($variant: ident),*) => {{
1857         // Curious inner module to allow variant names to be used as
1858         // variable names.
1859         #[allow(non_snake_case)]
1860         mod inner {
1861             use crate::ty::{self, TyCtxt};
1862             use crate::ty::context::Interned;
1863
1864             #[derive(Copy, Clone)]
1865             struct DebugStat {
1866                 total: usize,
1867                 lt_infer: usize,
1868                 ty_infer: usize,
1869                 ct_infer: usize,
1870                 all_infer: usize,
1871             }
1872
1873             pub fn go(tcx: TyCtxt<'_>) {
1874                 let mut total = DebugStat {
1875                     total: 0,
1876                     lt_infer: 0,
1877                     ty_infer: 0,
1878                     ct_infer: 0,
1879                     all_infer: 0,
1880                 };
1881                 $(let mut $variant = total;)*
1882
1883                 let shards = tcx.interners.type_.lock_shards();
1884                 let types = shards.iter().flat_map(|shard| shard.keys());
1885                 for &Interned(t) in types {
1886                     let variant = match t.kind {
1887                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
1888                             ty::Float(..) | ty::Str | ty::Never => continue,
1889                         ty::Error(_) => /* unimportant */ continue,
1890                         $(ty::$variant(..) => &mut $variant,)*
1891                     };
1892                     let lt = t.flags.intersects(ty::TypeFlags::HAS_RE_INFER);
1893                     let ty = t.flags.intersects(ty::TypeFlags::HAS_TY_INFER);
1894                     let ct = t.flags.intersects(ty::TypeFlags::HAS_CT_INFER);
1895
1896                     variant.total += 1;
1897                     total.total += 1;
1898                     if lt { total.lt_infer += 1; variant.lt_infer += 1 }
1899                     if ty { total.ty_infer += 1; variant.ty_infer += 1 }
1900                     if ct { total.ct_infer += 1; variant.ct_infer += 1 }
1901                     if lt && ty && ct { total.all_infer += 1; variant.all_infer += 1 }
1902                 }
1903                 println!("Ty interner             total           ty lt ct all");
1904                 $(println!("    {:18}: {uses:6} {usespc:4.1}%, \
1905                             {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
1906                     stringify!($variant),
1907                     uses = $variant.total,
1908                     usespc = $variant.total as f64 * 100.0 / total.total as f64,
1909                     ty = $variant.ty_infer as f64 * 100.0  / total.total as f64,
1910                     lt = $variant.lt_infer as f64 * 100.0  / total.total as f64,
1911                     ct = $variant.ct_infer as f64 * 100.0  / total.total as f64,
1912                     all = $variant.all_infer as f64 * 100.0  / total.total as f64);
1913                 )*
1914                 println!("                  total {uses:6}        \
1915                           {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
1916                     uses = total.total,
1917                     ty = total.ty_infer as f64 * 100.0  / total.total as f64,
1918                     lt = total.lt_infer as f64 * 100.0  / total.total as f64,
1919                     ct = total.ct_infer as f64 * 100.0  / total.total as f64,
1920                     all = total.all_infer as f64 * 100.0  / total.total as f64)
1921             }
1922         }
1923
1924         inner::go($ctxt)
1925     }}
1926 }
1927
1928 impl<'tcx> TyCtxt<'tcx> {
1929     pub fn print_debug_stats(self) {
1930         sty_debug_print!(
1931             self,
1932             Adt,
1933             Array,
1934             Slice,
1935             RawPtr,
1936             Ref,
1937             FnDef,
1938             FnPtr,
1939             Placeholder,
1940             Generator,
1941             GeneratorWitness,
1942             Dynamic,
1943             Closure,
1944             Tuple,
1945             Bound,
1946             Param,
1947             Infer,
1948             Projection,
1949             Opaque,
1950             Foreign
1951         );
1952
1953         println!("InternalSubsts interner: #{}", self.interners.substs.len());
1954         println!("Region interner: #{}", self.interners.region.len());
1955         println!("Stability interner: #{}", self.stability_interner.len());
1956         println!("Const Stability interner: #{}", self.const_stability_interner.len());
1957         println!("Allocation interner: #{}", self.allocation_interner.len());
1958         println!("Layout interner: #{}", self.layout_interner.len());
1959     }
1960 }
1961
1962 /// An entry in an interner.
1963 struct Interned<'tcx, T: ?Sized>(&'tcx T);
1964
1965 impl<'tcx, T: 'tcx + ?Sized> Clone for Interned<'tcx, T> {
1966     fn clone(&self) -> Self {
1967         Interned(self.0)
1968     }
1969 }
1970 impl<'tcx, T: 'tcx + ?Sized> Copy for Interned<'tcx, T> {}
1971
1972 impl<'tcx, T: 'tcx + ?Sized> IntoPointer for Interned<'tcx, T> {
1973     fn into_pointer(&self) -> *const () {
1974         self.0 as *const _ as *const ()
1975     }
1976 }
1977 // N.B., an `Interned<Ty>` compares and hashes as a `TyKind`.
1978 impl<'tcx> PartialEq for Interned<'tcx, TyS<'tcx>> {
1979     fn eq(&self, other: &Interned<'tcx, TyS<'tcx>>) -> bool {
1980         self.0.kind == other.0.kind
1981     }
1982 }
1983
1984 impl<'tcx> Eq for Interned<'tcx, TyS<'tcx>> {}
1985
1986 impl<'tcx> Hash for Interned<'tcx, TyS<'tcx>> {
1987     fn hash<H: Hasher>(&self, s: &mut H) {
1988         self.0.kind.hash(s)
1989     }
1990 }
1991
1992 #[allow(rustc::usage_of_ty_tykind)]
1993 impl<'tcx> Borrow<TyKind<'tcx>> for Interned<'tcx, TyS<'tcx>> {
1994     fn borrow<'a>(&'a self) -> &'a TyKind<'tcx> {
1995         &self.0.kind
1996     }
1997 }
1998 // N.B., an `Interned<PredicateInner>` compares and hashes as a `PredicateKind`.
1999 impl<'tcx> PartialEq for Interned<'tcx, PredicateInner<'tcx>> {
2000     fn eq(&self, other: &Interned<'tcx, PredicateInner<'tcx>>) -> bool {
2001         self.0.kind == other.0.kind
2002     }
2003 }
2004
2005 impl<'tcx> Eq for Interned<'tcx, PredicateInner<'tcx>> {}
2006
2007 impl<'tcx> Hash for Interned<'tcx, PredicateInner<'tcx>> {
2008     fn hash<H: Hasher>(&self, s: &mut H) {
2009         self.0.kind.hash(s)
2010     }
2011 }
2012
2013 impl<'tcx> Borrow<PredicateKind<'tcx>> for Interned<'tcx, PredicateInner<'tcx>> {
2014     fn borrow<'a>(&'a self) -> &'a PredicateKind<'tcx> {
2015         &self.0.kind
2016     }
2017 }
2018
2019 // N.B., an `Interned<List<T>>` compares and hashes as its elements.
2020 impl<'tcx, T: PartialEq> PartialEq for Interned<'tcx, List<T>> {
2021     fn eq(&self, other: &Interned<'tcx, List<T>>) -> bool {
2022         self.0[..] == other.0[..]
2023     }
2024 }
2025
2026 impl<'tcx, T: Eq> Eq for Interned<'tcx, List<T>> {}
2027
2028 impl<'tcx, T: Hash> Hash for Interned<'tcx, List<T>> {
2029     fn hash<H: Hasher>(&self, s: &mut H) {
2030         self.0[..].hash(s)
2031     }
2032 }
2033
2034 impl<'tcx, T> Borrow<[T]> for Interned<'tcx, List<T>> {
2035     fn borrow<'a>(&'a self) -> &'a [T] {
2036         &self.0[..]
2037     }
2038 }
2039
2040 impl<'tcx> Borrow<RegionKind> for Interned<'tcx, RegionKind> {
2041     fn borrow(&self) -> &RegionKind {
2042         &self.0
2043     }
2044 }
2045
2046 impl<'tcx> Borrow<Const<'tcx>> for Interned<'tcx, Const<'tcx>> {
2047     fn borrow<'a>(&'a self) -> &'a Const<'tcx> {
2048         &self.0
2049     }
2050 }
2051
2052 impl<'tcx> Borrow<PredicateKind<'tcx>> for Interned<'tcx, PredicateKind<'tcx>> {
2053     fn borrow<'a>(&'a self) -> &'a PredicateKind<'tcx> {
2054         &self.0
2055     }
2056 }
2057
2058 macro_rules! direct_interners {
2059     ($($name:ident: $method:ident($ty:ty),)+) => {
2060         $(impl<'tcx> PartialEq for Interned<'tcx, $ty> {
2061             fn eq(&self, other: &Self) -> bool {
2062                 self.0 == other.0
2063             }
2064         }
2065
2066         impl<'tcx> Eq for Interned<'tcx, $ty> {}
2067
2068         impl<'tcx> Hash for Interned<'tcx, $ty> {
2069             fn hash<H: Hasher>(&self, s: &mut H) {
2070                 self.0.hash(s)
2071             }
2072         }
2073
2074         impl<'tcx> TyCtxt<'tcx> {
2075             pub fn $method(self, v: $ty) -> &'tcx $ty {
2076                 self.interners.$name.intern_ref(&v, || {
2077                     Interned(self.interners.arena.alloc(v))
2078                 }).0
2079             }
2080         })+
2081     }
2082 }
2083
2084 direct_interners! {
2085     region: mk_region(RegionKind),
2086     const_: mk_const(Const<'tcx>),
2087 }
2088
2089 macro_rules! slice_interners {
2090     ($($field:ident: $method:ident($ty:ty)),+) => (
2091         $(impl<'tcx> TyCtxt<'tcx> {
2092             pub fn $method(self, v: &[$ty]) -> &'tcx List<$ty> {
2093                 self.interners.$field.intern_ref(v, || {
2094                     Interned(List::from_arena(&*self.arena, v))
2095                 }).0
2096             }
2097         })+
2098     );
2099 }
2100
2101 slice_interners!(
2102     type_list: _intern_type_list(Ty<'tcx>),
2103     substs: _intern_substs(GenericArg<'tcx>),
2104     canonical_var_infos: _intern_canonical_var_infos(CanonicalVarInfo),
2105     existential_predicates: _intern_existential_predicates(ExistentialPredicate<'tcx>),
2106     predicates: _intern_predicates(Predicate<'tcx>),
2107     projs: _intern_projs(ProjectionKind),
2108     place_elems: _intern_place_elems(PlaceElem<'tcx>),
2109     chalk_environment_clause_list:
2110         _intern_chalk_environment_clause_list(traits::ChalkEnvironmentClause<'tcx>)
2111 );
2112
2113 impl<'tcx> TyCtxt<'tcx> {
2114     /// Given a `fn` type, returns an equivalent `unsafe fn` type;
2115     /// that is, a `fn` type that is equivalent in every way for being
2116     /// unsafe.
2117     pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
2118         assert_eq!(sig.unsafety(), hir::Unsafety::Normal);
2119         self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Unsafe, ..sig }))
2120     }
2121
2122     /// Given a closure signature, returns an equivalent fn signature. Detuples
2123     /// and so forth -- so e.g., if we have a sig with `Fn<(u32, i32)>` then
2124     /// you would get a `fn(u32, i32)`.
2125     /// `unsafety` determines the unsafety of the fn signature. If you pass
2126     /// `hir::Unsafety::Unsafe` in the previous example, then you would get
2127     /// an `unsafe fn (u32, i32)`.
2128     /// It cannot convert a closure that requires unsafe.
2129     pub fn signature_unclosure(
2130         self,
2131         sig: PolyFnSig<'tcx>,
2132         unsafety: hir::Unsafety,
2133     ) -> PolyFnSig<'tcx> {
2134         sig.map_bound(|s| {
2135             let params_iter = match s.inputs()[0].kind {
2136                 ty::Tuple(params) => params.into_iter().map(|k| k.expect_ty()),
2137                 _ => bug!(),
2138             };
2139             self.mk_fn_sig(params_iter, s.output(), s.c_variadic, unsafety, abi::Abi::Rust)
2140         })
2141     }
2142
2143     /// Same a `self.mk_region(kind)`, but avoids accessing the interners if
2144     /// `*r == kind`.
2145     #[inline]
2146     pub fn reuse_or_mk_region(self, r: Region<'tcx>, kind: RegionKind) -> Region<'tcx> {
2147         if *r == kind { r } else { self.mk_region(kind) }
2148     }
2149
2150     #[allow(rustc::usage_of_ty_tykind)]
2151     #[inline]
2152     pub fn mk_ty(&self, st: TyKind<'tcx>) -> Ty<'tcx> {
2153         self.interners.intern_ty(st)
2154     }
2155
2156     #[inline]
2157     pub fn mk_predicate(&self, kind: PredicateKind<'tcx>) -> Predicate<'tcx> {
2158         let inner = self.interners.intern_predicate(kind);
2159         Predicate { inner }
2160     }
2161
2162     pub fn mk_mach_int(self, tm: ast::IntTy) -> Ty<'tcx> {
2163         match tm {
2164             ast::IntTy::Isize => self.types.isize,
2165             ast::IntTy::I8 => self.types.i8,
2166             ast::IntTy::I16 => self.types.i16,
2167             ast::IntTy::I32 => self.types.i32,
2168             ast::IntTy::I64 => self.types.i64,
2169             ast::IntTy::I128 => self.types.i128,
2170         }
2171     }
2172
2173     pub fn mk_mach_uint(self, tm: ast::UintTy) -> Ty<'tcx> {
2174         match tm {
2175             ast::UintTy::Usize => self.types.usize,
2176             ast::UintTy::U8 => self.types.u8,
2177             ast::UintTy::U16 => self.types.u16,
2178             ast::UintTy::U32 => self.types.u32,
2179             ast::UintTy::U64 => self.types.u64,
2180             ast::UintTy::U128 => self.types.u128,
2181         }
2182     }
2183
2184     pub fn mk_mach_float(self, tm: ast::FloatTy) -> Ty<'tcx> {
2185         match tm {
2186             ast::FloatTy::F32 => self.types.f32,
2187             ast::FloatTy::F64 => self.types.f64,
2188         }
2189     }
2190
2191     #[inline]
2192     pub fn mk_static_str(self) -> Ty<'tcx> {
2193         self.mk_imm_ref(self.lifetimes.re_static, self.types.str_)
2194     }
2195
2196     #[inline]
2197     pub fn mk_adt(self, def: &'tcx AdtDef, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2198         // Take a copy of substs so that we own the vectors inside.
2199         self.mk_ty(Adt(def, substs))
2200     }
2201
2202     #[inline]
2203     pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {
2204         self.mk_ty(Foreign(def_id))
2205     }
2206
2207     fn mk_generic_adt(self, wrapper_def_id: DefId, ty_param: Ty<'tcx>) -> Ty<'tcx> {
2208         let adt_def = self.adt_def(wrapper_def_id);
2209         let substs =
2210             InternalSubsts::for_item(self, wrapper_def_id, |param, substs| match param.kind {
2211                 GenericParamDefKind::Lifetime | GenericParamDefKind::Const => bug!(),
2212                 GenericParamDefKind::Type { has_default, .. } => {
2213                     if param.index == 0 {
2214                         ty_param.into()
2215                     } else {
2216                         assert!(has_default);
2217                         self.type_of(param.def_id).subst(self, substs).into()
2218                     }
2219                 }
2220             });
2221         self.mk_ty(Adt(adt_def, substs))
2222     }
2223
2224     #[inline]
2225     pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2226         let def_id = self.require_lang_item(lang_items::OwnedBoxLangItem, None);
2227         self.mk_generic_adt(def_id, ty)
2228     }
2229
2230     #[inline]
2231     pub fn mk_lang_item(self, ty: Ty<'tcx>, item: lang_items::LangItem) -> Option<Ty<'tcx>> {
2232         let def_id = self.lang_items().require(item).ok()?;
2233         Some(self.mk_generic_adt(def_id, ty))
2234     }
2235
2236     #[inline]
2237     pub fn mk_diagnostic_item(self, ty: Ty<'tcx>, name: Symbol) -> Option<Ty<'tcx>> {
2238         let def_id = self.get_diagnostic_item(name)?;
2239         Some(self.mk_generic_adt(def_id, ty))
2240     }
2241
2242     #[inline]
2243     pub fn mk_maybe_uninit(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2244         let def_id = self.require_lang_item(lang_items::MaybeUninitLangItem, None);
2245         self.mk_generic_adt(def_id, ty)
2246     }
2247
2248     #[inline]
2249     pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
2250         self.mk_ty(RawPtr(tm))
2251     }
2252
2253     #[inline]
2254     pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
2255         self.mk_ty(Ref(r, tm.ty, tm.mutbl))
2256     }
2257
2258     #[inline]
2259     pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
2260         self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Mut })
2261     }
2262
2263     #[inline]
2264     pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
2265         self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Not })
2266     }
2267
2268     #[inline]
2269     pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2270         self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Mut })
2271     }
2272
2273     #[inline]
2274     pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2275         self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Not })
2276     }
2277
2278     #[inline]
2279     pub fn mk_nil_ptr(self) -> Ty<'tcx> {
2280         self.mk_imm_ptr(self.mk_unit())
2281     }
2282
2283     #[inline]
2284     pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
2285         self.mk_ty(Array(ty, ty::Const::from_usize(self, n)))
2286     }
2287
2288     #[inline]
2289     pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2290         self.mk_ty(Slice(ty))
2291     }
2292
2293     #[inline]
2294     pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
2295         let kinds: Vec<_> = ts.iter().map(|&t| GenericArg::from(t)).collect();
2296         self.mk_ty(Tuple(self.intern_substs(&kinds)))
2297     }
2298
2299     pub fn mk_tup<I: InternAs<[Ty<'tcx>], Ty<'tcx>>>(self, iter: I) -> I::Output {
2300         iter.intern_with(|ts| {
2301             let kinds: Vec<_> = ts.iter().map(|&t| GenericArg::from(t)).collect();
2302             self.mk_ty(Tuple(self.intern_substs(&kinds)))
2303         })
2304     }
2305
2306     #[inline]
2307     pub fn mk_unit(self) -> Ty<'tcx> {
2308         self.types.unit
2309     }
2310
2311     #[inline]
2312     pub fn mk_diverging_default(self) -> Ty<'tcx> {
2313         if self.features().never_type_fallback { self.types.never } else { self.types.unit }
2314     }
2315
2316     #[inline]
2317     pub fn mk_fn_def(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2318         self.mk_ty(FnDef(def_id, substs))
2319     }
2320
2321     #[inline]
2322     pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
2323         self.mk_ty(FnPtr(fty))
2324     }
2325
2326     #[inline]
2327     pub fn mk_dynamic(
2328         self,
2329         obj: ty::Binder<&'tcx List<ExistentialPredicate<'tcx>>>,
2330         reg: ty::Region<'tcx>,
2331     ) -> Ty<'tcx> {
2332         self.mk_ty(Dynamic(obj, reg))
2333     }
2334
2335     #[inline]
2336     pub fn mk_projection(self, item_def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2337         self.mk_ty(Projection(ProjectionTy { item_def_id, substs }))
2338     }
2339
2340     #[inline]
2341     pub fn mk_closure(self, closure_id: DefId, closure_substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2342         self.mk_ty(Closure(closure_id, closure_substs))
2343     }
2344
2345     #[inline]
2346     pub fn mk_generator(
2347         self,
2348         id: DefId,
2349         generator_substs: SubstsRef<'tcx>,
2350         movability: hir::Movability,
2351     ) -> Ty<'tcx> {
2352         self.mk_ty(Generator(id, generator_substs, movability))
2353     }
2354
2355     #[inline]
2356     pub fn mk_generator_witness(self, types: ty::Binder<&'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {
2357         self.mk_ty(GeneratorWitness(types))
2358     }
2359
2360     #[inline]
2361     pub fn mk_ty_var(self, v: TyVid) -> Ty<'tcx> {
2362         self.mk_ty_infer(TyVar(v))
2363     }
2364
2365     #[inline]
2366     pub fn mk_const_var(self, v: ConstVid<'tcx>, ty: Ty<'tcx>) -> &'tcx Const<'tcx> {
2367         self.mk_const(ty::Const { val: ty::ConstKind::Infer(InferConst::Var(v)), ty })
2368     }
2369
2370     #[inline]
2371     pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {
2372         self.mk_ty_infer(IntVar(v))
2373     }
2374
2375     #[inline]
2376     pub fn mk_float_var(self, v: FloatVid) -> Ty<'tcx> {
2377         self.mk_ty_infer(FloatVar(v))
2378     }
2379
2380     #[inline]
2381     pub fn mk_ty_infer(self, it: InferTy) -> Ty<'tcx> {
2382         self.mk_ty(Infer(it))
2383     }
2384
2385     #[inline]
2386     pub fn mk_const_infer(self, ic: InferConst<'tcx>, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
2387         self.mk_const(ty::Const { val: ty::ConstKind::Infer(ic), ty })
2388     }
2389
2390     #[inline]
2391     pub fn mk_ty_param(self, index: u32, name: Symbol) -> Ty<'tcx> {
2392         self.mk_ty(Param(ParamTy { index, name }))
2393     }
2394
2395     #[inline]
2396     pub fn mk_const_param(self, index: u32, name: Symbol, ty: Ty<'tcx>) -> &'tcx Const<'tcx> {
2397         self.mk_const(ty::Const { val: ty::ConstKind::Param(ParamConst { index, name }), ty })
2398     }
2399
2400     pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
2401         match param.kind {
2402             GenericParamDefKind::Lifetime => {
2403                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
2404             }
2405             GenericParamDefKind::Type { .. } => self.mk_ty_param(param.index, param.name).into(),
2406             GenericParamDefKind::Const => {
2407                 self.mk_const_param(param.index, param.name, self.type_of(param.def_id)).into()
2408             }
2409         }
2410     }
2411
2412     #[inline]
2413     pub fn mk_opaque(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2414         self.mk_ty(Opaque(def_id, substs))
2415     }
2416
2417     pub fn mk_place_field(self, place: Place<'tcx>, f: Field, ty: Ty<'tcx>) -> Place<'tcx> {
2418         self.mk_place_elem(place, PlaceElem::Field(f, ty))
2419     }
2420
2421     pub fn mk_place_deref(self, place: Place<'tcx>) -> Place<'tcx> {
2422         self.mk_place_elem(place, PlaceElem::Deref)
2423     }
2424
2425     pub fn mk_place_downcast(
2426         self,
2427         place: Place<'tcx>,
2428         adt_def: &'tcx AdtDef,
2429         variant_index: VariantIdx,
2430     ) -> Place<'tcx> {
2431         self.mk_place_elem(
2432             place,
2433             PlaceElem::Downcast(Some(adt_def.variants[variant_index].ident.name), variant_index),
2434         )
2435     }
2436
2437     pub fn mk_place_downcast_unnamed(
2438         self,
2439         place: Place<'tcx>,
2440         variant_index: VariantIdx,
2441     ) -> Place<'tcx> {
2442         self.mk_place_elem(place, PlaceElem::Downcast(None, variant_index))
2443     }
2444
2445     pub fn mk_place_index(self, place: Place<'tcx>, index: Local) -> Place<'tcx> {
2446         self.mk_place_elem(place, PlaceElem::Index(index))
2447     }
2448
2449     /// This method copies `Place`'s projection, add an element and reintern it. Should not be used
2450     /// to build a full `Place` it's just a convenient way to grab a projection and modify it in
2451     /// flight.
2452     pub fn mk_place_elem(self, place: Place<'tcx>, elem: PlaceElem<'tcx>) -> Place<'tcx> {
2453         let mut projection = place.projection.to_vec();
2454         projection.push(elem);
2455
2456         Place { local: place.local, projection: self.intern_place_elems(&projection) }
2457     }
2458
2459     pub fn intern_existential_predicates(
2460         self,
2461         eps: &[ExistentialPredicate<'tcx>],
2462     ) -> &'tcx List<ExistentialPredicate<'tcx>> {
2463         assert!(!eps.is_empty());
2464         assert!(eps.windows(2).all(|w| w[0].stable_cmp(self, &w[1]) != Ordering::Greater));
2465         self._intern_existential_predicates(eps)
2466     }
2467
2468     pub fn intern_predicates(self, preds: &[Predicate<'tcx>]) -> &'tcx List<Predicate<'tcx>> {
2469         // FIXME consider asking the input slice to be sorted to avoid
2470         // re-interning permutations, in which case that would be asserted
2471         // here.
2472         if preds.is_empty() {
2473             // The macro-generated method below asserts we don't intern an empty slice.
2474             List::empty()
2475         } else {
2476             self._intern_predicates(preds)
2477         }
2478     }
2479
2480     pub fn intern_type_list(self, ts: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
2481         if ts.is_empty() { List::empty() } else { self._intern_type_list(ts) }
2482     }
2483
2484     pub fn intern_substs(self, ts: &[GenericArg<'tcx>]) -> &'tcx List<GenericArg<'tcx>> {
2485         if ts.is_empty() { List::empty() } else { self._intern_substs(ts) }
2486     }
2487
2488     pub fn intern_projs(self, ps: &[ProjectionKind]) -> &'tcx List<ProjectionKind> {
2489         if ps.is_empty() { List::empty() } else { self._intern_projs(ps) }
2490     }
2491
2492     pub fn intern_place_elems(self, ts: &[PlaceElem<'tcx>]) -> &'tcx List<PlaceElem<'tcx>> {
2493         if ts.is_empty() { List::empty() } else { self._intern_place_elems(ts) }
2494     }
2495
2496     pub fn intern_canonical_var_infos(self, ts: &[CanonicalVarInfo]) -> CanonicalVarInfos<'tcx> {
2497         if ts.is_empty() { List::empty() } else { self._intern_canonical_var_infos(ts) }
2498     }
2499
2500     pub fn intern_chalk_environment_clause_list(
2501         self,
2502         ts: &[traits::ChalkEnvironmentClause<'tcx>],
2503     ) -> &'tcx List<traits::ChalkEnvironmentClause<'tcx>> {
2504         if ts.is_empty() { List::empty() } else { self._intern_chalk_environment_clause_list(ts) }
2505     }
2506
2507     pub fn mk_fn_sig<I>(
2508         self,
2509         inputs: I,
2510         output: I::Item,
2511         c_variadic: bool,
2512         unsafety: hir::Unsafety,
2513         abi: abi::Abi,
2514     ) -> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
2515     where
2516         I: Iterator<Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>,
2517     {
2518         inputs.chain(iter::once(output)).intern_with(|xs| ty::FnSig {
2519             inputs_and_output: self.intern_type_list(xs),
2520             c_variadic,
2521             unsafety,
2522             abi,
2523         })
2524     }
2525
2526     pub fn mk_existential_predicates<
2527         I: InternAs<[ExistentialPredicate<'tcx>], &'tcx List<ExistentialPredicate<'tcx>>>,
2528     >(
2529         self,
2530         iter: I,
2531     ) -> I::Output {
2532         iter.intern_with(|xs| self.intern_existential_predicates(xs))
2533     }
2534
2535     pub fn mk_predicates<I: InternAs<[Predicate<'tcx>], &'tcx List<Predicate<'tcx>>>>(
2536         self,
2537         iter: I,
2538     ) -> I::Output {
2539         iter.intern_with(|xs| self.intern_predicates(xs))
2540     }
2541
2542     pub fn mk_type_list<I: InternAs<[Ty<'tcx>], &'tcx List<Ty<'tcx>>>>(self, iter: I) -> I::Output {
2543         iter.intern_with(|xs| self.intern_type_list(xs))
2544     }
2545
2546     pub fn mk_substs<I: InternAs<[GenericArg<'tcx>], &'tcx List<GenericArg<'tcx>>>>(
2547         self,
2548         iter: I,
2549     ) -> I::Output {
2550         iter.intern_with(|xs| self.intern_substs(xs))
2551     }
2552
2553     pub fn mk_place_elems<I: InternAs<[PlaceElem<'tcx>], &'tcx List<PlaceElem<'tcx>>>>(
2554         self,
2555         iter: I,
2556     ) -> I::Output {
2557         iter.intern_with(|xs| self.intern_place_elems(xs))
2558     }
2559
2560     pub fn mk_substs_trait(self, self_ty: Ty<'tcx>, rest: &[GenericArg<'tcx>]) -> SubstsRef<'tcx> {
2561         self.mk_substs(iter::once(self_ty.into()).chain(rest.iter().cloned()))
2562     }
2563
2564     pub fn mk_chalk_environment_clause_list<
2565         I: InternAs<
2566             [traits::ChalkEnvironmentClause<'tcx>],
2567             &'tcx List<traits::ChalkEnvironmentClause<'tcx>>,
2568         >,
2569     >(
2570         self,
2571         iter: I,
2572     ) -> I::Output {
2573         iter.intern_with(|xs| self.intern_chalk_environment_clause_list(xs))
2574     }
2575
2576     /// Walks upwards from `id` to find a node which might change lint levels with attributes.
2577     /// It stops at `bound` and just returns it if reached.
2578     pub fn maybe_lint_level_root_bounded(self, mut id: HirId, bound: HirId) -> HirId {
2579         let hir = self.hir();
2580         loop {
2581             if id == bound {
2582                 return bound;
2583             }
2584
2585             if hir.attrs(id).iter().any(|attr| Level::from_symbol(attr.name_or_empty()).is_some()) {
2586                 return id;
2587             }
2588             let next = hir.get_parent_node(id);
2589             if next == id {
2590                 bug!("lint traversal reached the root of the crate");
2591             }
2592             id = next;
2593         }
2594     }
2595
2596     pub fn lint_level_at_node(
2597         self,
2598         lint: &'static Lint,
2599         mut id: hir::HirId,
2600     ) -> (Level, LintSource) {
2601         let sets = self.lint_levels(LOCAL_CRATE);
2602         loop {
2603             if let Some(pair) = sets.level_and_source(lint, id, self.sess) {
2604                 return pair;
2605             }
2606             let next = self.hir().get_parent_node(id);
2607             if next == id {
2608                 bug!("lint traversal reached the root of the crate");
2609             }
2610             id = next;
2611         }
2612     }
2613
2614     pub fn struct_span_lint_hir(
2615         self,
2616         lint: &'static Lint,
2617         hir_id: HirId,
2618         span: impl Into<MultiSpan>,
2619         decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>),
2620     ) {
2621         let (level, src) = self.lint_level_at_node(lint, hir_id);
2622         struct_lint_level(self.sess, lint, level, src, Some(span.into()), decorate);
2623     }
2624
2625     pub fn struct_lint_node(
2626         self,
2627         lint: &'static Lint,
2628         id: HirId,
2629         decorate: impl for<'a> FnOnce(LintDiagnosticBuilder<'a>),
2630     ) {
2631         let (level, src) = self.lint_level_at_node(lint, id);
2632         struct_lint_level(self.sess, lint, level, src, None, decorate);
2633     }
2634
2635     pub fn in_scope_traits(self, id: HirId) -> Option<&'tcx StableVec<TraitCandidate>> {
2636         self.in_scope_traits_map(id.owner).and_then(|map| map.get(&id.local_id))
2637     }
2638
2639     pub fn named_region(self, id: HirId) -> Option<resolve_lifetime::Region> {
2640         self.named_region_map(id.owner).and_then(|map| map.get(&id.local_id).cloned())
2641     }
2642
2643     pub fn is_late_bound(self, id: HirId) -> bool {
2644         self.is_late_bound_map(id.owner).map(|set| set.contains(&id.local_id)).unwrap_or(false)
2645     }
2646
2647     pub fn object_lifetime_defaults(self, id: HirId) -> Option<&'tcx [ObjectLifetimeDefault]> {
2648         self.object_lifetime_defaults_map(id.owner)
2649             .and_then(|map| map.get(&id.local_id).map(|v| &**v))
2650     }
2651 }
2652
2653 pub trait InternAs<T: ?Sized, R> {
2654     type Output;
2655     fn intern_with<F>(self, f: F) -> Self::Output
2656     where
2657         F: FnOnce(&T) -> R;
2658 }
2659
2660 impl<I, T, R, E> InternAs<[T], R> for I
2661 where
2662     E: InternIteratorElement<T, R>,
2663     I: Iterator<Item = E>,
2664 {
2665     type Output = E::Output;
2666     fn intern_with<F>(self, f: F) -> Self::Output
2667     where
2668         F: FnOnce(&[T]) -> R,
2669     {
2670         E::intern_with(self, f)
2671     }
2672 }
2673
2674 pub trait InternIteratorElement<T, R>: Sized {
2675     type Output;
2676     fn intern_with<I: Iterator<Item = Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output;
2677 }
2678
2679 impl<T, R> InternIteratorElement<T, R> for T {
2680     type Output = R;
2681     fn intern_with<I: Iterator<Item = Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
2682         f(&iter.collect::<SmallVec<[_; 8]>>())
2683     }
2684 }
2685
2686 impl<'a, T, R> InternIteratorElement<T, R> for &'a T
2687 where
2688     T: Clone + 'a,
2689 {
2690     type Output = R;
2691     fn intern_with<I: Iterator<Item = Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
2692         f(&iter.cloned().collect::<SmallVec<[_; 8]>>())
2693     }
2694 }
2695
2696 impl<T, R, E> InternIteratorElement<T, R> for Result<T, E> {
2697     type Output = Result<R, E>;
2698     fn intern_with<I: Iterator<Item = Self>, F: FnOnce(&[T]) -> R>(
2699         mut iter: I,
2700         f: F,
2701     ) -> Self::Output {
2702         // This code is hot enough that it's worth specializing for the most
2703         // common length lists, to avoid the overhead of `SmallVec` creation.
2704         // The match arms are in order of frequency. The 1, 2, and 0 cases are
2705         // typically hit in ~95% of cases. We assume that if the upper and
2706         // lower bounds from `size_hint` agree they are correct.
2707         Ok(match iter.size_hint() {
2708             (1, Some(1)) => {
2709                 let t0 = iter.next().unwrap()?;
2710                 assert!(iter.next().is_none());
2711                 f(&[t0])
2712             }
2713             (2, Some(2)) => {
2714                 let t0 = iter.next().unwrap()?;
2715                 let t1 = iter.next().unwrap()?;
2716                 assert!(iter.next().is_none());
2717                 f(&[t0, t1])
2718             }
2719             (0, Some(0)) => {
2720                 assert!(iter.next().is_none());
2721                 f(&[])
2722             }
2723             _ => f(&iter.collect::<Result<SmallVec<[_; 8]>, _>>()?),
2724         })
2725     }
2726 }
2727
2728 // We are comparing types with different invariant lifetimes, so `ptr::eq`
2729 // won't work for us.
2730 fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
2731     t as *const () == u as *const ()
2732 }
2733
2734 pub fn provide(providers: &mut ty::query::Providers<'_>) {
2735     providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id);
2736     providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).map(|v| &v[..]);
2737     providers.crate_name = |tcx, id| {
2738         assert_eq!(id, LOCAL_CRATE);
2739         tcx.crate_name
2740     };
2741     providers.maybe_unused_trait_import = |tcx, id| tcx.maybe_unused_trait_imports.contains(&id);
2742     providers.maybe_unused_extern_crates = |tcx, cnum| {
2743         assert_eq!(cnum, LOCAL_CRATE);
2744         &tcx.maybe_unused_extern_crates[..]
2745     };
2746     providers.names_imported_by_glob_use =
2747         |tcx, id| tcx.arena.alloc(tcx.glob_map.get(&id).cloned().unwrap_or_default());
2748
2749     providers.lookup_stability = |tcx, id| {
2750         let id = tcx.hir().local_def_id_to_hir_id(id.expect_local());
2751         tcx.stability().local_stability(id)
2752     };
2753     providers.lookup_const_stability = |tcx, id| {
2754         let id = tcx.hir().local_def_id_to_hir_id(id.expect_local());
2755         tcx.stability().local_const_stability(id)
2756     };
2757     providers.lookup_deprecation_entry = |tcx, id| {
2758         let id = tcx.hir().local_def_id_to_hir_id(id.expect_local());
2759         tcx.stability().local_deprecation_entry(id)
2760     };
2761     providers.extern_mod_stmt_cnum = |tcx, id| tcx.extern_crate_map.get(&id).cloned();
2762     providers.all_crate_nums = |tcx, cnum| {
2763         assert_eq!(cnum, LOCAL_CRATE);
2764         tcx.arena.alloc_slice(&tcx.cstore.crates_untracked())
2765     };
2766     providers.output_filenames = |tcx, cnum| {
2767         assert_eq!(cnum, LOCAL_CRATE);
2768         tcx.output_filenames.clone()
2769     };
2770     providers.features_query = |tcx, cnum| {
2771         assert_eq!(cnum, LOCAL_CRATE);
2772         tcx.sess.features_untracked()
2773     };
2774     providers.is_panic_runtime = |tcx, cnum| {
2775         assert_eq!(cnum, LOCAL_CRATE);
2776         attr::contains_name(tcx.hir().krate_attrs(), sym::panic_runtime)
2777     };
2778     providers.is_compiler_builtins = |tcx, cnum| {
2779         assert_eq!(cnum, LOCAL_CRATE);
2780         attr::contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
2781     };
2782     providers.has_panic_handler = |tcx, cnum| {
2783         assert_eq!(cnum, LOCAL_CRATE);
2784         // We want to check if the panic handler was defined in this crate
2785         tcx.lang_items().panic_impl().map_or(false, |did| did.is_local())
2786     };
2787 }