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