compiler/rustc_middle/src/ty/context.rs

   1 //! Type context book-keeping.
   2
   3 use crate::arena::Arena;
   4 use crate::dep_graph::{DepGraph, DepKindStruct};
   5 use crate::hir::place::Place as HirPlace;
   6 use crate::infer::canonical::{Canonical, CanonicalVarInfo, CanonicalVarInfos};
   7 use crate::lint::struct_lint_level;
   8 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
   9 use crate::middle::resolve_lifetime;
  10 use crate::middle::stability;
  11 use crate::mir::interpret::{self, Allocation, ConstAllocation};
  12 use crate::mir::{
  13     Body, BorrowCheckResult, Field, Local, Place, PlaceElem, ProjectionKind, Promoted,
  14 };
  15 use crate::thir::Thir;
  16 use crate::traits;
  17 use crate::ty::query::{self, TyCtxtAt};
  18 use crate::ty::{
  19     self, AdtDef, AdtDefData, AdtKind, Binder, BindingMode, BoundVar, CanonicalPolyFnSig,
  20     ClosureSizeProfileData, Const, ConstS, ConstVid, DefIdTree, FloatTy, FloatVar, FloatVid,
  21     GenericParamDefKind, InferConst, InferTy, IntTy, IntVar, IntVid, List, ParamConst, ParamTy,
  22     PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, PredicateS, ProjectionTy,
  23     Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyS, TyVar, TyVid, TypeAndMut,
  24     UintTy, Visibility,
  25 };
  26 use crate::ty::{GenericArg, GenericArgKind, InternalSubsts, SubstsRef, UserSubsts};
  27 use rustc_ast as ast;
  28 use rustc_data_structures::fingerprint::Fingerprint;
  29 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  30 use rustc_data_structures::intern::{Interned, WithStableHash};
  31 use rustc_data_structures::memmap::Mmap;
  32 use rustc_data_structures::profiling::SelfProfilerRef;
  33 use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
  34 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
  35 use rustc_data_structures::steal::Steal;
  36 use rustc_data_structures::sync::{self, Lock, Lrc, ReadGuard, RwLock, WorkerLocal};
  37 use rustc_data_structures::unord::UnordSet;
  38 use rustc_data_structures::vec_map::VecMap;
  39 use rustc_errors::{
  40     DecorateLint, DiagnosticBuilder, DiagnosticMessage, ErrorGuaranteed, MultiSpan,
  41 };
  42 use rustc_hir as hir;
  43 use rustc_hir::def::{DefKind, Res};
  44 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LocalDefIdMap, LOCAL_CRATE};
  45 use rustc_hir::definitions::Definitions;
  46 use rustc_hir::hir_id::OwnerId;
  47 use rustc_hir::intravisit::Visitor;
  48 use rustc_hir::lang_items::LangItem;
  49 use rustc_hir::{
  50     Constness, ExprKind, HirId, ImplItemKind, ItemKind, ItemLocalId, ItemLocalMap, ItemLocalSet,
  51     Node, TraitCandidate, TraitItemKind,
  52 };
  53 use rustc_index::vec::{Idx, IndexVec};
  54 use rustc_macros::HashStable;
  55 use rustc_middle::mir::FakeReadCause;
  56 use rustc_query_system::ich::StableHashingContext;
  57 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
  58 use rustc_session::config::{CrateType, OutputFilenames};
  59 use rustc_session::cstore::CrateStoreDyn;
  60 use rustc_session::lint::Lint;
  61 use rustc_session::Limit;
  62 use rustc_session::Session;
  63 use rustc_span::def_id::{DefPathHash, StableCrateId};
  64 use rustc_span::source_map::SourceMap;
  65 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  66 use rustc_span::{Span, DUMMY_SP};
  67 use rustc_target::abi::{Layout, LayoutS, TargetDataLayout, VariantIdx};
  68 use rustc_target::spec::abi;
  69 use rustc_type_ir::sty::TyKind::*;
  70 use rustc_type_ir::{DynKind, InternAs, InternIteratorElement, Interner, TypeFlags};
  71
  72 use std::any::Any;
  73 use std::borrow::Borrow;
  74 use std::cmp::Ordering;
  75 use std::collections::hash_map::{self, Entry};
  76 use std::fmt;
  77 use std::hash::{Hash, Hasher};
  78 use std::iter;
  79 use std::mem;
  80 use std::ops::{Bound, Deref};
  81 use std::sync::Arc;
  82
  83 use super::{ImplPolarity, ResolverOutputs, RvalueScopes};
  84
  85 pub trait OnDiskCache<'tcx>: rustc_data_structures::sync::Sync {
  86     /// Creates a new `OnDiskCache` instance from the serialized data in `data`.
  87     fn new(sess: &'tcx Session, data: Mmap, start_pos: usize) -> Self
  88     where
  89         Self: Sized;
  90
  91     fn new_empty(source_map: &'tcx SourceMap) -> Self
  92     where
  93         Self: Sized;
  94
  95     fn drop_serialized_data(&self, tcx: TyCtxt<'tcx>);
  96
  97     fn serialize(&self, tcx: TyCtxt<'tcx>, encoder: FileEncoder) -> FileEncodeResult;
  98 }
  99
 100 #[allow(rustc::usage_of_ty_tykind)]
 101 impl<'tcx> Interner for TyCtxt<'tcx> {
 102     type AdtDef = ty::AdtDef<'tcx>;
 103     type SubstsRef = ty::SubstsRef<'tcx>;
 104     type DefId = DefId;
 105     type Ty = Ty<'tcx>;
 106     type Const = ty::Const<'tcx>;
 107     type Region = Region<'tcx>;
 108     type TypeAndMut = TypeAndMut<'tcx>;
 109     type Mutability = hir::Mutability;
 110     type Movability = hir::Movability;
 111     type PolyFnSig = PolyFnSig<'tcx>;
 112     type ListBinderExistentialPredicate = &'tcx List<PolyExistentialPredicate<'tcx>>;
 113     type BinderListTy = Binder<'tcx, &'tcx List<Ty<'tcx>>>;
 114     type ListTy = &'tcx List<Ty<'tcx>>;
 115     type ProjectionTy = ty::ProjectionTy<'tcx>;
 116     type ParamTy = ParamTy;
 117     type BoundTy = ty::BoundTy;
 118     type PlaceholderType = ty::PlaceholderType;
 119     type InferTy = InferTy;
 120     type ErrorGuaranteed = ErrorGuaranteed;
 121     type PredicateKind = ty::PredicateKind<'tcx>;
 122     type AllocId = crate::mir::interpret::AllocId;
 123
 124     type EarlyBoundRegion = ty::EarlyBoundRegion;
 125     type BoundRegion = ty::BoundRegion;
 126     type FreeRegion = ty::FreeRegion;
 127     type RegionVid = ty::RegionVid;
 128     type PlaceholderRegion = ty::PlaceholderRegion;
 129 }
 130
 131 type InternedSet<'tcx, T> = ShardedHashMap<InternedInSet<'tcx, T>, ()>;
 132
 133 pub struct CtxtInterners<'tcx> {
 134     /// The arena that types, regions, etc. are allocated from.
 135     arena: &'tcx WorkerLocal<Arena<'tcx>>,
 136
 137     // Specifically use a speedy hash algorithm for these hash sets, since
 138     // they're accessed quite often.
 139     type_: InternedSet<'tcx, WithStableHash<TyS<'tcx>>>,
 140     substs: InternedSet<'tcx, InternalSubsts<'tcx>>,
 141     canonical_var_infos: InternedSet<'tcx, List<CanonicalVarInfo<'tcx>>>,
 142     region: InternedSet<'tcx, RegionKind<'tcx>>,
 143     poly_existential_predicates: InternedSet<'tcx, List<PolyExistentialPredicate<'tcx>>>,
 144     predicate: InternedSet<'tcx, PredicateS<'tcx>>,
 145     predicates: InternedSet<'tcx, List<Predicate<'tcx>>>,
 146     projs: InternedSet<'tcx, List<ProjectionKind>>,
 147     place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>,
 148     const_: InternedSet<'tcx, ConstS<'tcx>>,
 149     const_allocation: InternedSet<'tcx, Allocation>,
 150     bound_variable_kinds: InternedSet<'tcx, List<ty::BoundVariableKind>>,
 151     layout: InternedSet<'tcx, LayoutS<'tcx>>,
 152     adt_def: InternedSet<'tcx, AdtDefData>,
 153 }
 154
 155 impl<'tcx> CtxtInterners<'tcx> {
 156     fn new(arena: &'tcx WorkerLocal<Arena<'tcx>>) -> CtxtInterners<'tcx> {
 157         CtxtInterners {
 158             arena,
 159             type_: Default::default(),
 160             substs: Default::default(),
 161             region: Default::default(),
 162             poly_existential_predicates: Default::default(),
 163             canonical_var_infos: Default::default(),
 164             predicate: Default::default(),
 165             predicates: Default::default(),
 166             projs: Default::default(),
 167             place_elems: Default::default(),
 168             const_: Default::default(),
 169             const_allocation: Default::default(),
 170             bound_variable_kinds: Default::default(),
 171             layout: Default::default(),
 172             adt_def: Default::default(),
 173         }
 174     }
 175
 176     /// Interns a type.
 177     #[allow(rustc::usage_of_ty_tykind)]
 178     #[inline(never)]
 179     fn intern_ty(
 180         &self,
 181         kind: TyKind<'tcx>,
 182         sess: &Session,
 183         definitions: &rustc_hir::definitions::Definitions,
 184         cstore: &CrateStoreDyn,
 185         source_span: &IndexVec<LocalDefId, Span>,
 186     ) -> Ty<'tcx> {
 187         Ty(Interned::new_unchecked(
 188             self.type_
 189                 .intern(kind, |kind| {
 190                     let flags = super::flags::FlagComputation::for_kind(&kind);
 191
 192                     // It's impossible to hash inference variables (and will ICE), so we don't need to try to cache them.
 193                     // Without incremental, we rarely stable-hash types, so let's not do it proactively.
 194                     let stable_hash = if flags.flags.intersects(TypeFlags::NEEDS_INFER)
 195                         || sess.opts.incremental.is_none()
 196                     {
 197                         Fingerprint::ZERO
 198                     } else {
 199                         let mut hasher = StableHasher::new();
 200                         let mut hcx =
 201                             StableHashingContext::new(sess, definitions, cstore, source_span);
 202                         kind.hash_stable(&mut hcx, &mut hasher);
 203                         hasher.finish()
 204                     };
 205
 206                     let ty_struct = TyS {
 207                         kind,
 208                         flags: flags.flags,
 209                         outer_exclusive_binder: flags.outer_exclusive_binder,
 210                     };
 211
 212                     InternedInSet(
 213                         self.arena.alloc(WithStableHash { internee: ty_struct, stable_hash }),
 214                     )
 215                 })
 216                 .0,
 217         ))
 218     }
 219
 220     #[inline(never)]
 221     fn intern_predicate(&self, kind: Binder<'tcx, PredicateKind<'tcx>>) -> Predicate<'tcx> {
 222         Predicate(Interned::new_unchecked(
 223             self.predicate
 224                 .intern(kind, |kind| {
 225                     let flags = super::flags::FlagComputation::for_predicate(kind);
 226
 227                     let predicate_struct = PredicateS {
 228                         kind,
 229                         flags: flags.flags,
 230                         outer_exclusive_binder: flags.outer_exclusive_binder,
 231                     };
 232
 233                     InternedInSet(self.arena.alloc(predicate_struct))
 234                 })
 235                 .0,
 236         ))
 237     }
 238 }
 239
 240 pub struct CommonTypes<'tcx> {
 241     pub unit: Ty<'tcx>,
 242     pub bool: Ty<'tcx>,
 243     pub char: Ty<'tcx>,
 244     pub isize: Ty<'tcx>,
 245     pub i8: Ty<'tcx>,
 246     pub i16: Ty<'tcx>,
 247     pub i32: Ty<'tcx>,
 248     pub i64: Ty<'tcx>,
 249     pub i128: Ty<'tcx>,
 250     pub usize: Ty<'tcx>,
 251     pub u8: Ty<'tcx>,
 252     pub u16: Ty<'tcx>,
 253     pub u32: Ty<'tcx>,
 254     pub u64: Ty<'tcx>,
 255     pub u128: Ty<'tcx>,
 256     pub f32: Ty<'tcx>,
 257     pub f64: Ty<'tcx>,
 258     pub str_: Ty<'tcx>,
 259     pub never: Ty<'tcx>,
 260     pub self_param: Ty<'tcx>,
 261
 262     /// Dummy type used for the `Self` of a `TraitRef` created for converting
 263     /// a trait object, and which gets removed in `ExistentialTraitRef`.
 264     /// This type must not appear anywhere in other converted types.
 265     pub trait_object_dummy_self: Ty<'tcx>,
 266 }
 267
 268 pub struct CommonLifetimes<'tcx> {
 269     /// `ReStatic`
 270     pub re_static: Region<'tcx>,
 271
 272     /// Erased region, used outside of type inference.
 273     pub re_erased: Region<'tcx>,
 274 }
 275
 276 pub struct CommonConsts<'tcx> {
 277     pub unit: Const<'tcx>,
 278 }
 279
 280 pub struct LocalTableInContext<'a, V> {
 281     hir_owner: OwnerId,
 282     data: &'a ItemLocalMap<V>,
 283 }
 284
 285 /// Validate that the given HirId (respectively its `local_id` part) can be
 286 /// safely used as a key in the maps of a TypeckResults. For that to be
 287 /// the case, the HirId must have the same `owner` as all the other IDs in
 288 /// this table (signified by `hir_owner`). Otherwise the HirId
 289 /// would be in a different frame of reference and using its `local_id`
 290 /// would result in lookup errors, or worse, in silently wrong data being
 291 /// stored/returned.
 292 #[inline]
 293 fn validate_hir_id_for_typeck_results(hir_owner: OwnerId, hir_id: hir::HirId) {
 294     if hir_id.owner != hir_owner {
 295         invalid_hir_id_for_typeck_results(hir_owner, hir_id);
 296     }
 297 }
 298
 299 #[cold]
 300 #[inline(never)]
 301 fn invalid_hir_id_for_typeck_results(hir_owner: OwnerId, hir_id: hir::HirId) {
 302     ty::tls::with(|tcx| {
 303         bug!(
 304             "node {} with HirId::owner {:?} cannot be placed in TypeckResults with hir_owner {:?}",
 305             tcx.hir().node_to_string(hir_id),
 306             hir_id.owner,
 307             hir_owner
 308         )
 309     });
 310 }
 311
 312 impl<'a, V> LocalTableInContext<'a, V> {
 313     pub fn contains_key(&self, id: hir::HirId) -> bool {
 314         validate_hir_id_for_typeck_results(self.hir_owner, id);
 315         self.data.contains_key(&id.local_id)
 316     }
 317
 318     pub fn get(&self, id: hir::HirId) -> Option<&V> {
 319         validate_hir_id_for_typeck_results(self.hir_owner, id);
 320         self.data.get(&id.local_id)
 321     }
 322
 323     pub fn iter(&self) -> hash_map::Iter<'_, hir::ItemLocalId, V> {
 324         self.data.iter()
 325     }
 326 }
 327
 328 impl<'a, V> ::std::ops::Index<hir::HirId> for LocalTableInContext<'a, V> {
 329     type Output = V;
 330
 331     fn index(&self, key: hir::HirId) -> &V {
 332         self.get(key).expect("LocalTableInContext: key not found")
 333     }
 334 }
 335
 336 pub struct LocalTableInContextMut<'a, V> {
 337     hir_owner: OwnerId,
 338     data: &'a mut ItemLocalMap<V>,
 339 }
 340
 341 impl<'a, V> LocalTableInContextMut<'a, V> {
 342     pub fn get_mut(&mut self, id: hir::HirId) -> Option<&mut V> {
 343         validate_hir_id_for_typeck_results(self.hir_owner, id);
 344         self.data.get_mut(&id.local_id)
 345     }
 346
 347     pub fn entry(&mut self, id: hir::HirId) -> Entry<'_, hir::ItemLocalId, V> {
 348         validate_hir_id_for_typeck_results(self.hir_owner, id);
 349         self.data.entry(id.local_id)
 350     }
 351
 352     pub fn insert(&mut self, id: hir::HirId, val: V) -> Option<V> {
 353         validate_hir_id_for_typeck_results(self.hir_owner, id);
 354         self.data.insert(id.local_id, val)
 355     }
 356
 357     pub fn remove(&mut self, id: hir::HirId) -> Option<V> {
 358         validate_hir_id_for_typeck_results(self.hir_owner, id);
 359         self.data.remove(&id.local_id)
 360     }
 361 }
 362
 363 /// Whenever a value may be live across a generator yield, the type of that value winds up in the
 364 /// `GeneratorInteriorTypeCause` struct. This struct adds additional information about such
 365 /// captured types that can be useful for diagnostics. In particular, it stores the span that
 366 /// caused a given type to be recorded, along with the scope that enclosed the value (which can
 367 /// be used to find the await that the value is live across).
 368 ///
 369 /// For example:
 370 ///
 371 /// ```ignore (pseudo-Rust)
 372 /// async move {
 373 ///     let x: T = expr;
 374 ///     foo.await
 375 ///     ...
 376 /// }
 377 /// ```
 378 ///
 379 /// Here, we would store the type `T`, the span of the value `x`, the "scope-span" for
 380 /// the scope that contains `x`, the expr `T` evaluated from, and the span of `foo.await`.
 381 #[derive(TyEncodable, TyDecodable, Clone, Debug, Eq, Hash, PartialEq, HashStable)]
 382 #[derive(TypeFoldable, TypeVisitable)]
 383 pub struct GeneratorInteriorTypeCause<'tcx> {
 384     /// Type of the captured binding.
 385     pub ty: Ty<'tcx>,
 386     /// Span of the binding that was captured.
 387     pub span: Span,
 388     /// Span of the scope of the captured binding.
 389     pub scope_span: Option<Span>,
 390     /// Span of `.await` or `yield` expression.
 391     pub yield_span: Span,
 392     /// Expr which the type evaluated from.
 393     pub expr: Option<hir::HirId>,
 394 }
 395
 396 // This type holds diagnostic information on generators and async functions across crate boundaries
 397 // and is used to provide better error messages
 398 #[derive(TyEncodable, TyDecodable, Clone, Debug, HashStable)]
 399 pub struct GeneratorDiagnosticData<'tcx> {
 400     pub generator_interior_types: ty::Binder<'tcx, Vec<GeneratorInteriorTypeCause<'tcx>>>,
 401     pub hir_owner: DefId,
 402     pub nodes_types: ItemLocalMap<Ty<'tcx>>,
 403     pub adjustments: ItemLocalMap<Vec<ty::adjustment::Adjustment<'tcx>>>,
 404 }
 405
 406 #[derive(TyEncodable, TyDecodable, Debug, HashStable)]
 407 pub struct TypeckResults<'tcx> {
 408     /// The `HirId::owner` all `ItemLocalId`s in this table are relative to.
 409     pub hir_owner: OwnerId,
 410
 411     /// Resolved definitions for `<T>::X` associated paths and
 412     /// method calls, including those of overloaded operators.
 413     type_dependent_defs: ItemLocalMap<Result<(DefKind, DefId), ErrorGuaranteed>>,
 414
 415     /// Resolved field indices for field accesses in expressions (`S { field }`, `obj.field`)
 416     /// or patterns (`S { field }`). The index is often useful by itself, but to learn more
 417     /// about the field you also need definition of the variant to which the field
 418     /// belongs, but it may not exist if it's a tuple field (`tuple.0`).
 419     field_indices: ItemLocalMap<usize>,
 420
 421     /// Stores the types for various nodes in the AST. Note that this table
 422     /// is not guaranteed to be populated outside inference. See
 423     /// typeck::check::fn_ctxt for details.
 424     node_types: ItemLocalMap<Ty<'tcx>>,
 425
 426     /// Stores the type parameters which were substituted to obtain the type
 427     /// of this node. This only applies to nodes that refer to entities
 428     /// parameterized by type parameters, such as generic fns, types, or
 429     /// other items.
 430     node_substs: ItemLocalMap<SubstsRef<'tcx>>,
 431
 432     /// This will either store the canonicalized types provided by the user
 433     /// or the substitutions that the user explicitly gave (if any) attached
 434     /// to `id`. These will not include any inferred values. The canonical form
 435     /// is used to capture things like `_` or other unspecified values.
 436     ///
 437     /// For example, if the user wrote `foo.collect::<Vec<_>>()`, then the
 438     /// canonical substitutions would include only `for<X> { Vec<X> }`.
 439     ///
 440     /// See also `AscribeUserType` statement in MIR.
 441     user_provided_types: ItemLocalMap<CanonicalUserType<'tcx>>,
 442
 443     /// Stores the canonicalized types provided by the user. See also
 444     /// `AscribeUserType` statement in MIR.
 445     pub user_provided_sigs: LocalDefIdMap<CanonicalPolyFnSig<'tcx>>,
 446
 447     adjustments: ItemLocalMap<Vec<ty::adjustment::Adjustment<'tcx>>>,
 448
 449     /// Stores the actual binding mode for all instances of hir::BindingAnnotation.
 450     pat_binding_modes: ItemLocalMap<BindingMode>,
 451
 452     /// Stores the types which were implicitly dereferenced in pattern binding modes
 453     /// for later usage in THIR lowering. For example,
 454     ///
 455     /// ```
 456     /// match &&Some(5i32) {
 457     ///     Some(n) => {},
 458     ///     _ => {},
 459     /// }
 460     /// ```
 461     /// leads to a `vec![&&Option<i32>, &Option<i32>]`. Empty vectors are not stored.
 462     ///
 463     /// See:
 464     /// <https://github.com/rust-lang/rfcs/blob/master/text/2005-match-ergonomics.md#definitions>
 465     pat_adjustments: ItemLocalMap<Vec<Ty<'tcx>>>,
 466
 467     /// Records the reasons that we picked the kind of each closure;
 468     /// not all closures are present in the map.
 469     closure_kind_origins: ItemLocalMap<(Span, HirPlace<'tcx>)>,
 470
 471     /// For each fn, records the "liberated" types of its arguments
 472     /// and return type. Liberated means that all bound regions
 473     /// (including late-bound regions) are replaced with free
 474     /// equivalents. This table is not used in codegen (since regions
 475     /// are erased there) and hence is not serialized to metadata.
 476     ///
 477     /// This table also contains the "revealed" values for any `impl Trait`
 478     /// that appear in the signature and whose values are being inferred
 479     /// by this function.
 480     ///
 481     /// # Example
 482     ///
 483     /// ```rust
 484     /// # use std::fmt::Debug;
 485     /// fn foo(x: &u32) -> impl Debug { *x }
 486     /// ```
 487     ///
 488     /// The function signature here would be:
 489     ///
 490     /// ```ignore (illustrative)
 491     /// for<'a> fn(&'a u32) -> Foo
 492     /// ```
 493     ///
 494     /// where `Foo` is an opaque type created for this function.
 495     ///
 496     ///
 497     /// The *liberated* form of this would be
 498     ///
 499     /// ```ignore (illustrative)
 500     /// fn(&'a u32) -> u32
 501     /// ```
 502     ///
 503     /// Note that `'a` is not bound (it would be an `ReFree`) and
 504     /// that the `Foo` opaque type is replaced by its hidden type.
 505     liberated_fn_sigs: ItemLocalMap<ty::FnSig<'tcx>>,
 506
 507     /// For each FRU expression, record the normalized types of the fields
 508     /// of the struct - this is needed because it is non-trivial to
 509     /// normalize while preserving regions. This table is used only in
 510     /// MIR construction and hence is not serialized to metadata.
 511     fru_field_types: ItemLocalMap<Vec<Ty<'tcx>>>,
 512
 513     /// For every coercion cast we add the HIR node ID of the cast
 514     /// expression to this set.
 515     coercion_casts: ItemLocalSet,
 516
 517     /// Set of trait imports actually used in the method resolution.
 518     /// This is used for warning unused imports. During type
 519     /// checking, this `Lrc` should not be cloned: it must have a ref-count
 520     /// of 1 so that we can insert things into the set mutably.
 521     pub used_trait_imports: Lrc<UnordSet<LocalDefId>>,
 522
 523     /// If any errors occurred while type-checking this body,
 524     /// this field will be set to `Some(ErrorGuaranteed)`.
 525     pub tainted_by_errors: Option<ErrorGuaranteed>,
 526
 527     /// All the opaque types that have hidden types set
 528     /// by this function. We also store the
 529     /// type here, so that mir-borrowck can use it as a hint for figuring out hidden types,
 530     /// even if they are only set in dead code (which doesn't show up in MIR).
 531     pub concrete_opaque_types: VecMap<LocalDefId, ty::OpaqueHiddenType<'tcx>>,
 532
 533     /// Tracks the minimum captures required for a closure;
 534     /// see `MinCaptureInformationMap` for more details.
 535     pub closure_min_captures: ty::MinCaptureInformationMap<'tcx>,
 536
 537     /// Tracks the fake reads required for a closure and the reason for the fake read.
 538     /// When performing pattern matching for closures, there are times we don't end up
 539     /// reading places that are mentioned in a closure (because of _ patterns). However,
 540     /// to ensure the places are initialized, we introduce fake reads.
 541     /// Consider these two examples:
 542     /// ``` (discriminant matching with only wildcard arm)
 543     /// let x: u8;
 544     /// let c = || match x { _ => () };
 545     /// ```
 546     /// In this example, we don't need to actually read/borrow `x` in `c`, and so we don't
 547     /// want to capture it. However, we do still want an error here, because `x` should have
 548     /// to be initialized at the point where c is created. Therefore, we add a "fake read"
 549     /// instead.
 550     /// ``` (destructured assignments)
 551     /// let c = || {
 552     ///     let (t1, t2) = t;
 553     /// }
 554     /// ```
 555     /// In the second example, we capture the disjoint fields of `t` (`t.0` & `t.1`), but
 556     /// we never capture `t`. This becomes an issue when we build MIR as we require
 557     /// information on `t` in order to create place `t.0` and `t.1`. We can solve this
 558     /// issue by fake reading `t`.
 559     pub closure_fake_reads: FxHashMap<LocalDefId, Vec<(HirPlace<'tcx>, FakeReadCause, hir::HirId)>>,
 560
 561     /// Tracks the rvalue scoping rules which defines finer scoping for rvalue expressions
 562     /// by applying extended parameter rules.
 563     /// Details may be find in `rustc_hir_analysis::check::rvalue_scopes`.
 564     pub rvalue_scopes: RvalueScopes,
 565
 566     /// Stores the type, expression, span and optional scope span of all types
 567     /// that are live across the yield of this generator (if a generator).
 568     pub generator_interior_types: ty::Binder<'tcx, Vec<GeneratorInteriorTypeCause<'tcx>>>,
 569
 570     /// We sometimes treat byte string literals (which are of type `&[u8; N]`)
 571     /// as `&[u8]`, depending on the pattern  in which they are used.
 572     /// This hashset records all instances where we behave
 573     /// like this to allow `const_to_pat` to reliably handle this situation.
 574     pub treat_byte_string_as_slice: ItemLocalSet,
 575
 576     /// Contains the data for evaluating the effect of feature `capture_disjoint_fields`
 577     /// on closure size.
 578     pub closure_size_eval: FxHashMap<LocalDefId, ClosureSizeProfileData<'tcx>>,
 579 }
 580
 581 impl<'tcx> TypeckResults<'tcx> {
 582     pub fn new(hir_owner: OwnerId) -> TypeckResults<'tcx> {
 583         TypeckResults {
 584             hir_owner,
 585             type_dependent_defs: Default::default(),
 586             field_indices: Default::default(),
 587             user_provided_types: Default::default(),
 588             user_provided_sigs: Default::default(),
 589             node_types: Default::default(),
 590             node_substs: Default::default(),
 591             adjustments: Default::default(),
 592             pat_binding_modes: Default::default(),
 593             pat_adjustments: Default::default(),
 594             closure_kind_origins: Default::default(),
 595             liberated_fn_sigs: Default::default(),
 596             fru_field_types: Default::default(),
 597             coercion_casts: Default::default(),
 598             used_trait_imports: Lrc::new(Default::default()),
 599             tainted_by_errors: None,
 600             concrete_opaque_types: Default::default(),
 601             closure_min_captures: Default::default(),
 602             closure_fake_reads: Default::default(),
 603             rvalue_scopes: Default::default(),
 604             generator_interior_types: ty::Binder::dummy(Default::default()),
 605             treat_byte_string_as_slice: Default::default(),
 606             closure_size_eval: Default::default(),
 607         }
 608     }
 609
 610     /// Returns the final resolution of a `QPath` in an `Expr` or `Pat` node.
 611     pub fn qpath_res(&self, qpath: &hir::QPath<'_>, id: hir::HirId) -> Res {
 612         match *qpath {
 613             hir::QPath::Resolved(_, ref path) => path.res,
 614             hir::QPath::TypeRelative(..) | hir::QPath::LangItem(..) => self
 615                 .type_dependent_def(id)
 616                 .map_or(Res::Err, |(kind, def_id)| Res::Def(kind, def_id)),
 617         }
 618     }
 619
 620     pub fn type_dependent_defs(
 621         &self,
 622     ) -> LocalTableInContext<'_, Result<(DefKind, DefId), ErrorGuaranteed>> {
 623         LocalTableInContext { hir_owner: self.hir_owner, data: &self.type_dependent_defs }
 624     }
 625
 626     pub fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)> {
 627         validate_hir_id_for_typeck_results(self.hir_owner, id);
 628         self.type_dependent_defs.get(&id.local_id).cloned().and_then(|r| r.ok())
 629     }
 630
 631     pub fn type_dependent_def_id(&self, id: HirId) -> Option<DefId> {
 632         self.type_dependent_def(id).map(|(_, def_id)| def_id)
 633     }
 634
 635     pub fn type_dependent_defs_mut(
 636         &mut self,
 637     ) -> LocalTableInContextMut<'_, Result<(DefKind, DefId), ErrorGuaranteed>> {
 638         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.type_dependent_defs }
 639     }
 640
 641     pub fn field_indices(&self) -> LocalTableInContext<'_, usize> {
 642         LocalTableInContext { hir_owner: self.hir_owner, data: &self.field_indices }
 643     }
 644
 645     pub fn field_indices_mut(&mut self) -> LocalTableInContextMut<'_, usize> {
 646         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.field_indices }
 647     }
 648
 649     pub fn user_provided_types(&self) -> LocalTableInContext<'_, CanonicalUserType<'tcx>> {
 650         LocalTableInContext { hir_owner: self.hir_owner, data: &self.user_provided_types }
 651     }
 652
 653     pub fn user_provided_types_mut(
 654         &mut self,
 655     ) -> LocalTableInContextMut<'_, CanonicalUserType<'tcx>> {
 656         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.user_provided_types }
 657     }
 658
 659     pub fn node_types(&self) -> LocalTableInContext<'_, Ty<'tcx>> {
 660         LocalTableInContext { hir_owner: self.hir_owner, data: &self.node_types }
 661     }
 662
 663     pub fn node_types_mut(&mut self) -> LocalTableInContextMut<'_, Ty<'tcx>> {
 664         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.node_types }
 665     }
 666
 667     pub fn get_generator_diagnostic_data(&self) -> GeneratorDiagnosticData<'tcx> {
 668         let generator_interior_type = self.generator_interior_types.map_bound_ref(|vec| {
 669             vec.iter()
 670                 .map(|item| {
 671                     GeneratorInteriorTypeCause {
 672                         ty: item.ty,
 673                         span: item.span,
 674                         scope_span: item.scope_span,
 675                         yield_span: item.yield_span,
 676                         expr: None, //FIXME: Passing expression over crate boundaries is impossible at the moment
 677                     }
 678                 })
 679                 .collect::<Vec<_>>()
 680         });
 681         GeneratorDiagnosticData {
 682             generator_interior_types: generator_interior_type,
 683             hir_owner: self.hir_owner.to_def_id(),
 684             nodes_types: self.node_types.clone(),
 685             adjustments: self.adjustments.clone(),
 686         }
 687     }
 688
 689     pub fn node_type(&self, id: hir::HirId) -> Ty<'tcx> {
 690         self.node_type_opt(id).unwrap_or_else(|| {
 691             bug!("node_type: no type for node `{}`", tls::with(|tcx| tcx.hir().node_to_string(id)))
 692         })
 693     }
 694
 695     pub fn node_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
 696         validate_hir_id_for_typeck_results(self.hir_owner, id);
 697         self.node_types.get(&id.local_id).cloned()
 698     }
 699
 700     pub fn node_substs_mut(&mut self) -> LocalTableInContextMut<'_, SubstsRef<'tcx>> {
 701         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.node_substs }
 702     }
 703
 704     pub fn node_substs(&self, id: hir::HirId) -> SubstsRef<'tcx> {
 705         validate_hir_id_for_typeck_results(self.hir_owner, id);
 706         self.node_substs.get(&id.local_id).cloned().unwrap_or_else(|| InternalSubsts::empty())
 707     }
 708
 709     pub fn node_substs_opt(&self, id: hir::HirId) -> Option<SubstsRef<'tcx>> {
 710         validate_hir_id_for_typeck_results(self.hir_owner, id);
 711         self.node_substs.get(&id.local_id).cloned()
 712     }
 713
 714     // Returns the type of a pattern as a monotype. Like @expr_ty, this function
 715     // doesn't provide type parameter substitutions.
 716     pub fn pat_ty(&self, pat: &hir::Pat<'_>) -> Ty<'tcx> {
 717         self.node_type(pat.hir_id)
 718     }
 719
 720     // Returns the type of an expression as a monotype.
 721     //
 722     // NB (1): This is the PRE-ADJUSTMENT TYPE for the expression.  That is, in
 723     // some cases, we insert `Adjustment` annotations such as auto-deref or
 724     // auto-ref.  The type returned by this function does not consider such
 725     // adjustments.  See `expr_ty_adjusted()` instead.
 726     //
 727     // NB (2): This type doesn't provide type parameter substitutions; e.g., if you
 728     // ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize"
 729     // instead of "fn(ty) -> T with T = isize".
 730     pub fn expr_ty(&self, expr: &hir::Expr<'_>) -> Ty<'tcx> {
 731         self.node_type(expr.hir_id)
 732     }
 733
 734     pub fn expr_ty_opt(&self, expr: &hir::Expr<'_>) -> Option<Ty<'tcx>> {
 735         self.node_type_opt(expr.hir_id)
 736     }
 737
 738     pub fn adjustments(&self) -> LocalTableInContext<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
 739         LocalTableInContext { hir_owner: self.hir_owner, data: &self.adjustments }
 740     }
 741
 742     pub fn adjustments_mut(
 743         &mut self,
 744     ) -> LocalTableInContextMut<'_, Vec<ty::adjustment::Adjustment<'tcx>>> {
 745         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.adjustments }
 746     }
 747
 748     pub fn expr_adjustments(&self, expr: &hir::Expr<'_>) -> &[ty::adjustment::Adjustment<'tcx>] {
 749         validate_hir_id_for_typeck_results(self.hir_owner, expr.hir_id);
 750         self.adjustments.get(&expr.hir_id.local_id).map_or(&[], |a| &a[..])
 751     }
 752
 753     /// Returns the type of `expr`, considering any `Adjustment`
 754     /// entry recorded for that expression.
 755     pub fn expr_ty_adjusted(&self, expr: &hir::Expr<'_>) -> Ty<'tcx> {
 756         self.expr_adjustments(expr).last().map_or_else(|| self.expr_ty(expr), |adj| adj.target)
 757     }
 758
 759     pub fn expr_ty_adjusted_opt(&self, expr: &hir::Expr<'_>) -> Option<Ty<'tcx>> {
 760         self.expr_adjustments(expr).last().map(|adj| adj.target).or_else(|| self.expr_ty_opt(expr))
 761     }
 762
 763     pub fn is_method_call(&self, expr: &hir::Expr<'_>) -> bool {
 764         // Only paths and method calls/overloaded operators have
 765         // entries in type_dependent_defs, ignore the former here.
 766         if let hir::ExprKind::Path(_) = expr.kind {
 767             return false;
 768         }
 769
 770         matches!(self.type_dependent_defs().get(expr.hir_id), Some(Ok((DefKind::AssocFn, _))))
 771     }
 772
 773     pub fn extract_binding_mode(&self, s: &Session, id: HirId, sp: Span) -> Option<BindingMode> {
 774         self.pat_binding_modes().get(id).copied().or_else(|| {
 775             s.delay_span_bug(sp, "missing binding mode");
 776             None
 777         })
 778     }
 779
 780     pub fn pat_binding_modes(&self) -> LocalTableInContext<'_, BindingMode> {
 781         LocalTableInContext { hir_owner: self.hir_owner, data: &self.pat_binding_modes }
 782     }
 783
 784     pub fn pat_binding_modes_mut(&mut self) -> LocalTableInContextMut<'_, BindingMode> {
 785         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_binding_modes }
 786     }
 787
 788     pub fn pat_adjustments(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
 789         LocalTableInContext { hir_owner: self.hir_owner, data: &self.pat_adjustments }
 790     }
 791
 792     pub fn pat_adjustments_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
 793         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_adjustments }
 794     }
 795
 796     /// For a given closure, returns the iterator of `ty::CapturedPlace`s that are captured
 797     /// by the closure.
 798     pub fn closure_min_captures_flattened(
 799         &self,
 800         closure_def_id: LocalDefId,
 801     ) -> impl Iterator<Item = &ty::CapturedPlace<'tcx>> {
 802         self.closure_min_captures
 803             .get(&closure_def_id)
 804             .map(|closure_min_captures| closure_min_captures.values().flat_map(|v| v.iter()))
 805             .into_iter()
 806             .flatten()
 807     }
 808
 809     pub fn closure_kind_origins(&self) -> LocalTableInContext<'_, (Span, HirPlace<'tcx>)> {
 810         LocalTableInContext { hir_owner: self.hir_owner, data: &self.closure_kind_origins }
 811     }
 812
 813     pub fn closure_kind_origins_mut(
 814         &mut self,
 815     ) -> LocalTableInContextMut<'_, (Span, HirPlace<'tcx>)> {
 816         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.closure_kind_origins }
 817     }
 818
 819     pub fn liberated_fn_sigs(&self) -> LocalTableInContext<'_, ty::FnSig<'tcx>> {
 820         LocalTableInContext { hir_owner: self.hir_owner, data: &self.liberated_fn_sigs }
 821     }
 822
 823     pub fn liberated_fn_sigs_mut(&mut self) -> LocalTableInContextMut<'_, ty::FnSig<'tcx>> {
 824         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.liberated_fn_sigs }
 825     }
 826
 827     pub fn fru_field_types(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
 828         LocalTableInContext { hir_owner: self.hir_owner, data: &self.fru_field_types }
 829     }
 830
 831     pub fn fru_field_types_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
 832         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.fru_field_types }
 833     }
 834
 835     pub fn is_coercion_cast(&self, hir_id: hir::HirId) -> bool {
 836         validate_hir_id_for_typeck_results(self.hir_owner, hir_id);
 837         self.coercion_casts.contains(&hir_id.local_id)
 838     }
 839
 840     pub fn set_coercion_cast(&mut self, id: ItemLocalId) {
 841         self.coercion_casts.insert(id);
 842     }
 843
 844     pub fn coercion_casts(&self) -> &ItemLocalSet {
 845         &self.coercion_casts
 846     }
 847 }
 848
 849 rustc_index::newtype_index! {
 850     pub struct UserTypeAnnotationIndex {
 851         derive [HashStable]
 852         DEBUG_FORMAT = "UserType({})",
 853         const START_INDEX = 0,
 854     }
 855 }
 856
 857 /// Mapping of type annotation indices to canonical user type annotations.
 858 pub type CanonicalUserTypeAnnotations<'tcx> =
 859     IndexVec<UserTypeAnnotationIndex, CanonicalUserTypeAnnotation<'tcx>>;
 860
 861 #[derive(Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable, Lift)]
 862 pub struct CanonicalUserTypeAnnotation<'tcx> {
 863     pub user_ty: Box<CanonicalUserType<'tcx>>,
 864     pub span: Span,
 865     pub inferred_ty: Ty<'tcx>,
 866 }
 867
 868 /// Canonicalized user type annotation.
 869 pub type CanonicalUserType<'tcx> = Canonical<'tcx, UserType<'tcx>>;
 870
 871 impl<'tcx> CanonicalUserType<'tcx> {
 872     /// Returns `true` if this represents a substitution of the form `[?0, ?1, ?2]`,
 873     /// i.e., each thing is mapped to a canonical variable with the same index.
 874     pub fn is_identity(&self) -> bool {
 875         match self.value {
 876             UserType::Ty(_) => false,
 877             UserType::TypeOf(_, user_substs) => {
 878                 if user_substs.user_self_ty.is_some() {
 879                     return false;
 880                 }
 881
 882                 iter::zip(user_substs.substs, BoundVar::new(0)..).all(|(kind, cvar)| {
 883                     match kind.unpack() {
 884                         GenericArgKind::Type(ty) => match ty.kind() {
 885                             ty::Bound(debruijn, b) => {
 886                                 // We only allow a `ty::INNERMOST` index in substitutions.
 887                                 assert_eq!(*debruijn, ty::INNERMOST);
 888                                 cvar == b.var
 889                             }
 890                             _ => false,
 891                         },
 892
 893                         GenericArgKind::Lifetime(r) => match *r {
 894                             ty::ReLateBound(debruijn, br) => {
 895                                 // We only allow a `ty::INNERMOST` index in substitutions.
 896                                 assert_eq!(debruijn, ty::INNERMOST);
 897                                 cvar == br.var
 898                             }
 899                             _ => false,
 900                         },
 901
 902                         GenericArgKind::Const(ct) => match ct.kind() {
 903                             ty::ConstKind::Bound(debruijn, b) => {
 904                                 // We only allow a `ty::INNERMOST` index in substitutions.
 905                                 assert_eq!(debruijn, ty::INNERMOST);
 906                                 cvar == b
 907                             }
 908                             _ => false,
 909                         },
 910                     }
 911                 })
 912             }
 913         }
 914     }
 915 }
 916
 917 /// A user-given type annotation attached to a constant. These arise
 918 /// from constants that are named via paths, like `Foo::<A>::new` and
 919 /// so forth.
 920 #[derive(Copy, Clone, Debug, PartialEq, TyEncodable, TyDecodable)]
 921 #[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
 922 pub enum UserType<'tcx> {
 923     Ty(Ty<'tcx>),
 924
 925     /// The canonical type is the result of `type_of(def_id)` with the
 926     /// given substitutions applied.
 927     TypeOf(DefId, UserSubsts<'tcx>),
 928 }
 929
 930 impl<'tcx> CommonTypes<'tcx> {
 931     fn new(
 932         interners: &CtxtInterners<'tcx>,
 933         sess: &Session,
 934         definitions: &rustc_hir::definitions::Definitions,
 935         cstore: &CrateStoreDyn,
 936         source_span: &IndexVec<LocalDefId, Span>,
 937     ) -> CommonTypes<'tcx> {
 938         let mk = |ty| interners.intern_ty(ty, sess, definitions, cstore, source_span);
 939
 940         CommonTypes {
 941             unit: mk(Tuple(List::empty())),
 942             bool: mk(Bool),
 943             char: mk(Char),
 944             never: mk(Never),
 945             isize: mk(Int(ty::IntTy::Isize)),
 946             i8: mk(Int(ty::IntTy::I8)),
 947             i16: mk(Int(ty::IntTy::I16)),
 948             i32: mk(Int(ty::IntTy::I32)),
 949             i64: mk(Int(ty::IntTy::I64)),
 950             i128: mk(Int(ty::IntTy::I128)),
 951             usize: mk(Uint(ty::UintTy::Usize)),
 952             u8: mk(Uint(ty::UintTy::U8)),
 953             u16: mk(Uint(ty::UintTy::U16)),
 954             u32: mk(Uint(ty::UintTy::U32)),
 955             u64: mk(Uint(ty::UintTy::U64)),
 956             u128: mk(Uint(ty::UintTy::U128)),
 957             f32: mk(Float(ty::FloatTy::F32)),
 958             f64: mk(Float(ty::FloatTy::F64)),
 959             str_: mk(Str),
 960             self_param: mk(ty::Param(ty::ParamTy { index: 0, name: kw::SelfUpper })),
 961
 962             trait_object_dummy_self: mk(Infer(ty::FreshTy(0))),
 963         }
 964     }
 965 }
 966
 967 impl<'tcx> CommonLifetimes<'tcx> {
 968     fn new(interners: &CtxtInterners<'tcx>) -> CommonLifetimes<'tcx> {
 969         let mk = |r| {
 970             Region(Interned::new_unchecked(
 971                 interners.region.intern(r, |r| InternedInSet(interners.arena.alloc(r))).0,
 972             ))
 973         };
 974
 975         CommonLifetimes { re_static: mk(ty::ReStatic), re_erased: mk(ty::ReErased) }
 976     }
 977 }
 978
 979 impl<'tcx> CommonConsts<'tcx> {
 980     fn new(interners: &CtxtInterners<'tcx>, types: &CommonTypes<'tcx>) -> CommonConsts<'tcx> {
 981         let mk_const = |c| {
 982             Const(Interned::new_unchecked(
 983                 interners.const_.intern(c, |c| InternedInSet(interners.arena.alloc(c))).0,
 984             ))
 985         };
 986
 987         CommonConsts {
 988             unit: mk_const(ty::ConstS {
 989                 kind: ty::ConstKind::Value(ty::ValTree::zst()),
 990                 ty: types.unit,
 991             }),
 992         }
 993     }
 994 }
 995
 996 // This struct contains information regarding the `ReFree(FreeRegion)` corresponding to a lifetime
 997 // conflict.
 998 #[derive(Debug)]
 999 pub struct FreeRegionInfo {
1000     // `LocalDefId` corresponding to FreeRegion
1001     pub def_id: LocalDefId,
1002     // the bound region corresponding to FreeRegion
1003     pub boundregion: ty::BoundRegionKind,
1004     // checks if bound region is in Impl Item
1005     pub is_impl_item: bool,
1006 }
1007
1008 /// The central data structure of the compiler. It stores references
1009 /// to the various **arenas** and also houses the results of the
1010 /// various **compiler queries** that have been performed. See the
1011 /// [rustc dev guide] for more details.
1012 ///
1013 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/ty.html
1014 #[derive(Copy, Clone)]
1015 #[rustc_diagnostic_item = "TyCtxt"]
1016 #[rustc_pass_by_value]
1017 pub struct TyCtxt<'tcx> {
1018     gcx: &'tcx GlobalCtxt<'tcx>,
1019 }
1020
1021 impl<'tcx> Deref for TyCtxt<'tcx> {
1022     type Target = &'tcx GlobalCtxt<'tcx>;
1023     #[inline(always)]
1024     fn deref(&self) -> &Self::Target {
1025         &self.gcx
1026     }
1027 }
1028
1029 pub struct GlobalCtxt<'tcx> {
1030     pub arena: &'tcx WorkerLocal<Arena<'tcx>>,
1031     pub hir_arena: &'tcx WorkerLocal<hir::Arena<'tcx>>,
1032
1033     interners: CtxtInterners<'tcx>,
1034
1035     pub sess: &'tcx Session,
1036
1037     /// This only ever stores a `LintStore` but we don't want a dependency on that type here.
1038     ///
1039     /// FIXME(Centril): consider `dyn LintStoreMarker` once
1040     /// we can upcast to `Any` for some additional type safety.
1041     pub lint_store: Lrc<dyn Any + sync::Sync + sync::Send>,
1042
1043     pub dep_graph: DepGraph,
1044
1045     pub prof: SelfProfilerRef,
1046
1047     /// Common types, pre-interned for your convenience.
1048     pub types: CommonTypes<'tcx>,
1049
1050     /// Common lifetimes, pre-interned for your convenience.
1051     pub lifetimes: CommonLifetimes<'tcx>,
1052
1053     /// Common consts, pre-interned for your convenience.
1054     pub consts: CommonConsts<'tcx>,
1055
1056     definitions: RwLock<Definitions>,
1057
1058     /// Output of the resolver.
1059     pub(crate) untracked_resolutions: ty::ResolverGlobalCtxt,
1060     untracked_resolver_for_lowering: Steal<ty::ResolverAstLowering>,
1061     /// The entire crate as AST. This field serves as the input for the hir_crate query,
1062     /// which lowers it from AST to HIR. It must not be read or used by anything else.
1063     pub untracked_crate: Steal<Lrc<ast::Crate>>,
1064
1065     /// This provides access to the incremental compilation on-disk cache for query results.
1066     /// Do not access this directly. It is only meant to be used by
1067     /// `DepGraph::try_mark_green()` and the query infrastructure.
1068     /// This is `None` if we are not incremental compilation mode
1069     pub on_disk_cache: Option<&'tcx dyn OnDiskCache<'tcx>>,
1070
1071     pub queries: &'tcx dyn query::QueryEngine<'tcx>,
1072     pub query_caches: query::QueryCaches<'tcx>,
1073     pub(crate) query_kinds: &'tcx [DepKindStruct<'tcx>],
1074
1075     // Internal caches for metadata decoding. No need to track deps on this.
1076     pub ty_rcache: Lock<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
1077     pub pred_rcache: Lock<FxHashMap<ty::CReaderCacheKey, Predicate<'tcx>>>,
1078
1079     /// Caches the results of trait selection. This cache is used
1080     /// for things that do not have to do with the parameters in scope.
1081     pub selection_cache: traits::SelectionCache<'tcx>,
1082
1083     /// Caches the results of trait evaluation. This cache is used
1084     /// for things that do not have to do with the parameters in scope.
1085     /// Merge this with `selection_cache`?
1086     pub evaluation_cache: traits::EvaluationCache<'tcx>,
1087
1088     /// The definite name of the current crate after taking into account
1089     /// attributes, commandline parameters, etc.
1090     crate_name: Symbol,
1091
1092     /// Data layout specification for the current target.
1093     pub data_layout: TargetDataLayout,
1094
1095     /// Stores memory for globals (statics/consts).
1096     pub(crate) alloc_map: Lock<interpret::AllocMap<'tcx>>,
1097
1098     output_filenames: Arc<OutputFilenames>,
1099 }
1100
1101 impl<'tcx> TyCtxt<'tcx> {
1102     /// Expects a body and returns its codegen attributes.
1103     ///
1104     /// Unlike `codegen_fn_attrs`, this returns `CodegenFnAttrs::EMPTY` for
1105     /// constants.
1106     pub fn body_codegen_attrs(self, def_id: DefId) -> &'tcx CodegenFnAttrs {
1107         let def_kind = self.def_kind(def_id);
1108         if def_kind.has_codegen_attrs() {
1109             self.codegen_fn_attrs(def_id)
1110         } else if matches!(
1111             def_kind,
1112             DefKind::AnonConst | DefKind::AssocConst | DefKind::Const | DefKind::InlineConst
1113         ) {
1114             CodegenFnAttrs::EMPTY
1115         } else {
1116             bug!(
1117                 "body_codegen_fn_attrs called on unexpected definition: {:?} {:?}",
1118                 def_id,
1119                 def_kind
1120             )
1121         }
1122     }
1123
1124     pub fn typeck_opt_const_arg(
1125         self,
1126         def: ty::WithOptConstParam<LocalDefId>,
1127     ) -> &'tcx TypeckResults<'tcx> {
1128         if let Some(param_did) = def.const_param_did {
1129             self.typeck_const_arg((def.did, param_did))
1130         } else {
1131             self.typeck(def.did)
1132         }
1133     }
1134
1135     pub fn mir_borrowck_opt_const_arg(
1136         self,
1137         def: ty::WithOptConstParam<LocalDefId>,
1138     ) -> &'tcx BorrowCheckResult<'tcx> {
1139         if let Some(param_did) = def.const_param_did {
1140             self.mir_borrowck_const_arg((def.did, param_did))
1141         } else {
1142             self.mir_borrowck(def.did)
1143         }
1144     }
1145
1146     pub fn alloc_steal_thir(self, thir: Thir<'tcx>) -> &'tcx Steal<Thir<'tcx>> {
1147         self.arena.alloc(Steal::new(thir))
1148     }
1149
1150     pub fn alloc_steal_mir(self, mir: Body<'tcx>) -> &'tcx Steal<Body<'tcx>> {
1151         self.arena.alloc(Steal::new(mir))
1152     }
1153
1154     pub fn alloc_steal_promoted(
1155         self,
1156         promoted: IndexVec<Promoted, Body<'tcx>>,
1157     ) -> &'tcx Steal<IndexVec<Promoted, Body<'tcx>>> {
1158         self.arena.alloc(Steal::new(promoted))
1159     }
1160
1161     pub fn alloc_adt_def(
1162         self,
1163         did: DefId,
1164         kind: AdtKind,
1165         variants: IndexVec<VariantIdx, ty::VariantDef>,
1166         repr: ReprOptions,
1167     ) -> ty::AdtDef<'tcx> {
1168         self.intern_adt_def(ty::AdtDefData::new(self, did, kind, variants, repr))
1169     }
1170
1171     /// Allocates a read-only byte or string literal for `mir::interpret`.
1172     pub fn allocate_bytes(self, bytes: &[u8]) -> interpret::AllocId {
1173         // Create an allocation that just contains these bytes.
1174         let alloc = interpret::Allocation::from_bytes_byte_aligned_immutable(bytes);
1175         let alloc = self.intern_const_alloc(alloc);
1176         self.create_memory_alloc(alloc)
1177     }
1178
1179     /// Returns a range of the start/end indices specified with the
1180     /// `rustc_layout_scalar_valid_range` attribute.
1181     // FIXME(eddyb) this is an awkward spot for this method, maybe move it?
1182     pub fn layout_scalar_valid_range(self, def_id: DefId) -> (Bound<u128>, Bound<u128>) {
1183         let get = |name| {
1184             let Some(attr) = self.get_attr(def_id, name) else {
1185                 return Bound::Unbounded;
1186             };
1187             debug!("layout_scalar_valid_range: attr={:?}", attr);
1188             if let Some(
1189                 &[
1190                     ast::NestedMetaItem::Literal(ast::Lit {
1191                         kind: ast::LitKind::Int(a, _), ..
1192                     }),
1193                 ],
1194             ) = attr.meta_item_list().as_deref()
1195             {
1196                 Bound::Included(a)
1197             } else {
1198                 self.sess
1199                     .delay_span_bug(attr.span, "invalid rustc_layout_scalar_valid_range attribute");
1200                 Bound::Unbounded
1201             }
1202         };
1203         (
1204             get(sym::rustc_layout_scalar_valid_range_start),
1205             get(sym::rustc_layout_scalar_valid_range_end),
1206         )
1207     }
1208
1209     pub fn lift<T: Lift<'tcx>>(self, value: T) -> Option<T::Lifted> {
1210         value.lift_to_tcx(self)
1211     }
1212
1213     /// Creates a type context and call the closure with a `TyCtxt` reference
1214     /// to the context. The closure enforces that the type context and any interned
1215     /// value (types, substs, etc.) can only be used while `ty::tls` has a valid
1216     /// reference to the context, to allow formatting values that need it.
1217     pub fn create_global_ctxt(
1218         s: &'tcx Session,
1219         lint_store: Lrc<dyn Any + sync::Send + sync::Sync>,
1220         arena: &'tcx WorkerLocal<Arena<'tcx>>,
1221         hir_arena: &'tcx WorkerLocal<hir::Arena<'tcx>>,
1222         resolver_outputs: ResolverOutputs,
1223         krate: Lrc<ast::Crate>,
1224         dep_graph: DepGraph,
1225         on_disk_cache: Option<&'tcx dyn OnDiskCache<'tcx>>,
1226         queries: &'tcx dyn query::QueryEngine<'tcx>,
1227         query_kinds: &'tcx [DepKindStruct<'tcx>],
1228         crate_name: &str,
1229         output_filenames: OutputFilenames,
1230     ) -> GlobalCtxt<'tcx> {
1231         let ResolverOutputs {
1232             definitions,
1233             global_ctxt: untracked_resolutions,
1234             ast_lowering: untracked_resolver_for_lowering,
1235         } = resolver_outputs;
1236         let data_layout = TargetDataLayout::parse(&s.target).unwrap_or_else(|err| {
1237             s.emit_fatal(err);
1238         });
1239         let interners = CtxtInterners::new(arena);
1240         let common_types = CommonTypes::new(
1241             &interners,
1242             s,
1243             &definitions,
1244             &*untracked_resolutions.cstore,
1245             // This is only used to create a stable hashing context.
1246             &untracked_resolutions.source_span,
1247         );
1248         let common_lifetimes = CommonLifetimes::new(&interners);
1249         let common_consts = CommonConsts::new(&interners, &common_types);
1250
1251         GlobalCtxt {
1252             sess: s,
1253             lint_store,
1254             arena,
1255             hir_arena,
1256             interners,
1257             dep_graph,
1258             definitions: RwLock::new(definitions),
1259             prof: s.prof.clone(),
1260             types: common_types,
1261             lifetimes: common_lifetimes,
1262             consts: common_consts,
1263             untracked_resolutions,
1264             untracked_resolver_for_lowering: Steal::new(untracked_resolver_for_lowering),
1265             untracked_crate: Steal::new(krate),
1266             on_disk_cache,
1267             queries,
1268             query_caches: query::QueryCaches::default(),
1269             query_kinds,
1270             ty_rcache: Default::default(),
1271             pred_rcache: Default::default(),
1272             selection_cache: Default::default(),
1273             evaluation_cache: Default::default(),
1274             crate_name: Symbol::intern(crate_name),
1275             data_layout,
1276             alloc_map: Lock::new(interpret::AllocMap::new()),
1277             output_filenames: Arc::new(output_filenames),
1278         }
1279     }
1280
1281     /// Constructs a `TyKind::Error` type with current `ErrorGuaranteed`
1282     #[track_caller]
1283     pub fn ty_error_with_guaranteed(self, reported: ErrorGuaranteed) -> Ty<'tcx> {
1284         self.mk_ty(Error(reported))
1285     }
1286
1287     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used.
1288     #[track_caller]
1289     pub fn ty_error(self) -> Ty<'tcx> {
1290         self.ty_error_with_message(DUMMY_SP, "TyKind::Error constructed but no error reported")
1291     }
1292
1293     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given `msg` to
1294     /// ensure it gets used.
1295     #[track_caller]
1296     pub fn ty_error_with_message<S: Into<MultiSpan>>(self, span: S, msg: &str) -> Ty<'tcx> {
1297         let reported = self.sess.delay_span_bug(span, msg);
1298         self.mk_ty(Error(reported))
1299     }
1300
1301     /// Like [TyCtxt::ty_error] but for constants, with current `ErrorGuaranteed`
1302     #[track_caller]
1303     pub fn const_error_with_guaranteed(
1304         self,
1305         ty: Ty<'tcx>,
1306         reported: ErrorGuaranteed,
1307     ) -> Const<'tcx> {
1308         self.mk_const(ty::ConstKind::Error(reported), ty)
1309     }
1310
1311     /// Like [TyCtxt::ty_error] but for constants.
1312     #[track_caller]
1313     pub fn const_error(self, ty: Ty<'tcx>) -> Const<'tcx> {
1314         self.const_error_with_message(
1315             ty,
1316             DUMMY_SP,
1317             "ty::ConstKind::Error constructed but no error reported",
1318         )
1319     }
1320
1321     /// Like [TyCtxt::ty_error_with_message] but for constants.
1322     #[track_caller]
1323     pub fn const_error_with_message<S: Into<MultiSpan>>(
1324         self,
1325         ty: Ty<'tcx>,
1326         span: S,
1327         msg: &str,
1328     ) -> Const<'tcx> {
1329         let reported = self.sess.delay_span_bug(span, msg);
1330         self.mk_const(ty::ConstKind::Error(reported), ty)
1331     }
1332
1333     pub fn consider_optimizing<T: Fn() -> String>(self, msg: T) -> bool {
1334         let cname = self.crate_name(LOCAL_CRATE);
1335         self.sess.consider_optimizing(cname.as_str(), msg)
1336     }
1337
1338     /// Obtain all lang items of this crate and all dependencies (recursively)
1339     pub fn lang_items(self) -> &'tcx rustc_hir::lang_items::LanguageItems {
1340         self.get_lang_items(())
1341     }
1342
1343     /// Obtain the given diagnostic item's `DefId`. Use `is_diagnostic_item` if you just want to
1344     /// compare against another `DefId`, since `is_diagnostic_item` is cheaper.
1345     pub fn get_diagnostic_item(self, name: Symbol) -> Option<DefId> {
1346         self.all_diagnostic_items(()).name_to_id.get(&name).copied()
1347     }
1348
1349     /// Obtain the diagnostic item's name
1350     pub fn get_diagnostic_name(self, id: DefId) -> Option<Symbol> {
1351         self.diagnostic_items(id.krate).id_to_name.get(&id).copied()
1352     }
1353
1354     /// Check whether the diagnostic item with the given `name` has the given `DefId`.
1355     pub fn is_diagnostic_item(self, name: Symbol, did: DefId) -> bool {
1356         self.diagnostic_items(did.krate).name_to_id.get(&name) == Some(&did)
1357     }
1358
1359     pub fn stability(self) -> &'tcx stability::Index {
1360         self.stability_index(())
1361     }
1362
1363     pub fn features(self) -> &'tcx rustc_feature::Features {
1364         self.features_query(())
1365     }
1366
1367     pub fn def_key(self, id: DefId) -> rustc_hir::definitions::DefKey {
1368         // Accessing the DefKey is ok, since it is part of DefPathHash.
1369         if let Some(id) = id.as_local() {
1370             self.definitions_untracked().def_key(id)
1371         } else {
1372             self.untracked_resolutions.cstore.def_key(id)
1373         }
1374     }
1375
1376     /// Converts a `DefId` into its fully expanded `DefPath` (every
1377     /// `DefId` is really just an interned `DefPath`).
1378     ///
1379     /// Note that if `id` is not local to this crate, the result will
1380     ///  be a non-local `DefPath`.
1381     pub fn def_path(self, id: DefId) -> rustc_hir::definitions::DefPath {
1382         // Accessing the DefPath is ok, since it is part of DefPathHash.
1383         if let Some(id) = id.as_local() {
1384             self.definitions_untracked().def_path(id)
1385         } else {
1386             self.untracked_resolutions.cstore.def_path(id)
1387         }
1388     }
1389
1390     #[inline]
1391     pub fn def_path_hash(self, def_id: DefId) -> rustc_hir::definitions::DefPathHash {
1392         // Accessing the DefPathHash is ok, it is incr. comp. stable.
1393         if let Some(def_id) = def_id.as_local() {
1394             self.definitions_untracked().def_path_hash(def_id)
1395         } else {
1396             self.untracked_resolutions.cstore.def_path_hash(def_id)
1397         }
1398     }
1399
1400     #[inline]
1401     pub fn stable_crate_id(self, crate_num: CrateNum) -> StableCrateId {
1402         if crate_num == LOCAL_CRATE {
1403             self.sess.local_stable_crate_id()
1404         } else {
1405             self.untracked_resolutions.cstore.stable_crate_id(crate_num)
1406         }
1407     }
1408
1409     /// Maps a StableCrateId to the corresponding CrateNum. This method assumes
1410     /// that the crate in question has already been loaded by the CrateStore.
1411     #[inline]
1412     pub fn stable_crate_id_to_crate_num(self, stable_crate_id: StableCrateId) -> CrateNum {
1413         if stable_crate_id == self.sess.local_stable_crate_id() {
1414             LOCAL_CRATE
1415         } else {
1416             self.untracked_resolutions.cstore.stable_crate_id_to_crate_num(stable_crate_id)
1417         }
1418     }
1419
1420     /// Converts a `DefPathHash` to its corresponding `DefId` in the current compilation
1421     /// session, if it still exists. This is used during incremental compilation to
1422     /// turn a deserialized `DefPathHash` into its current `DefId`.
1423     pub fn def_path_hash_to_def_id(self, hash: DefPathHash, err: &mut dyn FnMut() -> !) -> DefId {
1424         debug!("def_path_hash_to_def_id({:?})", hash);
1425
1426         let stable_crate_id = hash.stable_crate_id();
1427
1428         // If this is a DefPathHash from the local crate, we can look up the
1429         // DefId in the tcx's `Definitions`.
1430         if stable_crate_id == self.sess.local_stable_crate_id() {
1431             self.definitions.read().local_def_path_hash_to_def_id(hash, err).to_def_id()
1432         } else {
1433             // If this is a DefPathHash from an upstream crate, let the CrateStore map
1434             // it to a DefId.
1435             let cstore = &*self.untracked_resolutions.cstore;
1436             let cnum = cstore.stable_crate_id_to_crate_num(stable_crate_id);
1437             cstore.def_path_hash_to_def_id(cnum, hash)
1438         }
1439     }
1440
1441     pub fn def_path_debug_str(self, def_id: DefId) -> String {
1442         // We are explicitly not going through queries here in order to get
1443         // crate name and stable crate id since this code is called from debug!()
1444         // statements within the query system and we'd run into endless
1445         // recursion otherwise.
1446         let (crate_name, stable_crate_id) = if def_id.is_local() {
1447             (self.crate_name, self.sess.local_stable_crate_id())
1448         } else {
1449             let cstore = &*self.untracked_resolutions.cstore;
1450             (cstore.crate_name(def_id.krate), cstore.stable_crate_id(def_id.krate))
1451         };
1452
1453         format!(
1454             "{}[{:04x}]{}",
1455             crate_name,
1456             // Don't print the whole stable crate id. That's just
1457             // annoying in debug output.
1458             stable_crate_id.to_u64() >> 8 * 6,
1459             self.def_path(def_id).to_string_no_crate_verbose()
1460         )
1461     }
1462
1463     /// Create a new definition within the incr. comp. engine.
1464     pub fn create_def(self, parent: LocalDefId, data: hir::definitions::DefPathData) -> LocalDefId {
1465         // This function modifies `self.definitions` using a side-effect.
1466         // We need to ensure that these side effects are re-run by the incr. comp. engine.
1467         // Depending on the forever-red node will tell the graph that the calling query
1468         // needs to be re-evaluated.
1469         use rustc_query_system::dep_graph::DepNodeIndex;
1470         self.dep_graph.read_index(DepNodeIndex::FOREVER_RED_NODE);
1471
1472         // The following call has the side effect of modifying the tables inside `definitions`.
1473         // These very tables are relied on by the incr. comp. engine to decode DepNodes and to
1474         // decode the on-disk cache.
1475         //
1476         // Any LocalDefId which is used within queries, either as key or result, either:
1477         // - has been created before the construction of the TyCtxt;
1478         // - has been created by this call to `create_def`.
1479         // As a consequence, this LocalDefId is always re-created before it is needed by the incr.
1480         // comp. engine itself.
1481         //
1482         // This call also writes to the value of `source_span` and `expn_that_defined` queries.
1483         // This is fine because:
1484         // - those queries are `eval_always` so we won't miss their result changing;
1485         // - this write will have happened before these queries are called.
1486         self.definitions.write().create_def(parent, data)
1487     }
1488
1489     pub fn iter_local_def_id(self) -> impl Iterator<Item = LocalDefId> + 'tcx {
1490         // Create a dependency to the crate to be sure we re-execute this when the amount of
1491         // definitions change.
1492         self.ensure().hir_crate(());
1493         // Leak a read lock once we start iterating on definitions, to prevent adding new ones
1494         // while iterating.  If some query needs to add definitions, it should be `ensure`d above.
1495         let definitions = self.definitions.leak();
1496         definitions.iter_local_def_id()
1497     }
1498
1499     pub fn def_path_table(self) -> &'tcx rustc_hir::definitions::DefPathTable {
1500         // Create a dependency to the crate to be sure we re-execute this when the amount of
1501         // definitions change.
1502         self.ensure().hir_crate(());
1503         // Leak a read lock once we start iterating on definitions, to prevent adding new ones
1504         // while iterating.  If some query needs to add definitions, it should be `ensure`d above.
1505         let definitions = self.definitions.leak();
1506         definitions.def_path_table()
1507     }
1508
1509     pub fn def_path_hash_to_def_index_map(
1510         self,
1511     ) -> &'tcx rustc_hir::def_path_hash_map::DefPathHashMap {
1512         // Create a dependency to the crate to be sure we re-execute this when the amount of
1513         // definitions change.
1514         self.ensure().hir_crate(());
1515         // Leak a read lock once we start iterating on definitions, to prevent adding new ones
1516         // while iterating.  If some query needs to add definitions, it should be `ensure`d above.
1517         let definitions = self.definitions.leak();
1518         definitions.def_path_hash_to_def_index_map()
1519     }
1520
1521     /// Note that this is *untracked* and should only be used within the query
1522     /// system if the result is otherwise tracked through queries
1523     pub fn cstore_untracked(self) -> &'tcx CrateStoreDyn {
1524         &*self.untracked_resolutions.cstore
1525     }
1526
1527     /// Note that this is *untracked* and should only be used within the query
1528     /// system if the result is otherwise tracked through queries
1529     #[inline]
1530     pub fn definitions_untracked(self) -> ReadGuard<'tcx, Definitions> {
1531         self.definitions.read()
1532     }
1533
1534     /// Note that this is *untracked* and should only be used within the query
1535     /// system if the result is otherwise tracked through queries
1536     #[inline]
1537     pub fn source_span_untracked(self, def_id: LocalDefId) -> Span {
1538         self.untracked_resolutions.source_span.get(def_id).copied().unwrap_or(DUMMY_SP)
1539     }
1540
1541     #[inline(always)]
1542     pub fn with_stable_hashing_context<R>(
1543         self,
1544         f: impl FnOnce(StableHashingContext<'_>) -> R,
1545     ) -> R {
1546         let definitions = self.definitions_untracked();
1547         let hcx = StableHashingContext::new(
1548             self.sess,
1549             &*definitions,
1550             &*self.untracked_resolutions.cstore,
1551             &self.untracked_resolutions.source_span,
1552         );
1553         f(hcx)
1554     }
1555
1556     pub fn serialize_query_result_cache(self, encoder: FileEncoder) -> FileEncodeResult {
1557         self.on_disk_cache.as_ref().map_or(Ok(0), |c| c.serialize(self, encoder))
1558     }
1559
1560     /// If `true`, we should use lazy normalization for constants, otherwise
1561     /// we still evaluate them eagerly.
1562     #[inline]
1563     pub fn lazy_normalization(self) -> bool {
1564         let features = self.features();
1565         // Note: We only use lazy normalization for generic const expressions.
1566         features.generic_const_exprs
1567     }
1568
1569     #[inline]
1570     pub fn local_crate_exports_generics(self) -> bool {
1571         debug_assert!(self.sess.opts.share_generics());
1572
1573         self.sess.crate_types().iter().any(|crate_type| {
1574             match crate_type {
1575                 CrateType::Executable
1576                 | CrateType::Staticlib
1577                 | CrateType::ProcMacro
1578                 | CrateType::Cdylib => false,
1579
1580                 // FIXME rust-lang/rust#64319, rust-lang/rust#64872:
1581                 // We want to block export of generics from dylibs,
1582                 // but we must fix rust-lang/rust#65890 before we can
1583                 // do that robustly.
1584                 CrateType::Dylib => true,
1585
1586                 CrateType::Rlib => true,
1587             }
1588         })
1589     }
1590
1591     /// Returns the `DefId` and the `BoundRegionKind` corresponding to the given region.
1592     pub fn is_suitable_region(self, region: Region<'tcx>) -> Option<FreeRegionInfo> {
1593         let (suitable_region_binding_scope, bound_region) = match *region {
1594             ty::ReFree(ref free_region) => {
1595                 (free_region.scope.expect_local(), free_region.bound_region)
1596             }
1597             ty::ReEarlyBound(ref ebr) => (
1598                 self.local_parent(ebr.def_id.expect_local()),
1599                 ty::BoundRegionKind::BrNamed(ebr.def_id, ebr.name),
1600             ),
1601             _ => return None, // not a free region
1602         };
1603
1604         let is_impl_item = match self.hir().find_by_def_id(suitable_region_binding_scope) {
1605             Some(Node::Item(..) | Node::TraitItem(..)) => false,
1606             Some(Node::ImplItem(..)) => {
1607                 self.is_bound_region_in_impl_item(suitable_region_binding_scope)
1608             }
1609             _ => return None,
1610         };
1611
1612         Some(FreeRegionInfo {
1613             def_id: suitable_region_binding_scope,
1614             boundregion: bound_region,
1615             is_impl_item,
1616         })
1617     }
1618
1619     /// Given a `DefId` for an `fn`, return all the `dyn` and `impl` traits in its return type.
1620     pub fn return_type_impl_or_dyn_traits(
1621         self,
1622         scope_def_id: LocalDefId,
1623     ) -> Vec<&'tcx hir::Ty<'tcx>> {
1624         let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id);
1625         let Some(hir::FnDecl { output: hir::FnRetTy::Return(hir_output), .. }) = self.hir().fn_decl_by_hir_id(hir_id) else {
1626             return vec![];
1627         };
1628
1629         let mut v = TraitObjectVisitor(vec![], self.hir());
1630         v.visit_ty(hir_output);
1631         v.0
1632     }
1633
1634     pub fn return_type_impl_trait(self, scope_def_id: LocalDefId) -> Option<(Ty<'tcx>, Span)> {
1635         // `type_of()` will fail on these (#55796, #86483), so only allow `fn`s or closures.
1636         match self.hir().get_by_def_id(scope_def_id) {
1637             Node::Item(&hir::Item { kind: ItemKind::Fn(..), .. }) => {}
1638             Node::TraitItem(&hir::TraitItem { kind: TraitItemKind::Fn(..), .. }) => {}
1639             Node::ImplItem(&hir::ImplItem { kind: ImplItemKind::Fn(..), .. }) => {}
1640             Node::Expr(&hir::Expr { kind: ExprKind::Closure { .. }, .. }) => {}
1641             _ => return None,
1642         }
1643
1644         let ret_ty = self.type_of(scope_def_id);
1645         match ret_ty.kind() {
1646             ty::FnDef(_, _) => {
1647                 let sig = ret_ty.fn_sig(self);
1648                 let output = self.erase_late_bound_regions(sig.output());
1649                 if output.is_impl_trait() {
1650                     let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id);
1651                     let fn_decl = self.hir().fn_decl_by_hir_id(hir_id).unwrap();
1652                     Some((output, fn_decl.output.span()))
1653                 } else {
1654                     None
1655                 }
1656             }
1657             _ => None,
1658         }
1659     }
1660
1661     // Checks if the bound region is in Impl Item.
1662     pub fn is_bound_region_in_impl_item(self, suitable_region_binding_scope: LocalDefId) -> bool {
1663         let container_id = self.parent(suitable_region_binding_scope.to_def_id());
1664         if self.impl_trait_ref(container_id).is_some() {
1665             // For now, we do not try to target impls of traits. This is
1666             // because this message is going to suggest that the user
1667             // change the fn signature, but they may not be free to do so,
1668             // since the signature must match the trait.
1669             //
1670             // FIXME(#42706) -- in some cases, we could do better here.
1671             return true;
1672         }
1673         false
1674     }
1675
1676     /// Determines whether identifiers in the assembly have strict naming rules.
1677     /// Currently, only NVPTX* targets need it.
1678     pub fn has_strict_asm_symbol_naming(self) -> bool {
1679         self.sess.target.arch.contains("nvptx")
1680     }
1681
1682     /// Returns `&'static core::panic::Location<'static>`.
1683     pub fn caller_location_ty(self) -> Ty<'tcx> {
1684         self.mk_imm_ref(
1685             self.lifetimes.re_static,
1686             self.bound_type_of(self.require_lang_item(LangItem::PanicLocation, None))
1687                 .subst(self, self.mk_substs([self.lifetimes.re_static.into()].iter())),
1688         )
1689     }
1690
1691     /// Returns a displayable description and article for the given `def_id` (e.g. `("a", "struct")`).
1692     pub fn article_and_description(self, def_id: DefId) -> (&'static str, &'static str) {
1693         match self.def_kind(def_id) {
1694             DefKind::Generator => match self.generator_kind(def_id).unwrap() {
1695                 rustc_hir::GeneratorKind::Async(..) => ("an", "async closure"),
1696                 rustc_hir::GeneratorKind::Gen => ("a", "generator"),
1697             },
1698             def_kind => (def_kind.article(), def_kind.descr(def_id)),
1699         }
1700     }
1701
1702     pub fn type_length_limit(self) -> Limit {
1703         self.limits(()).type_length_limit
1704     }
1705
1706     pub fn recursion_limit(self) -> Limit {
1707         self.limits(()).recursion_limit
1708     }
1709
1710     pub fn move_size_limit(self) -> Limit {
1711         self.limits(()).move_size_limit
1712     }
1713
1714     pub fn const_eval_limit(self) -> Limit {
1715         self.limits(()).const_eval_limit
1716     }
1717
1718     pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
1719         iter::once(LOCAL_CRATE)
1720             .chain(self.crates(()).iter().copied())
1721             .flat_map(move |cnum| self.traits_in_crate(cnum).iter().copied())
1722     }
1723
1724     #[inline]
1725     pub fn local_visibility(self, def_id: LocalDefId) -> Visibility {
1726         self.visibility(def_id).expect_local()
1727     }
1728 }
1729
1730 /// A trait implemented for all `X<'a>` types that can be safely and
1731 /// efficiently converted to `X<'tcx>` as long as they are part of the
1732 /// provided `TyCtxt<'tcx>`.
1733 /// This can be done, for example, for `Ty<'tcx>` or `SubstsRef<'tcx>`
1734 /// by looking them up in their respective interners.
1735 ///
1736 /// However, this is still not the best implementation as it does
1737 /// need to compare the components, even for interned values.
1738 /// It would be more efficient if `TypedArena` provided a way to
1739 /// determine whether the address is in the allocated range.
1740 ///
1741 /// `None` is returned if the value or one of the components is not part
1742 /// of the provided context.
1743 /// For `Ty`, `None` can be returned if either the type interner doesn't
1744 /// contain the `TyKind` key or if the address of the interned
1745 /// pointer differs. The latter case is possible if a primitive type,
1746 /// e.g., `()` or `u8`, was interned in a different context.
1747 pub trait Lift<'tcx>: fmt::Debug {
1748     type Lifted: fmt::Debug + 'tcx;
1749     fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>;
1750 }
1751
1752 macro_rules! nop_lift {
1753     ($set:ident; $ty:ty => $lifted:ty) => {
1754         impl<'a, 'tcx> Lift<'tcx> for $ty {
1755             type Lifted = $lifted;
1756             fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1757                 if tcx.interners.$set.contains_pointer_to(&InternedInSet(&*self.0.0)) {
1758                     // SAFETY: `self` is interned and therefore valid
1759                     // for the entire lifetime of the `TyCtxt`.
1760                     Some(unsafe { mem::transmute(self) })
1761                 } else {
1762                     None
1763                 }
1764             }
1765         }
1766     };
1767 }
1768
1769 // Can't use the macros as we have reuse the `substs` here.
1770 //
1771 // See `intern_type_list` for more info.
1772 impl<'a, 'tcx> Lift<'tcx> for &'a List<Ty<'a>> {
1773     type Lifted = &'tcx List<Ty<'tcx>>;
1774     fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1775         if self.is_empty() {
1776             return Some(List::empty());
1777         }
1778         if tcx.interners.substs.contains_pointer_to(&InternedInSet(self.as_substs())) {
1779             // SAFETY: `self` is interned and therefore valid
1780             // for the entire lifetime of the `TyCtxt`.
1781             Some(unsafe { mem::transmute::<&'a List<Ty<'a>>, &'tcx List<Ty<'tcx>>>(self) })
1782         } else {
1783             None
1784         }
1785     }
1786 }
1787
1788 macro_rules! nop_list_lift {
1789     ($set:ident; $ty:ty => $lifted:ty) => {
1790         impl<'a, 'tcx> Lift<'tcx> for &'a List<$ty> {
1791             type Lifted = &'tcx List<$lifted>;
1792             fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1793                 if self.is_empty() {
1794                     return Some(List::empty());
1795                 }
1796                 if tcx.interners.$set.contains_pointer_to(&InternedInSet(self)) {
1797                     Some(unsafe { mem::transmute(self) })
1798                 } else {
1799                     None
1800                 }
1801             }
1802         }
1803     };
1804 }
1805
1806 nop_lift! {type_; Ty<'a> => Ty<'tcx>}
1807 nop_lift! {region; Region<'a> => Region<'tcx>}
1808 nop_lift! {const_; Const<'a> => Const<'tcx>}
1809 nop_lift! {const_allocation; ConstAllocation<'a> => ConstAllocation<'tcx>}
1810 nop_lift! {predicate; Predicate<'a> => Predicate<'tcx>}
1811
1812 nop_list_lift! {poly_existential_predicates; PolyExistentialPredicate<'a> => PolyExistentialPredicate<'tcx>}
1813 nop_list_lift! {predicates; Predicate<'a> => Predicate<'tcx>}
1814 nop_list_lift! {canonical_var_infos; CanonicalVarInfo<'a> => CanonicalVarInfo<'tcx>}
1815 nop_list_lift! {projs; ProjectionKind => ProjectionKind}
1816 nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariableKind}
1817
1818 // This is the impl for `&'a InternalSubsts<'a>`.
1819 nop_list_lift! {substs; GenericArg<'a> => GenericArg<'tcx>}
1820
1821 CloneLiftImpls! { for<'tcx> {
1822     Constness, traits::WellFormedLoc, ImplPolarity, crate::mir::ReturnConstraint,
1823 } }
1824
1825 pub mod tls {
1826     use super::{ptr_eq, GlobalCtxt, TyCtxt};
1827
1828     use crate::dep_graph::TaskDepsRef;
1829     use crate::ty::query;
1830     use rustc_data_structures::sync::{self, Lock};
1831     use rustc_errors::Diagnostic;
1832     use std::mem;
1833     use thin_vec::ThinVec;
1834
1835     #[cfg(not(parallel_compiler))]
1836     use std::cell::Cell;
1837
1838     #[cfg(parallel_compiler)]
1839     use rustc_rayon_core as rayon_core;
1840
1841     /// This is the implicit state of rustc. It contains the current
1842     /// `TyCtxt` and query. It is updated when creating a local interner or
1843     /// executing a new query. Whenever there's a `TyCtxt` value available
1844     /// you should also have access to an `ImplicitCtxt` through the functions
1845     /// in this module.
1846     #[derive(Clone)]
1847     pub struct ImplicitCtxt<'a, 'tcx> {
1848         /// The current `TyCtxt`.
1849         pub tcx: TyCtxt<'tcx>,
1850
1851         /// The current query job, if any. This is updated by `JobOwner::start` in
1852         /// `ty::query::plumbing` when executing a query.
1853         pub query: Option<query::QueryJobId>,
1854
1855         /// Where to store diagnostics for the current query job, if any.
1856         /// This is updated by `JobOwner::start` in `ty::query::plumbing` when executing a query.
1857         pub diagnostics: Option<&'a Lock<ThinVec<Diagnostic>>>,
1858
1859         /// Used to prevent queries from calling too deeply.
1860         pub query_depth: usize,
1861
1862         /// The current dep graph task. This is used to add dependencies to queries
1863         /// when executing them.
1864         pub task_deps: TaskDepsRef<'a>,
1865     }
1866
1867     impl<'a, 'tcx> ImplicitCtxt<'a, 'tcx> {
1868         pub fn new(gcx: &'tcx GlobalCtxt<'tcx>) -> Self {
1869             let tcx = TyCtxt { gcx };
1870             ImplicitCtxt {
1871                 tcx,
1872                 query: None,
1873                 diagnostics: None,
1874                 query_depth: 0,
1875                 task_deps: TaskDepsRef::Ignore,
1876             }
1877         }
1878     }
1879
1880     /// Sets Rayon's thread-local variable, which is preserved for Rayon jobs
1881     /// to `value` during the call to `f`. It is restored to its previous value after.
1882     /// This is used to set the pointer to the new `ImplicitCtxt`.
1883     #[cfg(parallel_compiler)]
1884     #[inline]
1885     fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
1886         rayon_core::tlv::with(value, f)
1887     }
1888
1889     /// Gets Rayon's thread-local variable, which is preserved for Rayon jobs.
1890     /// This is used to get the pointer to the current `ImplicitCtxt`.
1891     #[cfg(parallel_compiler)]
1892     #[inline]
1893     pub fn get_tlv() -> usize {
1894         rayon_core::tlv::get()
1895     }
1896
1897     #[cfg(not(parallel_compiler))]
1898     thread_local! {
1899         /// A thread local variable that stores a pointer to the current `ImplicitCtxt`.
1900         static TLV: Cell<usize> = const { Cell::new(0) };
1901     }
1902
1903     /// Sets TLV to `value` during the call to `f`.
1904     /// It is restored to its previous value after.
1905     /// This is used to set the pointer to the new `ImplicitCtxt`.
1906     #[cfg(not(parallel_compiler))]
1907     #[inline]
1908     fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
1909         let old = get_tlv();
1910         let _reset = rustc_data_structures::OnDrop(move || TLV.with(|tlv| tlv.set(old)));
1911         TLV.with(|tlv| tlv.set(value));
1912         f()
1913     }
1914
1915     /// Gets the pointer to the current `ImplicitCtxt`.
1916     #[cfg(not(parallel_compiler))]
1917     #[inline]
1918     fn get_tlv() -> usize {
1919         TLV.with(|tlv| tlv.get())
1920     }
1921
1922     /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`.
1923     #[inline]
1924     pub fn enter_context<'a, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'tcx>, f: F) -> R
1925     where
1926         F: FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
1927     {
1928         set_tlv(context as *const _ as usize, || f(&context))
1929     }
1930
1931     /// Allows access to the current `ImplicitCtxt` in a closure if one is available.
1932     #[inline]
1933     pub fn with_context_opt<F, R>(f: F) -> R
1934     where
1935         F: for<'a, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'tcx>>) -> R,
1936     {
1937         let context = get_tlv();
1938         if context == 0 {
1939             f(None)
1940         } else {
1941             // We could get an `ImplicitCtxt` pointer from another thread.
1942             // Ensure that `ImplicitCtxt` is `Sync`.
1943             sync::assert_sync::<ImplicitCtxt<'_, '_>>();
1944
1945             unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) }
1946         }
1947     }
1948
1949     /// Allows access to the current `ImplicitCtxt`.
1950     /// Panics if there is no `ImplicitCtxt` available.
1951     #[inline]
1952     pub fn with_context<F, R>(f: F) -> R
1953     where
1954         F: for<'a, 'tcx> FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
1955     {
1956         with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
1957     }
1958
1959     /// Allows access to the current `ImplicitCtxt` whose tcx field is the same as the tcx argument
1960     /// passed in. This means the closure is given an `ImplicitCtxt` with the same `'tcx` lifetime
1961     /// as the `TyCtxt` passed in.
1962     /// This will panic if you pass it a `TyCtxt` which is different from the current
1963     /// `ImplicitCtxt`'s `tcx` field.
1964     #[inline]
1965     pub fn with_related_context<'tcx, F, R>(tcx: TyCtxt<'tcx>, f: F) -> R
1966     where
1967         F: FnOnce(&ImplicitCtxt<'_, 'tcx>) -> R,
1968     {
1969         with_context(|context| unsafe {
1970             assert!(ptr_eq(context.tcx.gcx, tcx.gcx));
1971             let context: &ImplicitCtxt<'_, '_> = mem::transmute(context);
1972             f(context)
1973         })
1974     }
1975
1976     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
1977     /// Panics if there is no `ImplicitCtxt` available.
1978     #[inline]
1979     pub fn with<F, R>(f: F) -> R
1980     where
1981         F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
1982     {
1983         with_context(|context| f(context.tcx))
1984     }
1985
1986     /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
1987     /// The closure is passed None if there is no `ImplicitCtxt` available.
1988     #[inline]
1989     pub fn with_opt<F, R>(f: F) -> R
1990     where
1991         F: for<'tcx> FnOnce(Option<TyCtxt<'tcx>>) -> R,
1992     {
1993         with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
1994     }
1995 }
1996
1997 macro_rules! sty_debug_print {
1998     ($fmt: expr, $ctxt: expr, $($variant: ident),*) => {{
1999         // Curious inner module to allow variant names to be used as
2000         // variable names.
2001         #[allow(non_snake_case)]
2002         mod inner {
2003             use crate::ty::{self, TyCtxt};
2004             use crate::ty::context::InternedInSet;
2005
2006             #[derive(Copy, Clone)]
2007             struct DebugStat {
2008                 total: usize,
2009                 lt_infer: usize,
2010                 ty_infer: usize,
2011                 ct_infer: usize,
2012                 all_infer: usize,
2013             }
2014
2015             pub fn go(fmt: &mut std::fmt::Formatter<'_>, tcx: TyCtxt<'_>) -> std::fmt::Result {
2016                 let mut total = DebugStat {
2017                     total: 0,
2018                     lt_infer: 0,
2019                     ty_infer: 0,
2020                     ct_infer: 0,
2021                     all_infer: 0,
2022                 };
2023                 $(let mut $variant = total;)*
2024
2025                 let shards = tcx.interners.type_.lock_shards();
2026                 let types = shards.iter().flat_map(|shard| shard.keys());
2027                 for &InternedInSet(t) in types {
2028                     let variant = match t.kind {
2029                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
2030                             ty::Float(..) | ty::Str | ty::Never => continue,
2031                         ty::Error(_) => /* unimportant */ continue,
2032                         $(ty::$variant(..) => &mut $variant,)*
2033                     };
2034                     let lt = t.flags.intersects(ty::TypeFlags::HAS_RE_INFER);
2035                     let ty = t.flags.intersects(ty::TypeFlags::HAS_TY_INFER);
2036                     let ct = t.flags.intersects(ty::TypeFlags::HAS_CT_INFER);
2037
2038                     variant.total += 1;
2039                     total.total += 1;
2040                     if lt { total.lt_infer += 1; variant.lt_infer += 1 }
2041                     if ty { total.ty_infer += 1; variant.ty_infer += 1 }
2042                     if ct { total.ct_infer += 1; variant.ct_infer += 1 }
2043                     if lt && ty && ct { total.all_infer += 1; variant.all_infer += 1 }
2044                 }
2045                 writeln!(fmt, "Ty interner             total           ty lt ct all")?;
2046                 $(writeln!(fmt, "    {:18}: {uses:6} {usespc:4.1}%, \
2047                             {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
2048                     stringify!($variant),
2049                     uses = $variant.total,
2050                     usespc = $variant.total as f64 * 100.0 / total.total as f64,
2051                     ty = $variant.ty_infer as f64 * 100.0  / total.total as f64,
2052                     lt = $variant.lt_infer as f64 * 100.0  / total.total as f64,
2053                     ct = $variant.ct_infer as f64 * 100.0  / total.total as f64,
2054                     all = $variant.all_infer as f64 * 100.0  / total.total as f64)?;
2055                 )*
2056                 writeln!(fmt, "                  total {uses:6}        \
2057                           {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
2058                     uses = total.total,
2059                     ty = total.ty_infer as f64 * 100.0  / total.total as f64,
2060                     lt = total.lt_infer as f64 * 100.0  / total.total as f64,
2061                     ct = total.ct_infer as f64 * 100.0  / total.total as f64,
2062                     all = total.all_infer as f64 * 100.0  / total.total as f64)
2063             }
2064         }
2065
2066         inner::go($fmt, $ctxt)
2067     }}
2068 }
2069
2070 impl<'tcx> TyCtxt<'tcx> {
2071     pub fn debug_stats(self) -> impl std::fmt::Debug + 'tcx {
2072         struct DebugStats<'tcx>(TyCtxt<'tcx>);
2073
2074         impl<'tcx> std::fmt::Debug for DebugStats<'tcx> {
2075             fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2076                 sty_debug_print!(
2077                     fmt,
2078                     self.0,
2079                     Adt,
2080                     Array,
2081                     Slice,
2082                     RawPtr,
2083                     Ref,
2084                     FnDef,
2085                     FnPtr,
2086                     Placeholder,
2087                     Generator,
2088                     GeneratorWitness,
2089                     Dynamic,
2090                     Closure,
2091                     Tuple,
2092                     Bound,
2093                     Param,
2094                     Infer,
2095                     Projection,
2096                     Opaque,
2097                     Foreign
2098                 )?;
2099
2100                 writeln!(fmt, "InternalSubsts interner: #{}", self.0.interners.substs.len())?;
2101                 writeln!(fmt, "Region interner: #{}", self.0.interners.region.len())?;
2102                 writeln!(
2103                     fmt,
2104                     "Const Allocation interner: #{}",
2105                     self.0.interners.const_allocation.len()
2106                 )?;
2107                 writeln!(fmt, "Layout interner: #{}", self.0.interners.layout.len())?;
2108
2109                 Ok(())
2110             }
2111         }
2112
2113         DebugStats(self)
2114     }
2115 }
2116
2117 // This type holds a `T` in the interner. The `T` is stored in the arena and
2118 // this type just holds a pointer to it, but it still effectively owns it. It
2119 // impls `Borrow` so that it can be looked up using the original
2120 // (non-arena-memory-owning) types.
2121 struct InternedInSet<'tcx, T: ?Sized>(&'tcx T);
2122
2123 impl<'tcx, T: 'tcx + ?Sized> Clone for InternedInSet<'tcx, T> {
2124     fn clone(&self) -> Self {
2125         InternedInSet(self.0)
2126     }
2127 }
2128
2129 impl<'tcx, T: 'tcx + ?Sized> Copy for InternedInSet<'tcx, T> {}
2130
2131 impl<'tcx, T: 'tcx + ?Sized> IntoPointer for InternedInSet<'tcx, T> {
2132     fn into_pointer(&self) -> *const () {
2133         self.0 as *const _ as *const ()
2134     }
2135 }
2136
2137 #[allow(rustc::usage_of_ty_tykind)]
2138 impl<'tcx> Borrow<TyKind<'tcx>> for InternedInSet<'tcx, WithStableHash<TyS<'tcx>>> {
2139     fn borrow<'a>(&'a self) -> &'a TyKind<'tcx> {
2140         &self.0.kind
2141     }
2142 }
2143
2144 impl<'tcx> PartialEq for InternedInSet<'tcx, WithStableHash<TyS<'tcx>>> {
2145     fn eq(&self, other: &InternedInSet<'tcx, WithStableHash<TyS<'tcx>>>) -> bool {
2146         // The `Borrow` trait requires that `x.borrow() == y.borrow()` equals
2147         // `x == y`.
2148         self.0.kind == other.0.kind
2149     }
2150 }
2151
2152 impl<'tcx> Eq for InternedInSet<'tcx, WithStableHash<TyS<'tcx>>> {}
2153
2154 impl<'tcx> Hash for InternedInSet<'tcx, WithStableHash<TyS<'tcx>>> {
2155     fn hash<H: Hasher>(&self, s: &mut H) {
2156         // The `Borrow` trait requires that `x.borrow().hash(s) == x.hash(s)`.
2157         self.0.kind.hash(s)
2158     }
2159 }
2160
2161 impl<'tcx> Borrow<Binder<'tcx, PredicateKind<'tcx>>> for InternedInSet<'tcx, PredicateS<'tcx>> {
2162     fn borrow<'a>(&'a self) -> &'a Binder<'tcx, PredicateKind<'tcx>> {
2163         &self.0.kind
2164     }
2165 }
2166
2167 impl<'tcx> PartialEq for InternedInSet<'tcx, PredicateS<'tcx>> {
2168     fn eq(&self, other: &InternedInSet<'tcx, PredicateS<'tcx>>) -> bool {
2169         // The `Borrow` trait requires that `x.borrow() == y.borrow()` equals
2170         // `x == y`.
2171         self.0.kind == other.0.kind
2172     }
2173 }
2174
2175 impl<'tcx> Eq for InternedInSet<'tcx, PredicateS<'tcx>> {}
2176
2177 impl<'tcx> Hash for InternedInSet<'tcx, PredicateS<'tcx>> {
2178     fn hash<H: Hasher>(&self, s: &mut H) {
2179         // The `Borrow` trait requires that `x.borrow().hash(s) == x.hash(s)`.
2180         self.0.kind.hash(s)
2181     }
2182 }
2183
2184 impl<'tcx, T> Borrow<[T]> for InternedInSet<'tcx, List<T>> {
2185     fn borrow<'a>(&'a self) -> &'a [T] {
2186         &self.0[..]
2187     }
2188 }
2189
2190 impl<'tcx, T: PartialEq> PartialEq for InternedInSet<'tcx, List<T>> {
2191     fn eq(&self, other: &InternedInSet<'tcx, List<T>>) -> bool {
2192         // The `Borrow` trait requires that `x.borrow() == y.borrow()` equals
2193         // `x == y`.
2194         self.0[..] == other.0[..]
2195     }
2196 }
2197
2198 impl<'tcx, T: Eq> Eq for InternedInSet<'tcx, List<T>> {}
2199
2200 impl<'tcx, T: Hash> Hash for InternedInSet<'tcx, List<T>> {
2201     fn hash<H: Hasher>(&self, s: &mut H) {
2202         // The `Borrow` trait requires that `x.borrow().hash(s) == x.hash(s)`.
2203         self.0[..].hash(s)
2204     }
2205 }
2206
2207 macro_rules! direct_interners {
2208     ($($name:ident: $method:ident($ty:ty): $ret_ctor:ident -> $ret_ty:ty,)+) => {
2209         $(impl<'tcx> Borrow<$ty> for InternedInSet<'tcx, $ty> {
2210             fn borrow<'a>(&'a self) -> &'a $ty {
2211                 &self.0
2212             }
2213         }
2214
2215         impl<'tcx> PartialEq for InternedInSet<'tcx, $ty> {
2216             fn eq(&self, other: &Self) -> bool {
2217                 // The `Borrow` trait requires that `x.borrow() == y.borrow()`
2218                 // equals `x == y`.
2219                 self.0 == other.0
2220             }
2221         }
2222
2223         impl<'tcx> Eq for InternedInSet<'tcx, $ty> {}
2224
2225         impl<'tcx> Hash for InternedInSet<'tcx, $ty> {
2226             fn hash<H: Hasher>(&self, s: &mut H) {
2227                 // The `Borrow` trait requires that `x.borrow().hash(s) ==
2228                 // x.hash(s)`.
2229                 self.0.hash(s)
2230             }
2231         }
2232
2233         impl<'tcx> TyCtxt<'tcx> {
2234             pub fn $method(self, v: $ty) -> $ret_ty {
2235                 $ret_ctor(Interned::new_unchecked(self.interners.$name.intern(v, |v| {
2236                     InternedInSet(self.interners.arena.alloc(v))
2237                 }).0))
2238             }
2239         })+
2240     }
2241 }
2242
2243 direct_interners! {
2244     region: mk_region(RegionKind<'tcx>): Region -> Region<'tcx>,
2245     const_: mk_const_internal(ConstS<'tcx>): Const -> Const<'tcx>,
2246     const_allocation: intern_const_alloc(Allocation): ConstAllocation -> ConstAllocation<'tcx>,
2247     layout: intern_layout(LayoutS<'tcx>): Layout -> Layout<'tcx>,
2248     adt_def: intern_adt_def(AdtDefData): AdtDef -> AdtDef<'tcx>,
2249 }
2250
2251 macro_rules! slice_interners {
2252     ($($field:ident: $method:ident($ty:ty)),+ $(,)?) => (
2253         impl<'tcx> TyCtxt<'tcx> {
2254             $(pub fn $method(self, v: &[$ty]) -> &'tcx List<$ty> {
2255                 self.interners.$field.intern_ref(v, || {
2256                     InternedInSet(List::from_arena(&*self.arena, v))
2257                 }).0
2258             })+
2259         }
2260     );
2261 }
2262
2263 slice_interners!(
2264     substs: _intern_substs(GenericArg<'tcx>),
2265     canonical_var_infos: _intern_canonical_var_infos(CanonicalVarInfo<'tcx>),
2266     poly_existential_predicates:
2267         _intern_poly_existential_predicates(PolyExistentialPredicate<'tcx>),
2268     predicates: _intern_predicates(Predicate<'tcx>),
2269     projs: _intern_projs(ProjectionKind),
2270     place_elems: _intern_place_elems(PlaceElem<'tcx>),
2271     bound_variable_kinds: _intern_bound_variable_kinds(ty::BoundVariableKind),
2272 );
2273
2274 impl<'tcx> TyCtxt<'tcx> {
2275     /// Given a `fn` type, returns an equivalent `unsafe fn` type;
2276     /// that is, a `fn` type that is equivalent in every way for being
2277     /// unsafe.
2278     pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
2279         assert_eq!(sig.unsafety(), hir::Unsafety::Normal);
2280         self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Unsafe, ..sig }))
2281     }
2282
2283     /// Given the def_id of a Trait `trait_def_id` and the name of an associated item `assoc_name`
2284     /// returns true if the `trait_def_id` defines an associated item of name `assoc_name`.
2285     pub fn trait_may_define_assoc_type(self, trait_def_id: DefId, assoc_name: Ident) -> bool {
2286         self.super_traits_of(trait_def_id).any(|trait_did| {
2287             self.associated_items(trait_did)
2288                 .find_by_name_and_kind(self, assoc_name, ty::AssocKind::Type, trait_did)
2289                 .is_some()
2290         })
2291     }
2292
2293     /// Given a `ty`, return whether it's an `impl Future<...>`.
2294     pub fn ty_is_opaque_future(self, ty: Ty<'_>) -> bool {
2295         let ty::Opaque(def_id, _) = ty.kind() else { return false };
2296         let future_trait = self.require_lang_item(LangItem::Future, None);
2297
2298         self.explicit_item_bounds(def_id).iter().any(|(predicate, _)| {
2299             let ty::PredicateKind::Trait(trait_predicate) = predicate.kind().skip_binder() else {
2300                 return false;
2301             };
2302             trait_predicate.trait_ref.def_id == future_trait
2303                 && trait_predicate.polarity == ImplPolarity::Positive
2304         })
2305     }
2306
2307     /// Computes the def-ids of the transitive supertraits of `trait_def_id`. This (intentionally)
2308     /// does not compute the full elaborated super-predicates but just the set of def-ids. It is used
2309     /// to identify which traits may define a given associated type to help avoid cycle errors.
2310     /// Returns a `DefId` iterator.
2311     fn super_traits_of(self, trait_def_id: DefId) -> impl Iterator<Item = DefId> + 'tcx {
2312         let mut set = FxHashSet::default();
2313         let mut stack = vec![trait_def_id];
2314
2315         set.insert(trait_def_id);
2316
2317         iter::from_fn(move || -> Option<DefId> {
2318             let trait_did = stack.pop()?;
2319             let generic_predicates = self.super_predicates_of(trait_did);
2320
2321             for (predicate, _) in generic_predicates.predicates {
2322                 if let ty::PredicateKind::Trait(data) = predicate.kind().skip_binder() {
2323                     if set.insert(data.def_id()) {
2324                         stack.push(data.def_id());
2325                     }
2326                 }
2327             }
2328
2329             Some(trait_did)
2330         })
2331     }
2332
2333     /// Given a closure signature, returns an equivalent fn signature. Detuples
2334     /// and so forth -- so e.g., if we have a sig with `Fn<(u32, i32)>` then
2335     /// you would get a `fn(u32, i32)`.
2336     /// `unsafety` determines the unsafety of the fn signature. If you pass
2337     /// `hir::Unsafety::Unsafe` in the previous example, then you would get
2338     /// an `unsafe fn (u32, i32)`.
2339     /// It cannot convert a closure that requires unsafe.
2340     pub fn signature_unclosure(
2341         self,
2342         sig: PolyFnSig<'tcx>,
2343         unsafety: hir::Unsafety,
2344     ) -> PolyFnSig<'tcx> {
2345         sig.map_bound(|s| {
2346             let params_iter = match s.inputs()[0].kind() {
2347                 ty::Tuple(params) => params.into_iter(),
2348                 _ => bug!(),
2349             };
2350             self.mk_fn_sig(params_iter, s.output(), s.c_variadic, unsafety, abi::Abi::Rust)
2351         })
2352     }
2353
2354     /// Same a `self.mk_region(kind)`, but avoids accessing the interners if
2355     /// `*r == kind`.
2356     #[inline]
2357     pub fn reuse_or_mk_region(self, r: Region<'tcx>, kind: RegionKind<'tcx>) -> Region<'tcx> {
2358         if *r == kind { r } else { self.mk_region(kind) }
2359     }
2360
2361     #[allow(rustc::usage_of_ty_tykind)]
2362     #[inline]
2363     pub fn mk_ty(self, st: TyKind<'tcx>) -> Ty<'tcx> {
2364         self.interners.intern_ty(
2365             st,
2366             self.sess,
2367             &self.definitions.read(),
2368             &*self.untracked_resolutions.cstore,
2369             // This is only used to create a stable hashing context.
2370             &self.untracked_resolutions.source_span,
2371         )
2372     }
2373
2374     #[inline]
2375     pub fn mk_predicate(self, binder: Binder<'tcx, PredicateKind<'tcx>>) -> Predicate<'tcx> {
2376         self.interners.intern_predicate(binder)
2377     }
2378
2379     #[inline]
2380     pub fn reuse_or_mk_predicate(
2381         self,
2382         pred: Predicate<'tcx>,
2383         binder: Binder<'tcx, PredicateKind<'tcx>>,
2384     ) -> Predicate<'tcx> {
2385         if pred.kind() != binder { self.mk_predicate(binder) } else { pred }
2386     }
2387
2388     pub fn mk_mach_int(self, tm: IntTy) -> Ty<'tcx> {
2389         match tm {
2390             IntTy::Isize => self.types.isize,
2391             IntTy::I8 => self.types.i8,
2392             IntTy::I16 => self.types.i16,
2393             IntTy::I32 => self.types.i32,
2394             IntTy::I64 => self.types.i64,
2395             IntTy::I128 => self.types.i128,
2396         }
2397     }
2398
2399     pub fn mk_mach_uint(self, tm: UintTy) -> Ty<'tcx> {
2400         match tm {
2401             UintTy::Usize => self.types.usize,
2402             UintTy::U8 => self.types.u8,
2403             UintTy::U16 => self.types.u16,
2404             UintTy::U32 => self.types.u32,
2405             UintTy::U64 => self.types.u64,
2406             UintTy::U128 => self.types.u128,
2407         }
2408     }
2409
2410     pub fn mk_mach_float(self, tm: FloatTy) -> Ty<'tcx> {
2411         match tm {
2412             FloatTy::F32 => self.types.f32,
2413             FloatTy::F64 => self.types.f64,
2414         }
2415     }
2416
2417     #[inline]
2418     pub fn mk_static_str(self) -> Ty<'tcx> {
2419         self.mk_imm_ref(self.lifetimes.re_static, self.types.str_)
2420     }
2421
2422     #[inline]
2423     pub fn mk_adt(self, def: AdtDef<'tcx>, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2424         // Take a copy of substs so that we own the vectors inside.
2425         self.mk_ty(Adt(def, substs))
2426     }
2427
2428     #[inline]
2429     pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {
2430         self.mk_ty(Foreign(def_id))
2431     }
2432
2433     fn mk_generic_adt(self, wrapper_def_id: DefId, ty_param: Ty<'tcx>) -> Ty<'tcx> {
2434         let adt_def = self.adt_def(wrapper_def_id);
2435         let substs =
2436             InternalSubsts::for_item(self, wrapper_def_id, |param, substs| match param.kind {
2437                 GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => bug!(),
2438                 GenericParamDefKind::Type { has_default, .. } => {
2439                     if param.index == 0 {
2440                         ty_param.into()
2441                     } else {
2442                         assert!(has_default);
2443                         self.bound_type_of(param.def_id).subst(self, substs).into()
2444                     }
2445                 }
2446             });
2447         self.mk_ty(Adt(adt_def, substs))
2448     }
2449
2450     #[inline]
2451     pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2452         let def_id = self.require_lang_item(LangItem::OwnedBox, None);
2453         self.mk_generic_adt(def_id, ty)
2454     }
2455
2456     #[inline]
2457     pub fn mk_lang_item(self, ty: Ty<'tcx>, item: LangItem) -> Option<Ty<'tcx>> {
2458         let def_id = self.lang_items().get(item)?;
2459         Some(self.mk_generic_adt(def_id, ty))
2460     }
2461
2462     #[inline]
2463     pub fn mk_diagnostic_item(self, ty: Ty<'tcx>, name: Symbol) -> Option<Ty<'tcx>> {
2464         let def_id = self.get_diagnostic_item(name)?;
2465         Some(self.mk_generic_adt(def_id, ty))
2466     }
2467
2468     #[inline]
2469     pub fn mk_maybe_uninit(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2470         let def_id = self.require_lang_item(LangItem::MaybeUninit, None);
2471         self.mk_generic_adt(def_id, ty)
2472     }
2473
2474     #[inline]
2475     pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
2476         self.mk_ty(RawPtr(tm))
2477     }
2478
2479     #[inline]
2480     pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
2481         self.mk_ty(Ref(r, tm.ty, tm.mutbl))
2482     }
2483
2484     #[inline]
2485     pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
2486         self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Mut })
2487     }
2488
2489     #[inline]
2490     pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
2491         self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Not })
2492     }
2493
2494     #[inline]
2495     pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2496         self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Mut })
2497     }
2498
2499     #[inline]
2500     pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2501         self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Not })
2502     }
2503
2504     #[inline]
2505     pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
2506         self.mk_ty(Array(ty, ty::Const::from_usize(self, n)))
2507     }
2508
2509     #[inline]
2510     pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
2511         self.mk_ty(Slice(ty))
2512     }
2513
2514     #[inline]
2515     pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
2516         self.mk_ty(Tuple(self.intern_type_list(&ts)))
2517     }
2518
2519     pub fn mk_tup<I: InternAs<Ty<'tcx>, Ty<'tcx>>>(self, iter: I) -> I::Output {
2520         iter.intern_with(|ts| self.mk_ty(Tuple(self.intern_type_list(&ts))))
2521     }
2522
2523     #[inline]
2524     pub fn mk_unit(self) -> Ty<'tcx> {
2525         self.types.unit
2526     }
2527
2528     #[inline]
2529     pub fn mk_diverging_default(self) -> Ty<'tcx> {
2530         if self.features().never_type_fallback { self.types.never } else { self.types.unit }
2531     }
2532
2533     #[inline]
2534     pub fn mk_fn_def(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2535         debug_assert_eq!(
2536             self.generics_of(def_id).count(),
2537             substs.len(),
2538             "wrong number of generic parameters for {def_id:?}: {substs:?}",
2539         );
2540         self.mk_ty(FnDef(def_id, substs))
2541     }
2542
2543     #[inline]
2544     pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
2545         self.mk_ty(FnPtr(fty))
2546     }
2547
2548     #[inline]
2549     pub fn mk_dynamic(
2550         self,
2551         obj: &'tcx List<PolyExistentialPredicate<'tcx>>,
2552         reg: ty::Region<'tcx>,
2553         repr: DynKind,
2554     ) -> Ty<'tcx> {
2555         self.mk_ty(Dynamic(obj, reg, repr))
2556     }
2557
2558     #[inline]
2559     pub fn mk_projection(self, item_def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2560         debug_assert_eq!(
2561             self.generics_of(item_def_id).count(),
2562             substs.len(),
2563             "wrong number of generic parameters for {item_def_id:?}: {substs:?}",
2564         );
2565         self.mk_ty(Projection(ProjectionTy { item_def_id, substs }))
2566     }
2567
2568     #[inline]
2569     pub fn mk_closure(self, closure_id: DefId, closure_substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2570         self.mk_ty(Closure(closure_id, closure_substs))
2571     }
2572
2573     #[inline]
2574     pub fn mk_generator(
2575         self,
2576         id: DefId,
2577         generator_substs: SubstsRef<'tcx>,
2578         movability: hir::Movability,
2579     ) -> Ty<'tcx> {
2580         self.mk_ty(Generator(id, generator_substs, movability))
2581     }
2582
2583     #[inline]
2584     pub fn mk_generator_witness(self, types: ty::Binder<'tcx, &'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {
2585         self.mk_ty(GeneratorWitness(types))
2586     }
2587
2588     #[inline]
2589     pub fn mk_ty_var(self, v: TyVid) -> Ty<'tcx> {
2590         self.mk_ty_infer(TyVar(v))
2591     }
2592
2593     #[inline]
2594     pub fn mk_const(self, kind: ty::ConstKind<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
2595         self.mk_const_internal(ty::ConstS { kind, ty })
2596     }
2597
2598     #[inline]
2599     pub fn mk_const_var(self, v: ConstVid<'tcx>, ty: Ty<'tcx>) -> Const<'tcx> {
2600         self.mk_const(ty::ConstKind::Infer(InferConst::Var(v)), ty)
2601     }
2602
2603     #[inline]
2604     pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {
2605         self.mk_ty_infer(IntVar(v))
2606     }
2607
2608     #[inline]
2609     pub fn mk_float_var(self, v: FloatVid) -> Ty<'tcx> {
2610         self.mk_ty_infer(FloatVar(v))
2611     }
2612
2613     #[inline]
2614     pub fn mk_ty_infer(self, it: InferTy) -> Ty<'tcx> {
2615         self.mk_ty(Infer(it))
2616     }
2617
2618     #[inline]
2619     pub fn mk_const_infer(self, ic: InferConst<'tcx>, ty: Ty<'tcx>) -> ty::Const<'tcx> {
2620         self.mk_const(ty::ConstKind::Infer(ic), ty)
2621     }
2622
2623     #[inline]
2624     pub fn mk_ty_param(self, index: u32, name: Symbol) -> Ty<'tcx> {
2625         self.mk_ty(Param(ParamTy { index, name }))
2626     }
2627
2628     #[inline]
2629     pub fn mk_const_param(self, index: u32, name: Symbol, ty: Ty<'tcx>) -> Const<'tcx> {
2630         self.mk_const(ty::ConstKind::Param(ParamConst { index, name }), ty)
2631     }
2632
2633     pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
2634         match param.kind {
2635             GenericParamDefKind::Lifetime => {
2636                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
2637             }
2638             GenericParamDefKind::Type { .. } => self.mk_ty_param(param.index, param.name).into(),
2639             GenericParamDefKind::Const { .. } => {
2640                 self.mk_const_param(param.index, param.name, self.type_of(param.def_id)).into()
2641             }
2642         }
2643     }
2644
2645     #[inline]
2646     pub fn mk_opaque(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
2647         self.mk_ty(Opaque(def_id, substs))
2648     }
2649
2650     pub fn mk_place_field(self, place: Place<'tcx>, f: Field, ty: Ty<'tcx>) -> Place<'tcx> {
2651         self.mk_place_elem(place, PlaceElem::Field(f, ty))
2652     }
2653
2654     pub fn mk_place_deref(self, place: Place<'tcx>) -> Place<'tcx> {
2655         self.mk_place_elem(place, PlaceElem::Deref)
2656     }
2657
2658     pub fn mk_place_downcast(
2659         self,
2660         place: Place<'tcx>,
2661         adt_def: AdtDef<'tcx>,
2662         variant_index: VariantIdx,
2663     ) -> Place<'tcx> {
2664         self.mk_place_elem(
2665             place,
2666             PlaceElem::Downcast(Some(adt_def.variant(variant_index).name), variant_index),
2667         )
2668     }
2669
2670     pub fn mk_place_downcast_unnamed(
2671         self,
2672         place: Place<'tcx>,
2673         variant_index: VariantIdx,
2674     ) -> Place<'tcx> {
2675         self.mk_place_elem(place, PlaceElem::Downcast(None, variant_index))
2676     }
2677
2678     pub fn mk_place_index(self, place: Place<'tcx>, index: Local) -> Place<'tcx> {
2679         self.mk_place_elem(place, PlaceElem::Index(index))
2680     }
2681
2682     /// This method copies `Place`'s projection, add an element and reintern it. Should not be used
2683     /// to build a full `Place` it's just a convenient way to grab a projection and modify it in
2684     /// flight.
2685     pub fn mk_place_elem(self, place: Place<'tcx>, elem: PlaceElem<'tcx>) -> Place<'tcx> {
2686         let mut projection = place.projection.to_vec();
2687         projection.push(elem);
2688
2689         Place { local: place.local, projection: self.intern_place_elems(&projection) }
2690     }
2691
2692     pub fn intern_poly_existential_predicates(
2693         self,
2694         eps: &[PolyExistentialPredicate<'tcx>],
2695     ) -> &'tcx List<PolyExistentialPredicate<'tcx>> {
2696         assert!(!eps.is_empty());
2697         assert!(
2698             eps.array_windows()
2699                 .all(|[a, b]| a.skip_binder().stable_cmp(self, &b.skip_binder())
2700                     != Ordering::Greater)
2701         );
2702         self._intern_poly_existential_predicates(eps)
2703     }
2704
2705     pub fn intern_predicates(self, preds: &[Predicate<'tcx>]) -> &'tcx List<Predicate<'tcx>> {
2706         // FIXME consider asking the input slice to be sorted to avoid
2707         // re-interning permutations, in which case that would be asserted
2708         // here.
2709         if preds.is_empty() {
2710             // The macro-generated method below asserts we don't intern an empty slice.
2711             List::empty()
2712         } else {
2713             self._intern_predicates(preds)
2714         }
2715     }
2716
2717     pub fn intern_type_list(self, ts: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
2718         if ts.is_empty() {
2719             List::empty()
2720         } else {
2721             // Actually intern type lists as lists of `GenericArg`s.
2722             //
2723             // Transmuting from `Ty<'tcx>` to `GenericArg<'tcx>` is sound
2724             // as explained in ty_slice_as_generic_arg`. With this,
2725             // we guarantee that even when transmuting between `List<Ty<'tcx>>`
2726             // and `List<GenericArg<'tcx>>`, the uniqueness requirement for
2727             // lists is upheld.
2728             let substs = self._intern_substs(ty::subst::ty_slice_as_generic_args(ts));
2729             substs.try_as_type_list().unwrap()
2730         }
2731     }
2732
2733     pub fn intern_substs(self, ts: &[GenericArg<'tcx>]) -> &'tcx List<GenericArg<'tcx>> {
2734         if ts.is_empty() { List::empty() } else { self._intern_substs(ts) }
2735     }
2736
2737     pub fn intern_projs(self, ps: &[ProjectionKind]) -> &'tcx List<ProjectionKind> {
2738         if ps.is_empty() { List::empty() } else { self._intern_projs(ps) }
2739     }
2740
2741     pub fn intern_place_elems(self, ts: &[PlaceElem<'tcx>]) -> &'tcx List<PlaceElem<'tcx>> {
2742         if ts.is_empty() { List::empty() } else { self._intern_place_elems(ts) }
2743     }
2744
2745     pub fn intern_canonical_var_infos(
2746         self,
2747         ts: &[CanonicalVarInfo<'tcx>],
2748     ) -> CanonicalVarInfos<'tcx> {
2749         if ts.is_empty() { List::empty() } else { self._intern_canonical_var_infos(ts) }
2750     }
2751
2752     pub fn intern_bound_variable_kinds(
2753         self,
2754         ts: &[ty::BoundVariableKind],
2755     ) -> &'tcx List<ty::BoundVariableKind> {
2756         if ts.is_empty() { List::empty() } else { self._intern_bound_variable_kinds(ts) }
2757     }
2758
2759     pub fn mk_fn_sig<I>(
2760         self,
2761         inputs: I,
2762         output: I::Item,
2763         c_variadic: bool,
2764         unsafety: hir::Unsafety,
2765         abi: abi::Abi,
2766     ) -> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
2767     where
2768         I: Iterator<Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>,
2769     {
2770         inputs.chain(iter::once(output)).intern_with(|xs| ty::FnSig {
2771             inputs_and_output: self.intern_type_list(xs),
2772             c_variadic,
2773             unsafety,
2774             abi,
2775         })
2776     }
2777
2778     pub fn mk_poly_existential_predicates<
2779         I: InternAs<PolyExistentialPredicate<'tcx>, &'tcx List<PolyExistentialPredicate<'tcx>>>,
2780     >(
2781         self,
2782         iter: I,
2783     ) -> I::Output {
2784         iter.intern_with(|xs| self.intern_poly_existential_predicates(xs))
2785     }
2786
2787     pub fn mk_predicates<I: InternAs<Predicate<'tcx>, &'tcx List<Predicate<'tcx>>>>(
2788         self,
2789         iter: I,
2790     ) -> I::Output {
2791         iter.intern_with(|xs| self.intern_predicates(xs))
2792     }
2793
2794     pub fn mk_type_list<I: InternAs<Ty<'tcx>, &'tcx List<Ty<'tcx>>>>(self, iter: I) -> I::Output {
2795         iter.intern_with(|xs| self.intern_type_list(xs))
2796     }
2797
2798     pub fn mk_substs<I: InternAs<GenericArg<'tcx>, &'tcx List<GenericArg<'tcx>>>>(
2799         self,
2800         iter: I,
2801     ) -> I::Output {
2802         iter.intern_with(|xs| self.intern_substs(xs))
2803     }
2804
2805     pub fn mk_place_elems<I: InternAs<PlaceElem<'tcx>, &'tcx List<PlaceElem<'tcx>>>>(
2806         self,
2807         iter: I,
2808     ) -> I::Output {
2809         iter.intern_with(|xs| self.intern_place_elems(xs))
2810     }
2811
2812     pub fn mk_substs_trait(
2813         self,
2814         self_ty: Ty<'tcx>,
2815         rest: impl IntoIterator<Item = GenericArg<'tcx>>,
2816     ) -> SubstsRef<'tcx> {
2817         self.mk_substs(iter::once(self_ty.into()).chain(rest))
2818     }
2819
2820     pub fn mk_trait_ref(
2821         self,
2822         trait_def_id: DefId,
2823         substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
2824     ) -> ty::TraitRef<'tcx> {
2825         let substs = substs.into_iter().map(Into::into);
2826         let n = self.generics_of(trait_def_id).count();
2827         debug_assert_eq!(
2828             (n, Some(n)),
2829             substs.size_hint(),
2830             "wrong number of generic parameters for {trait_def_id:?}: {:?} \nDid you accidentally include the self-type in the params list?",
2831             substs.collect::<Vec<_>>(),
2832         );
2833         let substs = self.mk_substs(substs);
2834         ty::TraitRef::new(trait_def_id, substs)
2835     }
2836
2837     pub fn mk_bound_variable_kinds<
2838         I: InternAs<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>,
2839     >(
2840         self,
2841         iter: I,
2842     ) -> I::Output {
2843         iter.intern_with(|xs| self.intern_bound_variable_kinds(xs))
2844     }
2845
2846     /// Emit a lint at `span` from a lint struct (some type that implements `DecorateLint`,
2847     /// typically generated by `#[derive(LintDiagnostic)]`).
2848     pub fn emit_spanned_lint(
2849         self,
2850         lint: &'static Lint,
2851         hir_id: HirId,
2852         span: impl Into<MultiSpan>,
2853         decorator: impl for<'a> DecorateLint<'a, ()>,
2854     ) {
2855         let msg = decorator.msg();
2856         let (level, src) = self.lint_level_at_node(lint, hir_id);
2857         struct_lint_level(self.sess, lint, level, src, Some(span.into()), msg, |diag| {
2858             decorator.decorate_lint(diag)
2859         })
2860     }
2861
2862     /// Emit a lint at the appropriate level for a hir node, with an associated span.
2863     ///
2864     /// Return value of the `decorate` closure is ignored, see [`struct_lint_level`] for a detailed explanation.
2865     ///
2866     /// [`struct_lint_level`]: rustc_middle::lint::struct_lint_level#decorate-signature
2867     #[rustc_lint_diagnostics]
2868     pub fn struct_span_lint_hir(
2869         self,
2870         lint: &'static Lint,
2871         hir_id: HirId,
2872         span: impl Into<MultiSpan>,
2873         msg: impl Into<DiagnosticMessage>,
2874         decorate: impl for<'a, 'b> FnOnce(
2875             &'b mut DiagnosticBuilder<'a, ()>,
2876         ) -> &'b mut DiagnosticBuilder<'a, ()>,
2877     ) {
2878         let (level, src) = self.lint_level_at_node(lint, hir_id);
2879         struct_lint_level(self.sess, lint, level, src, Some(span.into()), msg, decorate);
2880     }
2881
2882     /// Emit a lint from a lint struct (some type that implements `DecorateLint`, typically
2883     /// generated by `#[derive(LintDiagnostic)]`).
2884     pub fn emit_lint(
2885         self,
2886         lint: &'static Lint,
2887         id: HirId,
2888         decorator: impl for<'a> DecorateLint<'a, ()>,
2889     ) {
2890         self.struct_lint_node(lint, id, decorator.msg(), |diag| decorator.decorate_lint(diag))
2891     }
2892
2893     /// Emit a lint at the appropriate level for a hir node.
2894     ///
2895     /// Return value of the `decorate` closure is ignored, see [`struct_lint_level`] for a detailed explanation.
2896     ///
2897     /// [`struct_lint_level`]: rustc_middle::lint::struct_lint_level#decorate-signature
2898     #[rustc_lint_diagnostics]
2899     pub fn struct_lint_node(
2900         self,
2901         lint: &'static Lint,
2902         id: HirId,
2903         msg: impl Into<DiagnosticMessage>,
2904         decorate: impl for<'a, 'b> FnOnce(
2905             &'b mut DiagnosticBuilder<'a, ()>,
2906         ) -> &'b mut DiagnosticBuilder<'a, ()>,
2907     ) {
2908         let (level, src) = self.lint_level_at_node(lint, id);
2909         struct_lint_level(self.sess, lint, level, src, None, msg, decorate);
2910     }
2911
2912     pub fn in_scope_traits(self, id: HirId) -> Option<&'tcx [TraitCandidate]> {
2913         let map = self.in_scope_traits_map(id.owner)?;
2914         let candidates = map.get(&id.local_id)?;
2915         Some(&*candidates)
2916     }
2917
2918     pub fn named_region(self, id: HirId) -> Option<resolve_lifetime::Region> {
2919         debug!(?id, "named_region");
2920         self.named_region_map(id.owner).and_then(|map| map.get(&id.local_id).cloned())
2921     }
2922
2923     pub fn is_late_bound(self, id: HirId) -> bool {
2924         self.is_late_bound_map(id.owner.def_id).map_or(false, |set| {
2925             let def_id = self.hir().local_def_id(id);
2926             set.contains(&def_id)
2927         })
2928     }
2929
2930     pub fn late_bound_vars(self, id: HirId) -> &'tcx List<ty::BoundVariableKind> {
2931         self.mk_bound_variable_kinds(
2932             self.late_bound_vars_map(id.owner)
2933                 .and_then(|map| map.get(&id.local_id).cloned())
2934                 .unwrap_or_else(|| {
2935                     bug!("No bound vars found for {:?} ({:?})", self.hir().node_to_string(id), id)
2936                 })
2937                 .iter(),
2938         )
2939     }
2940
2941     /// Whether the `def_id` counts as const fn in the current crate, considering all active
2942     /// feature gates
2943     pub fn is_const_fn(self, def_id: DefId) -> bool {
2944         if self.is_const_fn_raw(def_id) {
2945             match self.lookup_const_stability(def_id) {
2946                 Some(stability) if stability.is_const_unstable() => {
2947                     // has a `rustc_const_unstable` attribute, check whether the user enabled the
2948                     // corresponding feature gate.
2949                     self.features()
2950                         .declared_lib_features
2951                         .iter()
2952                         .any(|&(sym, _)| sym == stability.feature)
2953                 }
2954                 // functions without const stability are either stable user written
2955                 // const fn or the user is using feature gates and we thus don't
2956                 // care what they do
2957                 _ => true,
2958             }
2959         } else {
2960             false
2961         }
2962     }
2963
2964     /// Whether the trait impl is marked const. This does not consider stability or feature gates.
2965     pub fn is_const_trait_impl_raw(self, def_id: DefId) -> bool {
2966         let Some(local_def_id) = def_id.as_local() else { return false };
2967         let hir_id = self.local_def_id_to_hir_id(local_def_id);
2968         let node = self.hir().get(hir_id);
2969
2970         matches!(
2971             node,
2972             hir::Node::Item(hir::Item {
2973                 kind: hir::ItemKind::Impl(hir::Impl { constness: hir::Constness::Const, .. }),
2974                 ..
2975             })
2976         )
2977     }
2978 }
2979
2980 impl<'tcx> TyCtxtAt<'tcx> {
2981     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used.
2982     #[track_caller]
2983     pub fn ty_error(self) -> Ty<'tcx> {
2984         self.tcx.ty_error_with_message(self.span, "TyKind::Error constructed but no error reported")
2985     }
2986
2987     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given `msg to
2988     /// ensure it gets used.
2989     #[track_caller]
2990     pub fn ty_error_with_message(self, msg: &str) -> Ty<'tcx> {
2991         self.tcx.ty_error_with_message(self.span, msg)
2992     }
2993
2994     pub fn mk_trait_ref(
2995         self,
2996         trait_lang_item: LangItem,
2997         substs: impl IntoIterator<Item = impl Into<ty::GenericArg<'tcx>>>,
2998     ) -> ty::TraitRef<'tcx> {
2999         let trait_def_id = self.require_lang_item(trait_lang_item, Some(self.span));
3000         self.tcx.mk_trait_ref(trait_def_id, substs)
3001     }
3002 }
3003
3004 /// Parameter attributes that can only be determined by examining the body of a function instead
3005 /// of just its signature.
3006 ///
3007 /// These can be useful for optimization purposes when a function is directly called. We compute
3008 /// them and store them into the crate metadata so that downstream crates can make use of them.
3009 ///
3010 /// Right now, we only have `read_only`, but `no_capture` and `no_alias` might be useful in the
3011 /// future.
3012 #[derive(Clone, Copy, PartialEq, Debug, Default, TyDecodable, TyEncodable, HashStable)]
3013 pub struct DeducedParamAttrs {
3014     /// The parameter is marked immutable in the function and contains no `UnsafeCell` (i.e. its
3015     /// type is freeze).
3016     pub read_only: bool,
3017 }
3018
3019 // We are comparing types with different invariant lifetimes, so `ptr::eq`
3020 // won't work for us.
3021 fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
3022     t as *const () == u as *const ()
3023 }
3024
3025 pub fn provide(providers: &mut ty::query::Providers) {
3026     providers.resolutions = |tcx, ()| &tcx.untracked_resolutions;
3027     providers.resolver_for_lowering = |tcx, ()| &tcx.untracked_resolver_for_lowering;
3028     providers.module_reexports =
3029         |tcx, id| tcx.resolutions(()).reexport_map.get(&id).map(|v| &v[..]);
3030     providers.crate_name = |tcx, id| {
3031         assert_eq!(id, LOCAL_CRATE);
3032         tcx.crate_name
3033     };
3034     providers.maybe_unused_trait_imports =
3035         |tcx, ()| &tcx.resolutions(()).maybe_unused_trait_imports;
3036     providers.maybe_unused_extern_crates =
3037         |tcx, ()| &tcx.resolutions(()).maybe_unused_extern_crates[..];
3038     providers.names_imported_by_glob_use = |tcx, id| {
3039         tcx.arena.alloc(tcx.resolutions(()).glob_map.get(&id).cloned().unwrap_or_default())
3040     };
3041
3042     providers.extern_mod_stmt_cnum =
3043         |tcx, id| tcx.resolutions(()).extern_crate_map.get(&id).cloned();
3044     providers.output_filenames = |tcx, ()| &tcx.output_filenames;
3045     providers.features_query = |tcx, ()| tcx.sess.features_untracked();
3046     providers.is_panic_runtime = |tcx, cnum| {
3047         assert_eq!(cnum, LOCAL_CRATE);
3048         tcx.sess.contains_name(tcx.hir().krate_attrs(), sym::panic_runtime)
3049     };
3050     providers.is_compiler_builtins = |tcx, cnum| {
3051         assert_eq!(cnum, LOCAL_CRATE);
3052         tcx.sess.contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
3053     };
3054     providers.has_panic_handler = |tcx, cnum| {
3055         assert_eq!(cnum, LOCAL_CRATE);
3056         // We want to check if the panic handler was defined in this crate
3057         tcx.lang_items().panic_impl().map_or(false, |did| did.is_local())
3058     };
3059 }