compiler/rustc_middle/src/ty/context.rs

   1 //! Type context book-keeping.
   2
   3 #![allow(rustc::usage_of_ty_tykind)]
   4
   5 pub mod tls;
   6
   7 use crate::arena::Arena;
   8 use crate::dep_graph::{DepGraph, DepKindStruct};
   9 use crate::infer::canonical::{CanonicalVarInfo, CanonicalVarInfos};
  10 use crate::lint::struct_lint_level;
  11 use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
  12 use crate::middle::resolve_lifetime;
  13 use crate::middle::stability;
  14 use crate::mir::interpret::{self, Allocation, ConstAllocation};
  15 use crate::mir::{
  16     Body, BorrowCheckResult, Field, Local, Place, PlaceElem, ProjectionKind, Promoted,
  17 };
  18 use crate::thir::Thir;
  19 use crate::traits;
  20 use crate::ty::query::{self, TyCtxtAt};
  21 use crate::ty::{
  22     self, AdtDef, AdtDefData, AdtKind, Binder, Const, ConstData, DefIdTree, FloatTy, FloatVar,
  23     FloatVid, GenericParamDefKind, ImplPolarity, InferTy, IntTy, IntVar, IntVid, List, ParamConst,
  24     ParamTy, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, Region, RegionKind,
  25     ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVar, TyVid, TypeAndMut, TypeckResults, UintTy,
  26     Visibility,
  27 };
  28 use crate::ty::{GenericArg, InternalSubsts, SubstsRef};
  29 use rustc_ast as ast;
  30 use rustc_data_structures::fingerprint::Fingerprint;
  31 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
  32 use rustc_data_structures::intern::Interned;
  33 use rustc_data_structures::memmap::Mmap;
  34 use rustc_data_structures::profiling::SelfProfilerRef;
  35 use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
  36 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
  37 use rustc_data_structures::steal::Steal;
  38 use rustc_data_structures::sync::{self, Lock, Lrc, ReadGuard, WorkerLocal};
  39 use rustc_errors::{
  40     DecorateLint, DiagnosticBuilder, DiagnosticMessage, ErrorGuaranteed, MultiSpan,
  41 };
  42 use rustc_hir as hir;
  43 use rustc_hir::def::DefKind;
  44 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
  45 use rustc_hir::definitions::Definitions;
  46 use rustc_hir::intravisit::Visitor;
  47 use rustc_hir::lang_items::LangItem;
  48 use rustc_hir::{
  49     Constness, ExprKind, HirId, ImplItemKind, ItemKind, Node, TraitCandidate, TraitItemKind,
  50 };
  51 use rustc_index::vec::IndexVec;
  52 use rustc_macros::HashStable;
  53 use rustc_query_system::dep_graph::DepNodeIndex;
  54 use rustc_query_system::ich::StableHashingContext;
  55 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
  56 use rustc_session::config::CrateType;
  57 use rustc_session::cstore::{CrateStoreDyn, Untracked};
  58 use rustc_session::lint::Lint;
  59 use rustc_session::Limit;
  60 use rustc_session::Session;
  61 use rustc_span::def_id::{DefPathHash, StableCrateId};
  62 use rustc_span::source_map::SourceMap;
  63 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  64 use rustc_span::{Span, DUMMY_SP};
  65 use rustc_target::abi::{Layout, LayoutS, TargetDataLayout, VariantIdx};
  66 use rustc_target::spec::abi;
  67 use rustc_type_ir::sty::TyKind::*;
  68 use rustc_type_ir::WithCachedTypeInfo;
  69 use rustc_type_ir::{DynKind, InternAs, InternIteratorElement, Interner, TypeFlags};
  70
  71 use std::any::Any;
  72 use std::borrow::Borrow;
  73 use std::cmp::Ordering;
  74 use std::fmt;
  75 use std::hash::{Hash, Hasher};
  76 use std::iter;
  77 use std::mem;
  78 use std::ops::{Bound, Deref};
  79
  80 pub trait OnDiskCache<'tcx>: rustc_data_structures::sync::Sync {
  81     /// Creates a new `OnDiskCache` instance from the serialized data in `data`.
  82     fn new(sess: &'tcx Session, data: Mmap, start_pos: usize) -> Self
  83     where
  84         Self: Sized;
  85
  86     fn new_empty(source_map: &'tcx SourceMap) -> Self
  87     where
  88         Self: Sized;
  89
  90     fn drop_serialized_data(&self, tcx: TyCtxt<'tcx>);
  91
  92     fn serialize(&self, tcx: TyCtxt<'tcx>, encoder: FileEncoder) -> FileEncodeResult;
  93 }
  94
  95 #[allow(rustc::usage_of_ty_tykind)]
  96 impl<'tcx> Interner for TyCtxt<'tcx> {
  97     type AdtDef = ty::AdtDef<'tcx>;
  98     type SubstsRef = ty::SubstsRef<'tcx>;
  99     type DefId = DefId;
 100     type Ty = Ty<'tcx>;
 101     type Const = ty::Const<'tcx>;
 102     type Region = Region<'tcx>;
 103     type TypeAndMut = TypeAndMut<'tcx>;
 104     type Mutability = hir::Mutability;
 105     type Movability = hir::Movability;
 106     type PolyFnSig = PolyFnSig<'tcx>;
 107     type ListBinderExistentialPredicate = &'tcx List<PolyExistentialPredicate<'tcx>>;
 108     type BinderListTy = Binder<'tcx, &'tcx List<Ty<'tcx>>>;
 109     type ListTy = &'tcx List<Ty<'tcx>>;
 110     type AliasTy = ty::AliasTy<'tcx>;
 111     type ParamTy = ParamTy;
 112     type BoundTy = ty::BoundTy;
 113     type PlaceholderType = ty::PlaceholderType;
 114     type InferTy = InferTy;
 115     type ErrorGuaranteed = ErrorGuaranteed;
 116     type PredicateKind = ty::PredicateKind<'tcx>;
 117     type AllocId = crate::mir::interpret::AllocId;
 118
 119     type EarlyBoundRegion = ty::EarlyBoundRegion;
 120     type BoundRegion = ty::BoundRegion;
 121     type FreeRegion = ty::FreeRegion;
 122     type RegionVid = ty::RegionVid;
 123     type PlaceholderRegion = ty::PlaceholderRegion;
 124 }
 125
 126 type InternedSet<'tcx, T> = ShardedHashMap<InternedInSet<'tcx, T>, ()>;
 127
 128 pub struct CtxtInterners<'tcx> {
 129     /// The arena that types, regions, etc. are allocated from.
 130     arena: &'tcx WorkerLocal<Arena<'tcx>>,
 131
 132     // Specifically use a speedy hash algorithm for these hash sets, since
 133     // they're accessed quite often.
 134     type_: InternedSet<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>,
 135     const_lists: InternedSet<'tcx, List<ty::Const<'tcx>>>,
 136     substs: InternedSet<'tcx, InternalSubsts<'tcx>>,
 137     canonical_var_infos: InternedSet<'tcx, List<CanonicalVarInfo<'tcx>>>,
 138     region: InternedSet<'tcx, RegionKind<'tcx>>,
 139     poly_existential_predicates: InternedSet<'tcx, List<PolyExistentialPredicate<'tcx>>>,
 140     predicate: InternedSet<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>,
 141     predicates: InternedSet<'tcx, List<Predicate<'tcx>>>,
 142     projs: InternedSet<'tcx, List<ProjectionKind>>,
 143     place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>,
 144     const_: InternedSet<'tcx, ConstData<'tcx>>,
 145     const_allocation: InternedSet<'tcx, Allocation>,
 146     bound_variable_kinds: InternedSet<'tcx, List<ty::BoundVariableKind>>,
 147     layout: InternedSet<'tcx, LayoutS<VariantIdx>>,
 148     adt_def: InternedSet<'tcx, AdtDefData>,
 149 }
 150
 151 impl<'tcx> CtxtInterners<'tcx> {
 152     fn new(arena: &'tcx WorkerLocal<Arena<'tcx>>) -> CtxtInterners<'tcx> {
 153         CtxtInterners {
 154             arena,
 155             type_: Default::default(),
 156             const_lists: Default::default(),
 157             substs: Default::default(),
 158             region: Default::default(),
 159             poly_existential_predicates: Default::default(),
 160             canonical_var_infos: Default::default(),
 161             predicate: Default::default(),
 162             predicates: Default::default(),
 163             projs: Default::default(),
 164             place_elems: Default::default(),
 165             const_: Default::default(),
 166             const_allocation: Default::default(),
 167             bound_variable_kinds: Default::default(),
 168             layout: Default::default(),
 169             adt_def: Default::default(),
 170         }
 171     }
 172
 173     /// Interns a type.
 174     #[allow(rustc::usage_of_ty_tykind)]
 175     #[inline(never)]
 176     fn intern_ty(&self, kind: TyKind<'tcx>, sess: &Session, untracked: &Untracked) -> Ty<'tcx> {
 177         Ty(Interned::new_unchecked(
 178             self.type_
 179                 .intern(kind, |kind| {
 180                     let flags = super::flags::FlagComputation::for_kind(&kind);
 181                     let stable_hash = self.stable_hash(&flags, sess, untracked, &kind);
 182
 183                     InternedInSet(self.arena.alloc(WithCachedTypeInfo {
 184                         internee: kind,
 185                         stable_hash,
 186                         flags: flags.flags,
 187                         outer_exclusive_binder: flags.outer_exclusive_binder,
 188                     }))
 189                 })
 190                 .0,
 191         ))
 192     }
 193
 194     fn stable_hash<'a, T: HashStable<StableHashingContext<'a>>>(
 195         &self,
 196         flags: &ty::flags::FlagComputation,
 197         sess: &'a Session,
 198         untracked: &'a Untracked,
 199         val: &T,
 200     ) -> Fingerprint {
 201         // It's impossible to hash inference variables (and will ICE), so we don't need to try to cache them.
 202         // Without incremental, we rarely stable-hash types, so let's not do it proactively.
 203         if flags.flags.intersects(TypeFlags::NEEDS_INFER) || sess.opts.incremental.is_none() {
 204             Fingerprint::ZERO
 205         } else {
 206             let mut hasher = StableHasher::new();
 207             let mut hcx = StableHashingContext::new(sess, untracked);
 208             val.hash_stable(&mut hcx, &mut hasher);
 209             hasher.finish()
 210         }
 211     }
 212
 213     #[inline(never)]
 214     fn intern_predicate(
 215         &self,
 216         kind: Binder<'tcx, PredicateKind<'tcx>>,
 217         sess: &Session,
 218         untracked: &Untracked,
 219     ) -> Predicate<'tcx> {
 220         Predicate(Interned::new_unchecked(
 221             self.predicate
 222                 .intern(kind, |kind| {
 223                     let flags = super::flags::FlagComputation::for_predicate(kind);
 224
 225                     let stable_hash = self.stable_hash(&flags, sess, untracked, &kind);
 226
 227                     InternedInSet(self.arena.alloc(WithCachedTypeInfo {
 228                         internee: kind,
 229                         stable_hash,
 230                         flags: flags.flags,
 231                         outer_exclusive_binder: flags.outer_exclusive_binder,
 232                     }))
 233                 })
 234                 .0,
 235         ))
 236     }
 237 }
 238
 239 pub struct CommonTypes<'tcx> {
 240     pub unit: Ty<'tcx>,
 241     pub bool: Ty<'tcx>,
 242     pub char: Ty<'tcx>,
 243     pub isize: Ty<'tcx>,
 244     pub i8: Ty<'tcx>,
 245     pub i16: Ty<'tcx>,
 246     pub i32: Ty<'tcx>,
 247     pub i64: Ty<'tcx>,
 248     pub i128: Ty<'tcx>,
 249     pub usize: Ty<'tcx>,
 250     pub u8: Ty<'tcx>,
 251     pub u16: Ty<'tcx>,
 252     pub u32: Ty<'tcx>,
 253     pub u64: Ty<'tcx>,
 254     pub u128: Ty<'tcx>,
 255     pub f32: Ty<'tcx>,
 256     pub f64: Ty<'tcx>,
 257     pub str_: Ty<'tcx>,
 258     pub never: Ty<'tcx>,
 259     pub self_param: Ty<'tcx>,
 260
 261     /// Dummy type used for the `Self` of a `TraitRef` created for converting
 262     /// a trait object, and which gets removed in `ExistentialTraitRef`.
 263     /// This type must not appear anywhere in other converted types.
 264     pub trait_object_dummy_self: Ty<'tcx>,
 265 }
 266
 267 pub struct CommonLifetimes<'tcx> {
 268     /// `ReStatic`
 269     pub re_static: Region<'tcx>,
 270
 271     /// Erased region, used outside of type inference.
 272     pub re_erased: Region<'tcx>,
 273 }
 274
 275 pub struct CommonConsts<'tcx> {
 276     pub unit: Const<'tcx>,
 277 }
 278
 279 impl<'tcx> CommonTypes<'tcx> {
 280     fn new(
 281         interners: &CtxtInterners<'tcx>,
 282         sess: &Session,
 283         untracked: &Untracked,
 284     ) -> CommonTypes<'tcx> {
 285         let mk = |ty| interners.intern_ty(ty, sess, untracked);
 286
 287         CommonTypes {
 288             unit: mk(Tuple(List::empty())),
 289             bool: mk(Bool),
 290             char: mk(Char),
 291             never: mk(Never),
 292             isize: mk(Int(ty::IntTy::Isize)),
 293             i8: mk(Int(ty::IntTy::I8)),
 294             i16: mk(Int(ty::IntTy::I16)),
 295             i32: mk(Int(ty::IntTy::I32)),
 296             i64: mk(Int(ty::IntTy::I64)),
 297             i128: mk(Int(ty::IntTy::I128)),
 298             usize: mk(Uint(ty::UintTy::Usize)),
 299             u8: mk(Uint(ty::UintTy::U8)),
 300             u16: mk(Uint(ty::UintTy::U16)),
 301             u32: mk(Uint(ty::UintTy::U32)),
 302             u64: mk(Uint(ty::UintTy::U64)),
 303             u128: mk(Uint(ty::UintTy::U128)),
 304             f32: mk(Float(ty::FloatTy::F32)),
 305             f64: mk(Float(ty::FloatTy::F64)),
 306             str_: mk(Str),
 307             self_param: mk(ty::Param(ty::ParamTy { index: 0, name: kw::SelfUpper })),
 308
 309             trait_object_dummy_self: mk(Infer(ty::FreshTy(0))),
 310         }
 311     }
 312 }
 313
 314 impl<'tcx> CommonLifetimes<'tcx> {
 315     fn new(interners: &CtxtInterners<'tcx>) -> CommonLifetimes<'tcx> {
 316         let mk = |r| {
 317             Region(Interned::new_unchecked(
 318                 interners.region.intern(r, |r| InternedInSet(interners.arena.alloc(r))).0,
 319             ))
 320         };
 321
 322         CommonLifetimes { re_static: mk(ty::ReStatic), re_erased: mk(ty::ReErased) }
 323     }
 324 }
 325
 326 impl<'tcx> CommonConsts<'tcx> {
 327     fn new(interners: &CtxtInterners<'tcx>, types: &CommonTypes<'tcx>) -> CommonConsts<'tcx> {
 328         let mk_const = |c| {
 329             Const(Interned::new_unchecked(
 330                 interners.const_.intern(c, |c| InternedInSet(interners.arena.alloc(c))).0,
 331             ))
 332         };
 333
 334         CommonConsts {
 335             unit: mk_const(ty::ConstData {
 336                 kind: ty::ConstKind::Value(ty::ValTree::zst()),
 337                 ty: types.unit,
 338             }),
 339         }
 340     }
 341 }
 342
 343 /// This struct contains information regarding the `ReFree(FreeRegion)` corresponding to a lifetime
 344 /// conflict.
 345 #[derive(Debug)]
 346 pub struct FreeRegionInfo {
 347     /// `LocalDefId` corresponding to FreeRegion
 348     pub def_id: LocalDefId,
 349     /// the bound region corresponding to FreeRegion
 350     pub boundregion: ty::BoundRegionKind,
 351     /// checks if bound region is in Impl Item
 352     pub is_impl_item: bool,
 353 }
 354
 355 /// This struct should only be created by `create_def`.
 356 #[derive(Copy, Clone)]
 357 pub struct TyCtxtFeed<'tcx, KEY: Copy> {
 358     pub tcx: TyCtxt<'tcx>,
 359     // Do not allow direct access, as downstream code must not mutate this field.
 360     key: KEY,
 361 }
 362
 363 impl<'tcx> TyCtxt<'tcx> {
 364     pub fn feed_unit_query(self) -> TyCtxtFeed<'tcx, ()> {
 365         TyCtxtFeed { tcx: self, key: () }
 366     }
 367     pub fn feed_local_crate(self) -> TyCtxtFeed<'tcx, CrateNum> {
 368         TyCtxtFeed { tcx: self, key: LOCAL_CRATE }
 369     }
 370 }
 371
 372 impl<'tcx, KEY: Copy> TyCtxtFeed<'tcx, KEY> {
 373     #[inline(always)]
 374     pub fn key(&self) -> KEY {
 375         self.key
 376     }
 377 }
 378
 379 impl<'tcx> TyCtxtFeed<'tcx, LocalDefId> {
 380     #[inline(always)]
 381     pub fn def_id(&self) -> LocalDefId {
 382         self.key
 383     }
 384 }
 385
 386 /// The central data structure of the compiler. It stores references
 387 /// to the various **arenas** and also houses the results of the
 388 /// various **compiler queries** that have been performed. See the
 389 /// [rustc dev guide] for more details.
 390 ///
 391 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/ty.html
 392 #[derive(Copy, Clone)]
 393 #[rustc_diagnostic_item = "TyCtxt"]
 394 #[rustc_pass_by_value]
 395 pub struct TyCtxt<'tcx> {
 396     gcx: &'tcx GlobalCtxt<'tcx>,
 397 }
 398
 399 impl<'tcx> Deref for TyCtxt<'tcx> {
 400     type Target = &'tcx GlobalCtxt<'tcx>;
 401     #[inline(always)]
 402     fn deref(&self) -> &Self::Target {
 403         &self.gcx
 404     }
 405 }
 406
 407 pub struct GlobalCtxt<'tcx> {
 408     pub arena: &'tcx WorkerLocal<Arena<'tcx>>,
 409     pub hir_arena: &'tcx WorkerLocal<hir::Arena<'tcx>>,
 410
 411     interners: CtxtInterners<'tcx>,
 412
 413     pub sess: &'tcx Session,
 414
 415     /// This only ever stores a `LintStore` but we don't want a dependency on that type here.
 416     ///
 417     /// FIXME(Centril): consider `dyn LintStoreMarker` once
 418     /// we can upcast to `Any` for some additional type safety.
 419     pub lint_store: Lrc<dyn Any + sync::Sync + sync::Send>,
 420
 421     pub dep_graph: DepGraph,
 422
 423     pub prof: SelfProfilerRef,
 424
 425     /// Common types, pre-interned for your convenience.
 426     pub types: CommonTypes<'tcx>,
 427
 428     /// Common lifetimes, pre-interned for your convenience.
 429     pub lifetimes: CommonLifetimes<'tcx>,
 430
 431     /// Common consts, pre-interned for your convenience.
 432     pub consts: CommonConsts<'tcx>,
 433
 434     untracked: Untracked,
 435
 436     /// This provides access to the incremental compilation on-disk cache for query results.
 437     /// Do not access this directly. It is only meant to be used by
 438     /// `DepGraph::try_mark_green()` and the query infrastructure.
 439     /// This is `None` if we are not incremental compilation mode
 440     pub on_disk_cache: Option<&'tcx dyn OnDiskCache<'tcx>>,
 441
 442     pub queries: &'tcx dyn query::QueryEngine<'tcx>,
 443     pub query_caches: query::QueryCaches<'tcx>,
 444     pub(crate) query_kinds: &'tcx [DepKindStruct<'tcx>],
 445
 446     // Internal caches for metadata decoding. No need to track deps on this.
 447     pub ty_rcache: Lock<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
 448     pub pred_rcache: Lock<FxHashMap<ty::CReaderCacheKey, Predicate<'tcx>>>,
 449
 450     /// Caches the results of trait selection. This cache is used
 451     /// for things that do not have to do with the parameters in scope.
 452     pub selection_cache: traits::SelectionCache<'tcx>,
 453
 454     /// Caches the results of trait evaluation. This cache is used
 455     /// for things that do not have to do with the parameters in scope.
 456     /// Merge this with `selection_cache`?
 457     pub evaluation_cache: traits::EvaluationCache<'tcx>,
 458
 459     /// Data layout specification for the current target.
 460     pub data_layout: TargetDataLayout,
 461
 462     /// Stores memory for globals (statics/consts).
 463     pub(crate) alloc_map: Lock<interpret::AllocMap<'tcx>>,
 464 }
 465
 466 impl<'tcx> TyCtxt<'tcx> {
 467     /// Expects a body and returns its codegen attributes.
 468     ///
 469     /// Unlike `codegen_fn_attrs`, this returns `CodegenFnAttrs::EMPTY` for
 470     /// constants.
 471     pub fn body_codegen_attrs(self, def_id: DefId) -> &'tcx CodegenFnAttrs {
 472         let def_kind = self.def_kind(def_id);
 473         if def_kind.has_codegen_attrs() {
 474             self.codegen_fn_attrs(def_id)
 475         } else if matches!(
 476             def_kind,
 477             DefKind::AnonConst | DefKind::AssocConst | DefKind::Const | DefKind::InlineConst
 478         ) {
 479             CodegenFnAttrs::EMPTY
 480         } else {
 481             bug!(
 482                 "body_codegen_fn_attrs called on unexpected definition: {:?} {:?}",
 483                 def_id,
 484                 def_kind
 485             )
 486         }
 487     }
 488
 489     pub fn typeck_opt_const_arg(
 490         self,
 491         def: ty::WithOptConstParam<LocalDefId>,
 492     ) -> &'tcx TypeckResults<'tcx> {
 493         if let Some(param_did) = def.const_param_did {
 494             self.typeck_const_arg((def.did, param_did))
 495         } else {
 496             self.typeck(def.did)
 497         }
 498     }
 499
 500     pub fn mir_borrowck_opt_const_arg(
 501         self,
 502         def: ty::WithOptConstParam<LocalDefId>,
 503     ) -> &'tcx BorrowCheckResult<'tcx> {
 504         if let Some(param_did) = def.const_param_did {
 505             self.mir_borrowck_const_arg((def.did, param_did))
 506         } else {
 507             self.mir_borrowck(def.did)
 508         }
 509     }
 510
 511     pub fn alloc_steal_thir(self, thir: Thir<'tcx>) -> &'tcx Steal<Thir<'tcx>> {
 512         self.arena.alloc(Steal::new(thir))
 513     }
 514
 515     pub fn alloc_steal_mir(self, mir: Body<'tcx>) -> &'tcx Steal<Body<'tcx>> {
 516         self.arena.alloc(Steal::new(mir))
 517     }
 518
 519     pub fn alloc_steal_promoted(
 520         self,
 521         promoted: IndexVec<Promoted, Body<'tcx>>,
 522     ) -> &'tcx Steal<IndexVec<Promoted, Body<'tcx>>> {
 523         self.arena.alloc(Steal::new(promoted))
 524     }
 525
 526     pub fn alloc_adt_def(
 527         self,
 528         did: DefId,
 529         kind: AdtKind,
 530         variants: IndexVec<VariantIdx, ty::VariantDef>,
 531         repr: ReprOptions,
 532     ) -> ty::AdtDef<'tcx> {
 533         self.intern_adt_def(ty::AdtDefData::new(self, did, kind, variants, repr))
 534     }
 535
 536     /// Allocates a read-only byte or string literal for `mir::interpret`.
 537     pub fn allocate_bytes(self, bytes: &[u8]) -> interpret::AllocId {
 538         // Create an allocation that just contains these bytes.
 539         let alloc = interpret::Allocation::from_bytes_byte_aligned_immutable(bytes);
 540         let alloc = self.intern_const_alloc(alloc);
 541         self.create_memory_alloc(alloc)
 542     }
 543
 544     /// Returns a range of the start/end indices specified with the
 545     /// `rustc_layout_scalar_valid_range` attribute.
 546     // FIXME(eddyb) this is an awkward spot for this method, maybe move it?
 547     pub fn layout_scalar_valid_range(self, def_id: DefId) -> (Bound<u128>, Bound<u128>) {
 548         let get = |name| {
 549             let Some(attr) = self.get_attr(def_id, name) else {
 550                 return Bound::Unbounded;
 551             };
 552             debug!("layout_scalar_valid_range: attr={:?}", attr);
 553             if let Some(
 554                 &[
 555                     ast::NestedMetaItem::Lit(ast::MetaItemLit {
 556                         kind: ast::LitKind::Int(a, _),
 557                         ..
 558                     }),
 559                 ],
 560             ) = attr.meta_item_list().as_deref()
 561             {
 562                 Bound::Included(a)
 563             } else {
 564                 self.sess
 565                     .delay_span_bug(attr.span, "invalid rustc_layout_scalar_valid_range attribute");
 566                 Bound::Unbounded
 567             }
 568         };
 569         (
 570             get(sym::rustc_layout_scalar_valid_range_start),
 571             get(sym::rustc_layout_scalar_valid_range_end),
 572         )
 573     }
 574
 575     pub fn lift<T: Lift<'tcx>>(self, value: T) -> Option<T::Lifted> {
 576         value.lift_to_tcx(self)
 577     }
 578
 579     /// Creates a type context and call the closure with a `TyCtxt` reference
 580     /// to the context. The closure enforces that the type context and any interned
 581     /// value (types, substs, etc.) can only be used while `ty::tls` has a valid
 582     /// reference to the context, to allow formatting values that need it.
 583     pub fn create_global_ctxt(
 584         s: &'tcx Session,
 585         lint_store: Lrc<dyn Any + sync::Send + sync::Sync>,
 586         arena: &'tcx WorkerLocal<Arena<'tcx>>,
 587         hir_arena: &'tcx WorkerLocal<hir::Arena<'tcx>>,
 588         untracked: Untracked,
 589         dep_graph: DepGraph,
 590         on_disk_cache: Option<&'tcx dyn OnDiskCache<'tcx>>,
 591         queries: &'tcx dyn query::QueryEngine<'tcx>,
 592         query_kinds: &'tcx [DepKindStruct<'tcx>],
 593     ) -> GlobalCtxt<'tcx> {
 594         let data_layout = s.target.parse_data_layout().unwrap_or_else(|err| {
 595             s.emit_fatal(err);
 596         });
 597         let interners = CtxtInterners::new(arena);
 598         let common_types = CommonTypes::new(&interners, s, &untracked);
 599         let common_lifetimes = CommonLifetimes::new(&interners);
 600         let common_consts = CommonConsts::new(&interners, &common_types);
 601
 602         GlobalCtxt {
 603             sess: s,
 604             lint_store,
 605             arena,
 606             hir_arena,
 607             interners,
 608             dep_graph,
 609             prof: s.prof.clone(),
 610             types: common_types,
 611             lifetimes: common_lifetimes,
 612             consts: common_consts,
 613             untracked,
 614             on_disk_cache,
 615             queries,
 616             query_caches: query::QueryCaches::default(),
 617             query_kinds,
 618             ty_rcache: Default::default(),
 619             pred_rcache: Default::default(),
 620             selection_cache: Default::default(),
 621             evaluation_cache: Default::default(),
 622             data_layout,
 623             alloc_map: Lock::new(interpret::AllocMap::new()),
 624         }
 625     }
 626
 627     /// Constructs a `TyKind::Error` type with current `ErrorGuaranteed`
 628     #[track_caller]
 629     pub fn ty_error_with_guaranteed(self, reported: ErrorGuaranteed) -> Ty<'tcx> {
 630         self.mk_ty(Error(reported))
 631     }
 632
 633     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used.
 634     #[track_caller]
 635     pub fn ty_error(self) -> Ty<'tcx> {
 636         self.ty_error_with_message(DUMMY_SP, "TyKind::Error constructed but no error reported")
 637     }
 638
 639     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given `msg` to
 640     /// ensure it gets used.
 641     #[track_caller]
 642     pub fn ty_error_with_message<S: Into<MultiSpan>>(self, span: S, msg: &str) -> Ty<'tcx> {
 643         let reported = self.sess.delay_span_bug(span, msg);
 644         self.mk_ty(Error(reported))
 645     }
 646
 647     /// Like [TyCtxt::ty_error] but for constants, with current `ErrorGuaranteed`
 648     #[track_caller]
 649     pub fn const_error_with_guaranteed(
 650         self,
 651         ty: Ty<'tcx>,
 652         reported: ErrorGuaranteed,
 653     ) -> Const<'tcx> {
 654         self.mk_const(ty::ConstKind::Error(reported), ty)
 655     }
 656
 657     /// Like [TyCtxt::ty_error] but for constants.
 658     #[track_caller]
 659     pub fn const_error(self, ty: Ty<'tcx>) -> Const<'tcx> {
 660         self.const_error_with_message(
 661             ty,
 662             DUMMY_SP,
 663             "ty::ConstKind::Error constructed but no error reported",
 664         )
 665     }
 666
 667     /// Like [TyCtxt::ty_error_with_message] but for constants.
 668     #[track_caller]
 669     pub fn const_error_with_message<S: Into<MultiSpan>>(
 670         self,
 671         ty: Ty<'tcx>,
 672         span: S,
 673         msg: &str,
 674     ) -> Const<'tcx> {
 675         let reported = self.sess.delay_span_bug(span, msg);
 676         self.mk_const(ty::ConstKind::Error(reported), ty)
 677     }
 678
 679     pub fn consider_optimizing<T: Fn() -> String>(self, msg: T) -> bool {
 680         let cname = self.crate_name(LOCAL_CRATE);
 681         self.sess.consider_optimizing(cname.as_str(), msg)
 682     }
 683
 684     /// Obtain all lang items of this crate and all dependencies (recursively)
 685     pub fn lang_items(self) -> &'tcx rustc_hir::lang_items::LanguageItems {
 686         self.get_lang_items(())
 687     }
 688
 689     /// Obtain the given diagnostic item's `DefId`. Use `is_diagnostic_item` if you just want to
 690     /// compare against another `DefId`, since `is_diagnostic_item` is cheaper.
 691     pub fn get_diagnostic_item(self, name: Symbol) -> Option<DefId> {
 692         self.all_diagnostic_items(()).name_to_id.get(&name).copied()
 693     }
 694
 695     /// Obtain the diagnostic item's name
 696     pub fn get_diagnostic_name(self, id: DefId) -> Option<Symbol> {
 697         self.diagnostic_items(id.krate).id_to_name.get(&id).copied()
 698     }
 699
 700     /// Check whether the diagnostic item with the given `name` has the given `DefId`.
 701     pub fn is_diagnostic_item(self, name: Symbol, did: DefId) -> bool {
 702         self.diagnostic_items(did.krate).name_to_id.get(&name) == Some(&did)
 703     }
 704
 705     /// Returns `true` if the node pointed to by `def_id` is a generator for an async construct.
 706     pub fn generator_is_async(self, def_id: DefId) -> bool {
 707         matches!(self.generator_kind(def_id), Some(hir::GeneratorKind::Async(_)))
 708     }
 709
 710     pub fn stability(self) -> &'tcx stability::Index {
 711         self.stability_index(())
 712     }
 713
 714     pub fn features(self) -> &'tcx rustc_feature::Features {
 715         self.features_query(())
 716     }
 717
 718     pub fn def_key(self, id: DefId) -> rustc_hir::definitions::DefKey {
 719         // Accessing the DefKey is ok, since it is part of DefPathHash.
 720         if let Some(id) = id.as_local() {
 721             self.definitions_untracked().def_key(id)
 722         } else {
 723             self.untracked.cstore.def_key(id)
 724         }
 725     }
 726
 727     /// Converts a `DefId` into its fully expanded `DefPath` (every
 728     /// `DefId` is really just an interned `DefPath`).
 729     ///
 730     /// Note that if `id` is not local to this crate, the result will
 731     ///  be a non-local `DefPath`.
 732     pub fn def_path(self, id: DefId) -> rustc_hir::definitions::DefPath {
 733         // Accessing the DefPath is ok, since it is part of DefPathHash.
 734         if let Some(id) = id.as_local() {
 735             self.definitions_untracked().def_path(id)
 736         } else {
 737             self.untracked.cstore.def_path(id)
 738         }
 739     }
 740
 741     #[inline]
 742     pub fn def_path_hash(self, def_id: DefId) -> rustc_hir::definitions::DefPathHash {
 743         // Accessing the DefPathHash is ok, it is incr. comp. stable.
 744         if let Some(def_id) = def_id.as_local() {
 745             self.definitions_untracked().def_path_hash(def_id)
 746         } else {
 747             self.untracked.cstore.def_path_hash(def_id)
 748         }
 749     }
 750
 751     #[inline]
 752     pub fn stable_crate_id(self, crate_num: CrateNum) -> StableCrateId {
 753         if crate_num == LOCAL_CRATE {
 754             self.sess.local_stable_crate_id()
 755         } else {
 756             self.untracked.cstore.stable_crate_id(crate_num)
 757         }
 758     }
 759
 760     /// Maps a StableCrateId to the corresponding CrateNum. This method assumes
 761     /// that the crate in question has already been loaded by the CrateStore.
 762     #[inline]
 763     pub fn stable_crate_id_to_crate_num(self, stable_crate_id: StableCrateId) -> CrateNum {
 764         if stable_crate_id == self.sess.local_stable_crate_id() {
 765             LOCAL_CRATE
 766         } else {
 767             self.untracked.cstore.stable_crate_id_to_crate_num(stable_crate_id)
 768         }
 769     }
 770
 771     /// Converts a `DefPathHash` to its corresponding `DefId` in the current compilation
 772     /// session, if it still exists. This is used during incremental compilation to
 773     /// turn a deserialized `DefPathHash` into its current `DefId`.
 774     pub fn def_path_hash_to_def_id(self, hash: DefPathHash, err: &mut dyn FnMut() -> !) -> DefId {
 775         debug!("def_path_hash_to_def_id({:?})", hash);
 776
 777         let stable_crate_id = hash.stable_crate_id();
 778
 779         // If this is a DefPathHash from the local crate, we can look up the
 780         // DefId in the tcx's `Definitions`.
 781         if stable_crate_id == self.sess.local_stable_crate_id() {
 782             self.untracked.definitions.read().local_def_path_hash_to_def_id(hash, err).to_def_id()
 783         } else {
 784             // If this is a DefPathHash from an upstream crate, let the CrateStore map
 785             // it to a DefId.
 786             let cstore = &*self.untracked.cstore;
 787             let cnum = cstore.stable_crate_id_to_crate_num(stable_crate_id);
 788             cstore.def_path_hash_to_def_id(cnum, hash)
 789         }
 790     }
 791
 792     pub fn def_path_debug_str(self, def_id: DefId) -> String {
 793         // We are explicitly not going through queries here in order to get
 794         // crate name and stable crate id since this code is called from debug!()
 795         // statements within the query system and we'd run into endless
 796         // recursion otherwise.
 797         let (crate_name, stable_crate_id) = if def_id.is_local() {
 798             (self.crate_name(LOCAL_CRATE), self.sess.local_stable_crate_id())
 799         } else {
 800             let cstore = &*self.untracked.cstore;
 801             (cstore.crate_name(def_id.krate), cstore.stable_crate_id(def_id.krate))
 802         };
 803
 804         format!(
 805             "{}[{:04x}]{}",
 806             crate_name,
 807             // Don't print the whole stable crate id. That's just
 808             // annoying in debug output.
 809             stable_crate_id.to_u64() >> 8 * 6,
 810             self.def_path(def_id).to_string_no_crate_verbose()
 811         )
 812     }
 813 }
 814
 815 impl<'tcx> TyCtxtAt<'tcx> {
 816     /// Create a new definition within the incr. comp. engine.
 817     pub fn create_def(
 818         self,
 819         parent: LocalDefId,
 820         data: hir::definitions::DefPathData,
 821     ) -> TyCtxtFeed<'tcx, LocalDefId> {
 822         // This function modifies `self.definitions` using a side-effect.
 823         // We need to ensure that these side effects are re-run by the incr. comp. engine.
 824         // Depending on the forever-red node will tell the graph that the calling query
 825         // needs to be re-evaluated.
 826         self.dep_graph.read_index(DepNodeIndex::FOREVER_RED_NODE);
 827
 828         // The following call has the side effect of modifying the tables inside `definitions`.
 829         // These very tables are relied on by the incr. comp. engine to decode DepNodes and to
 830         // decode the on-disk cache.
 831         //
 832         // Any LocalDefId which is used within queries, either as key or result, either:
 833         // - has been created before the construction of the TyCtxt;
 834         // - has been created by this call to `create_def`.
 835         // As a consequence, this LocalDefId is always re-created before it is needed by the incr.
 836         // comp. engine itself.
 837         //
 838         // This call also writes to the value of `source_span` and `expn_that_defined` queries.
 839         // This is fine because:
 840         // - those queries are `eval_always` so we won't miss their result changing;
 841         // - this write will have happened before these queries are called.
 842         let key = self.untracked.definitions.write().create_def(parent, data);
 843
 844         let feed = TyCtxtFeed { tcx: self.tcx, key };
 845         feed.def_span(self.span);
 846         feed
 847     }
 848 }
 849
 850 impl<'tcx> TyCtxt<'tcx> {
 851     pub fn iter_local_def_id(self) -> impl Iterator<Item = LocalDefId> + 'tcx {
 852         // Create a dependency to the red node to be sure we re-execute this when the amount of
 853         // definitions change.
 854         self.dep_graph.read_index(DepNodeIndex::FOREVER_RED_NODE);
 855
 856         let definitions = &self.untracked.definitions;
 857         std::iter::from_generator(|| {
 858             let mut i = 0;
 859
 860             // Recompute the number of definitions each time, because our caller may be creating
 861             // new ones.
 862             while i < { definitions.read().num_definitions() } {
 863                 let local_def_index = rustc_span::def_id::DefIndex::from_usize(i);
 864                 yield LocalDefId { local_def_index };
 865                 i += 1;
 866             }
 867
 868             // Leak a read lock once we finish iterating on definitions, to prevent adding new ones.
 869             definitions.leak();
 870         })
 871     }
 872
 873     pub fn def_path_table(self) -> &'tcx rustc_hir::definitions::DefPathTable {
 874         // Create a dependency to the crate to be sure we re-execute this when the amount of
 875         // definitions change.
 876         self.dep_graph.read_index(DepNodeIndex::FOREVER_RED_NODE);
 877
 878         // Leak a read lock once we start iterating on definitions, to prevent adding new ones
 879         // while iterating. If some query needs to add definitions, it should be `ensure`d above.
 880         let definitions = self.untracked.definitions.leak();
 881         definitions.def_path_table()
 882     }
 883
 884     pub fn def_path_hash_to_def_index_map(
 885         self,
 886     ) -> &'tcx rustc_hir::def_path_hash_map::DefPathHashMap {
 887         // Create a dependency to the crate to be sure we re-execute this when the amount of
 888         // definitions change.
 889         self.ensure().hir_crate(());
 890         // Leak a read lock once we start iterating on definitions, to prevent adding new ones
 891         // while iterating. If some query needs to add definitions, it should be `ensure`d above.
 892         let definitions = self.untracked.definitions.leak();
 893         definitions.def_path_hash_to_def_index_map()
 894     }
 895
 896     /// Note that this is *untracked* and should only be used within the query
 897     /// system if the result is otherwise tracked through queries
 898     pub fn cstore_untracked(self) -> &'tcx CrateStoreDyn {
 899         &*self.untracked.cstore
 900     }
 901
 902     /// Note that this is *untracked* and should only be used within the query
 903     /// system if the result is otherwise tracked through queries
 904     #[inline]
 905     pub fn definitions_untracked(self) -> ReadGuard<'tcx, Definitions> {
 906         self.untracked.definitions.read()
 907     }
 908
 909     /// Note that this is *untracked* and should only be used within the query
 910     /// system if the result is otherwise tracked through queries
 911     #[inline]
 912     pub fn source_span_untracked(self, def_id: LocalDefId) -> Span {
 913         self.untracked.source_span.get(def_id).copied().unwrap_or(DUMMY_SP)
 914     }
 915
 916     #[inline(always)]
 917     pub fn with_stable_hashing_context<R>(
 918         self,
 919         f: impl FnOnce(StableHashingContext<'_>) -> R,
 920     ) -> R {
 921         f(StableHashingContext::new(self.sess, &self.untracked))
 922     }
 923
 924     pub fn serialize_query_result_cache(self, encoder: FileEncoder) -> FileEncodeResult {
 925         self.on_disk_cache.as_ref().map_or(Ok(0), |c| c.serialize(self, encoder))
 926     }
 927
 928     /// If `true`, we should use lazy normalization for constants, otherwise
 929     /// we still evaluate them eagerly.
 930     #[inline]
 931     pub fn lazy_normalization(self) -> bool {
 932         let features = self.features();
 933         // Note: We only use lazy normalization for generic const expressions.
 934         features.generic_const_exprs
 935     }
 936
 937     #[inline]
 938     pub fn local_crate_exports_generics(self) -> bool {
 939         debug_assert!(self.sess.opts.share_generics());
 940
 941         self.sess.crate_types().iter().any(|crate_type| {
 942             match crate_type {
 943                 CrateType::Executable
 944                 | CrateType::Staticlib
 945                 | CrateType::ProcMacro
 946                 | CrateType::Cdylib => false,
 947
 948                 // FIXME rust-lang/rust#64319, rust-lang/rust#64872:
 949                 // We want to block export of generics from dylibs,
 950                 // but we must fix rust-lang/rust#65890 before we can
 951                 // do that robustly.
 952                 CrateType::Dylib => true,
 953
 954                 CrateType::Rlib => true,
 955             }
 956         })
 957     }
 958
 959     /// Returns the `DefId` and the `BoundRegionKind` corresponding to the given region.
 960     pub fn is_suitable_region(self, region: Region<'tcx>) -> Option<FreeRegionInfo> {
 961         let (suitable_region_binding_scope, bound_region) = match *region {
 962             ty::ReFree(ref free_region) => {
 963                 (free_region.scope.expect_local(), free_region.bound_region)
 964             }
 965             ty::ReEarlyBound(ref ebr) => (
 966                 self.local_parent(ebr.def_id.expect_local()),
 967                 ty::BoundRegionKind::BrNamed(ebr.def_id, ebr.name),
 968             ),
 969             _ => return None, // not a free region
 970         };
 971
 972         let is_impl_item = match self.hir().find_by_def_id(suitable_region_binding_scope) {
 973             Some(Node::Item(..) | Node::TraitItem(..)) => false,
 974             Some(Node::ImplItem(..)) => {
 975                 self.is_bound_region_in_impl_item(suitable_region_binding_scope)
 976             }
 977             _ => return None,
 978         };
 979
 980         Some(FreeRegionInfo {
 981             def_id: suitable_region_binding_scope,
 982             boundregion: bound_region,
 983             is_impl_item,
 984         })
 985     }
 986
 987     /// Given a `DefId` for an `fn`, return all the `dyn` and `impl` traits in its return type.
 988     pub fn return_type_impl_or_dyn_traits(
 989         self,
 990         scope_def_id: LocalDefId,
 991     ) -> Vec<&'tcx hir::Ty<'tcx>> {
 992         let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id);
 993         let Some(hir::FnDecl { output: hir::FnRetTy::Return(hir_output), .. }) = self.hir().fn_decl_by_hir_id(hir_id) else {
 994             return vec![];
 995         };
 996
 997         let mut v = TraitObjectVisitor(vec![], self.hir());
 998         v.visit_ty(hir_output);
 999         v.0
1000     }
1001
1002     pub fn return_type_impl_trait(self, scope_def_id: LocalDefId) -> Option<(Ty<'tcx>, Span)> {
1003         // `type_of()` will fail on these (#55796, #86483), so only allow `fn`s or closures.
1004         match self.hir().get_by_def_id(scope_def_id) {
1005             Node::Item(&hir::Item { kind: ItemKind::Fn(..), .. }) => {}
1006             Node::TraitItem(&hir::TraitItem { kind: TraitItemKind::Fn(..), .. }) => {}
1007             Node::ImplItem(&hir::ImplItem { kind: ImplItemKind::Fn(..), .. }) => {}
1008             Node::Expr(&hir::Expr { kind: ExprKind::Closure { .. }, .. }) => {}
1009             _ => return None,
1010         }
1011
1012         let ret_ty = self.type_of(scope_def_id);
1013         match ret_ty.kind() {
1014             ty::FnDef(_, _) => {
1015                 let sig = ret_ty.fn_sig(self);
1016                 let output = self.erase_late_bound_regions(sig.output());
1017                 if output.is_impl_trait() {
1018                     let hir_id = self.hir().local_def_id_to_hir_id(scope_def_id);
1019                     let fn_decl = self.hir().fn_decl_by_hir_id(hir_id).unwrap();
1020                     Some((output, fn_decl.output.span()))
1021                 } else {
1022                     None
1023                 }
1024             }
1025             _ => None,
1026         }
1027     }
1028
1029     /// Checks if the bound region is in Impl Item.
1030     pub fn is_bound_region_in_impl_item(self, suitable_region_binding_scope: LocalDefId) -> bool {
1031         let container_id = self.parent(suitable_region_binding_scope.to_def_id());
1032         if self.impl_trait_ref(container_id).is_some() {
1033             // For now, we do not try to target impls of traits. This is
1034             // because this message is going to suggest that the user
1035             // change the fn signature, but they may not be free to do so,
1036             // since the signature must match the trait.
1037             //
1038             // FIXME(#42706) -- in some cases, we could do better here.
1039             return true;
1040         }
1041         false
1042     }
1043
1044     /// Determines whether identifiers in the assembly have strict naming rules.
1045     /// Currently, only NVPTX* targets need it.
1046     pub fn has_strict_asm_symbol_naming(self) -> bool {
1047         self.sess.target.arch.contains("nvptx")
1048     }
1049
1050     /// Returns `&'static core::panic::Location<'static>`.
1051     pub fn caller_location_ty(self) -> Ty<'tcx> {
1052         self.mk_imm_ref(
1053             self.lifetimes.re_static,
1054             self.bound_type_of(self.require_lang_item(LangItem::PanicLocation, None))
1055                 .subst(self, self.mk_substs([self.lifetimes.re_static.into()].iter())),
1056         )
1057     }
1058
1059     /// Returns a displayable description and article for the given `def_id` (e.g. `("a", "struct")`).
1060     pub fn article_and_description(self, def_id: DefId) -> (&'static str, &'static str) {
1061         match self.def_kind(def_id) {
1062             DefKind::Generator => match self.generator_kind(def_id).unwrap() {
1063                 rustc_hir::GeneratorKind::Async(..) => ("an", "async closure"),
1064                 rustc_hir::GeneratorKind::Gen => ("a", "generator"),
1065             },
1066             def_kind => (def_kind.article(), def_kind.descr(def_id)),
1067         }
1068     }
1069
1070     pub fn type_length_limit(self) -> Limit {
1071         self.limits(()).type_length_limit
1072     }
1073
1074     pub fn recursion_limit(self) -> Limit {
1075         self.limits(()).recursion_limit
1076     }
1077
1078     pub fn move_size_limit(self) -> Limit {
1079         self.limits(()).move_size_limit
1080     }
1081
1082     pub fn const_eval_limit(self) -> Limit {
1083         self.limits(()).const_eval_limit
1084     }
1085
1086     pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
1087         iter::once(LOCAL_CRATE)
1088             .chain(self.crates(()).iter().copied())
1089             .flat_map(move |cnum| self.traits_in_crate(cnum).iter().copied())
1090     }
1091
1092     #[inline]
1093     pub fn local_visibility(self, def_id: LocalDefId) -> Visibility {
1094         self.visibility(def_id).expect_local()
1095     }
1096 }
1097
1098 /// A trait implemented for all `X<'a>` types that can be safely and
1099 /// efficiently converted to `X<'tcx>` as long as they are part of the
1100 /// provided `TyCtxt<'tcx>`.
1101 /// This can be done, for example, for `Ty<'tcx>` or `SubstsRef<'tcx>`
1102 /// by looking them up in their respective interners.
1103 ///
1104 /// However, this is still not the best implementation as it does
1105 /// need to compare the components, even for interned values.
1106 /// It would be more efficient if `TypedArena` provided a way to
1107 /// determine whether the address is in the allocated range.
1108 ///
1109 /// `None` is returned if the value or one of the components is not part
1110 /// of the provided context.
1111 /// For `Ty`, `None` can be returned if either the type interner doesn't
1112 /// contain the `TyKind` key or if the address of the interned
1113 /// pointer differs. The latter case is possible if a primitive type,
1114 /// e.g., `()` or `u8`, was interned in a different context.
1115 pub trait Lift<'tcx>: fmt::Debug {
1116     type Lifted: fmt::Debug + 'tcx;
1117     fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>;
1118 }
1119
1120 macro_rules! nop_lift {
1121     ($set:ident; $ty:ty => $lifted:ty) => {
1122         impl<'a, 'tcx> Lift<'tcx> for $ty {
1123             type Lifted = $lifted;
1124             fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1125                 if tcx.interners.$set.contains_pointer_to(&InternedInSet(&*self.0.0)) {
1126                     // SAFETY: `self` is interned and therefore valid
1127                     // for the entire lifetime of the `TyCtxt`.
1128                     Some(unsafe { mem::transmute(self) })
1129                 } else {
1130                     None
1131                 }
1132             }
1133         }
1134     };
1135 }
1136
1137 // Can't use the macros as we have reuse the `substs` here.
1138 //
1139 // See `intern_type_list` for more info.
1140 impl<'a, 'tcx> Lift<'tcx> for &'a List<Ty<'a>> {
1141     type Lifted = &'tcx List<Ty<'tcx>>;
1142     fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1143         if self.is_empty() {
1144             return Some(List::empty());
1145         }
1146         if tcx.interners.substs.contains_pointer_to(&InternedInSet(self.as_substs())) {
1147             // SAFETY: `self` is interned and therefore valid
1148             // for the entire lifetime of the `TyCtxt`.
1149             Some(unsafe { mem::transmute::<&'a List<Ty<'a>>, &'tcx List<Ty<'tcx>>>(self) })
1150         } else {
1151             None
1152         }
1153     }
1154 }
1155
1156 macro_rules! nop_list_lift {
1157     ($set:ident; $ty:ty => $lifted:ty) => {
1158         impl<'a, 'tcx> Lift<'tcx> for &'a List<$ty> {
1159             type Lifted = &'tcx List<$lifted>;
1160             fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted> {
1161                 if self.is_empty() {
1162                     return Some(List::empty());
1163                 }
1164                 if tcx.interners.$set.contains_pointer_to(&InternedInSet(self)) {
1165                     Some(unsafe { mem::transmute(self) })
1166                 } else {
1167                     None
1168                 }
1169             }
1170         }
1171     };
1172 }
1173
1174 nop_lift! {type_; Ty<'a> => Ty<'tcx>}
1175 nop_lift! {region; Region<'a> => Region<'tcx>}
1176 nop_lift! {const_; Const<'a> => Const<'tcx>}
1177 nop_lift! {const_allocation; ConstAllocation<'a> => ConstAllocation<'tcx>}
1178 nop_lift! {predicate; Predicate<'a> => Predicate<'tcx>}
1179
1180 nop_list_lift! {poly_existential_predicates; PolyExistentialPredicate<'a> => PolyExistentialPredicate<'tcx>}
1181 nop_list_lift! {predicates; Predicate<'a> => Predicate<'tcx>}
1182 nop_list_lift! {canonical_var_infos; CanonicalVarInfo<'a> => CanonicalVarInfo<'tcx>}
1183 nop_list_lift! {projs; ProjectionKind => ProjectionKind}
1184 nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariableKind}
1185
1186 // This is the impl for `&'a InternalSubsts<'a>`.
1187 nop_list_lift! {substs; GenericArg<'a> => GenericArg<'tcx>}
1188
1189 CloneLiftImpls! { for<'tcx> {
1190     Constness, traits::WellFormedLoc, ImplPolarity, crate::mir::ReturnConstraint,
1191 } }
1192
1193 macro_rules! sty_debug_print {
1194     ($fmt: expr, $ctxt: expr, $($variant: ident),*) => {{
1195         // Curious inner module to allow variant names to be used as
1196         // variable names.
1197         #[allow(non_snake_case)]
1198         mod inner {
1199             use crate::ty::{self, TyCtxt};
1200             use crate::ty::context::InternedInSet;
1201
1202             #[derive(Copy, Clone)]
1203             struct DebugStat {
1204                 total: usize,
1205                 lt_infer: usize,
1206                 ty_infer: usize,
1207                 ct_infer: usize,
1208                 all_infer: usize,
1209             }
1210
1211             pub fn go(fmt: &mut std::fmt::Formatter<'_>, tcx: TyCtxt<'_>) -> std::fmt::Result {
1212                 let mut total = DebugStat {
1213                     total: 0,
1214                     lt_infer: 0,
1215                     ty_infer: 0,
1216                     ct_infer: 0,
1217                     all_infer: 0,
1218                 };
1219                 $(let mut $variant = total;)*
1220
1221                 let shards = tcx.interners.type_.lock_shards();
1222                 let types = shards.iter().flat_map(|shard| shard.keys());
1223                 for &InternedInSet(t) in types {
1224                     let variant = match t.internee {
1225                         ty::Bool | ty::Char | ty::Int(..) | ty::Uint(..) |
1226                             ty::Float(..) | ty::Str | ty::Never => continue,
1227                         ty::Error(_) => /* unimportant */ continue,
1228                         $(ty::$variant(..) => &mut $variant,)*
1229                     };
1230                     let lt = t.flags.intersects(ty::TypeFlags::HAS_RE_INFER);
1231                     let ty = t.flags.intersects(ty::TypeFlags::HAS_TY_INFER);
1232                     let ct = t.flags.intersects(ty::TypeFlags::HAS_CT_INFER);
1233
1234                     variant.total += 1;
1235                     total.total += 1;
1236                     if lt { total.lt_infer += 1; variant.lt_infer += 1 }
1237                     if ty { total.ty_infer += 1; variant.ty_infer += 1 }
1238                     if ct { total.ct_infer += 1; variant.ct_infer += 1 }
1239                     if lt && ty && ct { total.all_infer += 1; variant.all_infer += 1 }
1240                 }
1241                 writeln!(fmt, "Ty interner             total           ty lt ct all")?;
1242                 $(writeln!(fmt, "    {:18}: {uses:6} {usespc:4.1}%, \
1243                             {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
1244                     stringify!($variant),
1245                     uses = $variant.total,
1246                     usespc = $variant.total as f64 * 100.0 / total.total as f64,
1247                     ty = $variant.ty_infer as f64 * 100.0  / total.total as f64,
1248                     lt = $variant.lt_infer as f64 * 100.0  / total.total as f64,
1249                     ct = $variant.ct_infer as f64 * 100.0  / total.total as f64,
1250                     all = $variant.all_infer as f64 * 100.0  / total.total as f64)?;
1251                 )*
1252                 writeln!(fmt, "                  total {uses:6}        \
1253                           {ty:4.1}% {lt:5.1}% {ct:4.1}% {all:4.1}%",
1254                     uses = total.total,
1255                     ty = total.ty_infer as f64 * 100.0  / total.total as f64,
1256                     lt = total.lt_infer as f64 * 100.0  / total.total as f64,
1257                     ct = total.ct_infer as f64 * 100.0  / total.total as f64,
1258                     all = total.all_infer as f64 * 100.0  / total.total as f64)
1259             }
1260         }
1261
1262         inner::go($fmt, $ctxt)
1263     }}
1264 }
1265
1266 impl<'tcx> TyCtxt<'tcx> {
1267     pub fn debug_stats(self) -> impl std::fmt::Debug + 'tcx {
1268         struct DebugStats<'tcx>(TyCtxt<'tcx>);
1269
1270         impl<'tcx> std::fmt::Debug for DebugStats<'tcx> {
1271             fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1272                 sty_debug_print!(
1273                     fmt,
1274                     self.0,
1275                     Adt,
1276                     Array,
1277                     Slice,
1278                     RawPtr,
1279                     Ref,
1280                     FnDef,
1281                     FnPtr,
1282                     Placeholder,
1283                     Generator,
1284                     GeneratorWitness,
1285                     Dynamic,
1286                     Closure,
1287                     Tuple,
1288                     Bound,
1289                     Param,
1290                     Infer,
1291                     Alias,
1292                     Foreign
1293                 )?;
1294
1295                 writeln!(fmt, "InternalSubsts interner: #{}", self.0.interners.substs.len())?;
1296                 writeln!(fmt, "Region interner: #{}", self.0.interners.region.len())?;
1297                 writeln!(
1298                     fmt,
1299                     "Const Allocation interner: #{}",
1300                     self.0.interners.const_allocation.len()
1301                 )?;
1302                 writeln!(fmt, "Layout interner: #{}", self.0.interners.layout.len())?;
1303
1304                 Ok(())
1305             }
1306         }
1307
1308         DebugStats(self)
1309     }
1310 }
1311
1312 // This type holds a `T` in the interner. The `T` is stored in the arena and
1313 // this type just holds a pointer to it, but it still effectively owns it. It
1314 // impls `Borrow` so that it can be looked up using the original
1315 // (non-arena-memory-owning) types.
1316 struct InternedInSet<'tcx, T: ?Sized>(&'tcx T);
1317
1318 impl<'tcx, T: 'tcx + ?Sized> Clone for InternedInSet<'tcx, T> {
1319     fn clone(&self) -> Self {
1320         InternedInSet(self.0)
1321     }
1322 }
1323
1324 impl<'tcx, T: 'tcx + ?Sized> Copy for InternedInSet<'tcx, T> {}
1325
1326 impl<'tcx, T: 'tcx + ?Sized> IntoPointer for InternedInSet<'tcx, T> {
1327     fn into_pointer(&self) -> *const () {
1328         self.0 as *const _ as *const ()
1329     }
1330 }
1331
1332 #[allow(rustc::usage_of_ty_tykind)]
1333 impl<'tcx, T> Borrow<T> for InternedInSet<'tcx, WithCachedTypeInfo<T>> {
1334     fn borrow(&self) -> &T {
1335         &self.0.internee
1336     }
1337 }
1338
1339 impl<'tcx, T: PartialEq> PartialEq for InternedInSet<'tcx, WithCachedTypeInfo<T>> {
1340     fn eq(&self, other: &InternedInSet<'tcx, WithCachedTypeInfo<T>>) -> bool {
1341         // The `Borrow` trait requires that `x.borrow() == y.borrow()` equals
1342         // `x == y`.
1343         self.0.internee == other.0.internee
1344     }
1345 }
1346
1347 impl<'tcx, T: Eq> Eq for InternedInSet<'tcx, WithCachedTypeInfo<T>> {}
1348
1349 impl<'tcx, T: Hash> Hash for InternedInSet<'tcx, WithCachedTypeInfo<T>> {
1350     fn hash<H: Hasher>(&self, s: &mut H) {
1351         // The `Borrow` trait requires that `x.borrow().hash(s) == x.hash(s)`.
1352         self.0.internee.hash(s)
1353     }
1354 }
1355
1356 impl<'tcx, T> Borrow<[T]> for InternedInSet<'tcx, List<T>> {
1357     fn borrow(&self) -> &[T] {
1358         &self.0[..]
1359     }
1360 }
1361
1362 impl<'tcx, T: PartialEq> PartialEq for InternedInSet<'tcx, List<T>> {
1363     fn eq(&self, other: &InternedInSet<'tcx, List<T>>) -> bool {
1364         // The `Borrow` trait requires that `x.borrow() == y.borrow()` equals
1365         // `x == y`.
1366         self.0[..] == other.0[..]
1367     }
1368 }
1369
1370 impl<'tcx, T: Eq> Eq for InternedInSet<'tcx, List<T>> {}
1371
1372 impl<'tcx, T: Hash> Hash for InternedInSet<'tcx, List<T>> {
1373     fn hash<H: Hasher>(&self, s: &mut H) {
1374         // The `Borrow` trait requires that `x.borrow().hash(s) == x.hash(s)`.
1375         self.0[..].hash(s)
1376     }
1377 }
1378
1379 macro_rules! direct_interners {
1380     ($($name:ident: $method:ident($ty:ty): $ret_ctor:ident -> $ret_ty:ty,)+) => {
1381         $(impl<'tcx> Borrow<$ty> for InternedInSet<'tcx, $ty> {
1382             fn borrow<'a>(&'a self) -> &'a $ty {
1383                 &self.0
1384             }
1385         }
1386
1387         impl<'tcx> PartialEq for InternedInSet<'tcx, $ty> {
1388             fn eq(&self, other: &Self) -> bool {
1389                 // The `Borrow` trait requires that `x.borrow() == y.borrow()`
1390                 // equals `x == y`.
1391                 self.0 == other.0
1392             }
1393         }
1394
1395         impl<'tcx> Eq for InternedInSet<'tcx, $ty> {}
1396
1397         impl<'tcx> Hash for InternedInSet<'tcx, $ty> {
1398             fn hash<H: Hasher>(&self, s: &mut H) {
1399                 // The `Borrow` trait requires that `x.borrow().hash(s) ==
1400                 // x.hash(s)`.
1401                 self.0.hash(s)
1402             }
1403         }
1404
1405         impl<'tcx> TyCtxt<'tcx> {
1406             pub fn $method(self, v: $ty) -> $ret_ty {
1407                 $ret_ctor(Interned::new_unchecked(self.interners.$name.intern(v, |v| {
1408                     InternedInSet(self.interners.arena.alloc(v))
1409                 }).0))
1410             }
1411         })+
1412     }
1413 }
1414
1415 direct_interners! {
1416     region: mk_region(RegionKind<'tcx>): Region -> Region<'tcx>,
1417     const_: mk_const_internal(ConstData<'tcx>): Const -> Const<'tcx>,
1418     const_allocation: intern_const_alloc(Allocation): ConstAllocation -> ConstAllocation<'tcx>,
1419     layout: intern_layout(LayoutS<VariantIdx>): Layout -> Layout<'tcx>,
1420     adt_def: intern_adt_def(AdtDefData): AdtDef -> AdtDef<'tcx>,
1421 }
1422
1423 macro_rules! slice_interners {
1424     ($($field:ident: $method:ident($ty:ty)),+ $(,)?) => (
1425         impl<'tcx> TyCtxt<'tcx> {
1426             $(pub fn $method(self, v: &[$ty]) -> &'tcx List<$ty> {
1427                 self.interners.$field.intern_ref(v, || {
1428                     InternedInSet(List::from_arena(&*self.arena, v))
1429                 }).0
1430             })+
1431         }
1432     );
1433 }
1434
1435 slice_interners!(
1436     const_lists: _intern_const_list(Const<'tcx>),
1437     substs: _intern_substs(GenericArg<'tcx>),
1438     canonical_var_infos: _intern_canonical_var_infos(CanonicalVarInfo<'tcx>),
1439     poly_existential_predicates:
1440         _intern_poly_existential_predicates(PolyExistentialPredicate<'tcx>),
1441     predicates: _intern_predicates(Predicate<'tcx>),
1442     projs: _intern_projs(ProjectionKind),
1443     place_elems: _intern_place_elems(PlaceElem<'tcx>),
1444     bound_variable_kinds: _intern_bound_variable_kinds(ty::BoundVariableKind),
1445 );
1446
1447 impl<'tcx> TyCtxt<'tcx> {
1448     /// Given a `fn` type, returns an equivalent `unsafe fn` type;
1449     /// that is, a `fn` type that is equivalent in every way for being
1450     /// unsafe.
1451     pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
1452         assert_eq!(sig.unsafety(), hir::Unsafety::Normal);
1453         self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig { unsafety: hir::Unsafety::Unsafe, ..sig }))
1454     }
1455
1456     /// Given the def_id of a Trait `trait_def_id` and the name of an associated item `assoc_name`
1457     /// returns true if the `trait_def_id` defines an associated item of name `assoc_name`.
1458     pub fn trait_may_define_assoc_type(self, trait_def_id: DefId, assoc_name: Ident) -> bool {
1459         self.super_traits_of(trait_def_id).any(|trait_did| {
1460             self.associated_items(trait_did)
1461                 .find_by_name_and_kind(self, assoc_name, ty::AssocKind::Type, trait_did)
1462                 .is_some()
1463         })
1464     }
1465
1466     /// Given a `ty`, return whether it's an `impl Future<...>`.
1467     pub fn ty_is_opaque_future(self, ty: Ty<'_>) -> bool {
1468         let ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) = ty.kind() else { return false };
1469         let future_trait = self.require_lang_item(LangItem::Future, None);
1470
1471         self.explicit_item_bounds(def_id).iter().any(|(predicate, _)| {
1472             let ty::PredicateKind::Clause(ty::Clause::Trait(trait_predicate)) = predicate.kind().skip_binder() else {
1473                 return false;
1474             };
1475             trait_predicate.trait_ref.def_id == future_trait
1476                 && trait_predicate.polarity == ImplPolarity::Positive
1477         })
1478     }
1479
1480     /// Computes the def-ids of the transitive supertraits of `trait_def_id`. This (intentionally)
1481     /// does not compute the full elaborated super-predicates but just the set of def-ids. It is used
1482     /// to identify which traits may define a given associated type to help avoid cycle errors.
1483     /// Returns a `DefId` iterator.
1484     fn super_traits_of(self, trait_def_id: DefId) -> impl Iterator<Item = DefId> + 'tcx {
1485         let mut set = FxHashSet::default();
1486         let mut stack = vec![trait_def_id];
1487
1488         set.insert(trait_def_id);
1489
1490         iter::from_fn(move || -> Option<DefId> {
1491             let trait_did = stack.pop()?;
1492             let generic_predicates = self.super_predicates_of(trait_did);
1493
1494             for (predicate, _) in generic_predicates.predicates {
1495                 if let ty::PredicateKind::Clause(ty::Clause::Trait(data)) =
1496                     predicate.kind().skip_binder()
1497                 {
1498                     if set.insert(data.def_id()) {
1499                         stack.push(data.def_id());
1500                     }
1501                 }
1502             }
1503
1504             Some(trait_did)
1505         })
1506     }
1507
1508     /// Given a closure signature, returns an equivalent fn signature. Detuples
1509     /// and so forth -- so e.g., if we have a sig with `Fn<(u32, i32)>` then
1510     /// you would get a `fn(u32, i32)`.
1511     /// `unsafety` determines the unsafety of the fn signature. If you pass
1512     /// `hir::Unsafety::Unsafe` in the previous example, then you would get
1513     /// an `unsafe fn (u32, i32)`.
1514     /// It cannot convert a closure that requires unsafe.
1515     pub fn signature_unclosure(
1516         self,
1517         sig: PolyFnSig<'tcx>,
1518         unsafety: hir::Unsafety,
1519     ) -> PolyFnSig<'tcx> {
1520         sig.map_bound(|s| {
1521             let params_iter = match s.inputs()[0].kind() {
1522                 ty::Tuple(params) => params.into_iter(),
1523                 _ => bug!(),
1524             };
1525             self.mk_fn_sig(params_iter, s.output(), s.c_variadic, unsafety, abi::Abi::Rust)
1526         })
1527     }
1528
1529     /// Same a `self.mk_region(kind)`, but avoids accessing the interners if
1530     /// `*r == kind`.
1531     #[inline]
1532     pub fn reuse_or_mk_region(self, r: Region<'tcx>, kind: RegionKind<'tcx>) -> Region<'tcx> {
1533         if *r == kind { r } else { self.mk_region(kind) }
1534     }
1535
1536     #[allow(rustc::usage_of_ty_tykind)]
1537     #[inline]
1538     pub fn mk_ty(self, st: TyKind<'tcx>) -> Ty<'tcx> {
1539         self.interners.intern_ty(
1540             st,
1541             self.sess,
1542             // This is only used to create a stable hashing context.
1543             &self.untracked,
1544         )
1545     }
1546
1547     #[inline]
1548     pub fn mk_predicate(self, binder: Binder<'tcx, PredicateKind<'tcx>>) -> Predicate<'tcx> {
1549         self.interners.intern_predicate(
1550             binder,
1551             self.sess,
1552             // This is only used to create a stable hashing context.
1553             &self.untracked,
1554         )
1555     }
1556
1557     #[inline]
1558     pub fn reuse_or_mk_predicate(
1559         self,
1560         pred: Predicate<'tcx>,
1561         binder: Binder<'tcx, PredicateKind<'tcx>>,
1562     ) -> Predicate<'tcx> {
1563         if pred.kind() != binder { self.mk_predicate(binder) } else { pred }
1564     }
1565
1566     pub fn mk_mach_int(self, tm: IntTy) -> Ty<'tcx> {
1567         match tm {
1568             IntTy::Isize => self.types.isize,
1569             IntTy::I8 => self.types.i8,
1570             IntTy::I16 => self.types.i16,
1571             IntTy::I32 => self.types.i32,
1572             IntTy::I64 => self.types.i64,
1573             IntTy::I128 => self.types.i128,
1574         }
1575     }
1576
1577     pub fn mk_mach_uint(self, tm: UintTy) -> Ty<'tcx> {
1578         match tm {
1579             UintTy::Usize => self.types.usize,
1580             UintTy::U8 => self.types.u8,
1581             UintTy::U16 => self.types.u16,
1582             UintTy::U32 => self.types.u32,
1583             UintTy::U64 => self.types.u64,
1584             UintTy::U128 => self.types.u128,
1585         }
1586     }
1587
1588     pub fn mk_mach_float(self, tm: FloatTy) -> Ty<'tcx> {
1589         match tm {
1590             FloatTy::F32 => self.types.f32,
1591             FloatTy::F64 => self.types.f64,
1592         }
1593     }
1594
1595     #[inline]
1596     pub fn mk_static_str(self) -> Ty<'tcx> {
1597         self.mk_imm_ref(self.lifetimes.re_static, self.types.str_)
1598     }
1599
1600     #[inline]
1601     pub fn mk_adt(self, def: AdtDef<'tcx>, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
1602         // Take a copy of substs so that we own the vectors inside.
1603         self.mk_ty(Adt(def, substs))
1604     }
1605
1606     #[inline]
1607     pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {
1608         self.mk_ty(Foreign(def_id))
1609     }
1610
1611     fn mk_generic_adt(self, wrapper_def_id: DefId, ty_param: Ty<'tcx>) -> Ty<'tcx> {
1612         let adt_def = self.adt_def(wrapper_def_id);
1613         let substs =
1614             InternalSubsts::for_item(self, wrapper_def_id, |param, substs| match param.kind {
1615                 GenericParamDefKind::Lifetime | GenericParamDefKind::Const { .. } => bug!(),
1616                 GenericParamDefKind::Type { has_default, .. } => {
1617                     if param.index == 0 {
1618                         ty_param.into()
1619                     } else {
1620                         assert!(has_default);
1621                         self.bound_type_of(param.def_id).subst(self, substs).into()
1622                     }
1623                 }
1624             });
1625         self.mk_ty(Adt(adt_def, substs))
1626     }
1627
1628     #[inline]
1629     pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> {
1630         let def_id = self.require_lang_item(LangItem::OwnedBox, None);
1631         self.mk_generic_adt(def_id, ty)
1632     }
1633
1634     #[inline]
1635     pub fn mk_lang_item(self, ty: Ty<'tcx>, item: LangItem) -> Option<Ty<'tcx>> {
1636         let def_id = self.lang_items().get(item)?;
1637         Some(self.mk_generic_adt(def_id, ty))
1638     }
1639
1640     #[inline]
1641     pub fn mk_diagnostic_item(self, ty: Ty<'tcx>, name: Symbol) -> Option<Ty<'tcx>> {
1642         let def_id = self.get_diagnostic_item(name)?;
1643         Some(self.mk_generic_adt(def_id, ty))
1644     }
1645
1646     #[inline]
1647     pub fn mk_maybe_uninit(self, ty: Ty<'tcx>) -> Ty<'tcx> {
1648         let def_id = self.require_lang_item(LangItem::MaybeUninit, None);
1649         self.mk_generic_adt(def_id, ty)
1650     }
1651
1652     #[inline]
1653     pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
1654         self.mk_ty(RawPtr(tm))
1655     }
1656
1657     #[inline]
1658     pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
1659         self.mk_ty(Ref(r, tm.ty, tm.mutbl))
1660     }
1661
1662     #[inline]
1663     pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
1664         self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Mut })
1665     }
1666
1667     #[inline]
1668     pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
1669         self.mk_ref(r, TypeAndMut { ty, mutbl: hir::Mutability::Not })
1670     }
1671
1672     #[inline]
1673     pub fn mk_mut_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
1674         self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Mut })
1675     }
1676
1677     #[inline]
1678     pub fn mk_imm_ptr(self, ty: Ty<'tcx>) -> Ty<'tcx> {
1679         self.mk_ptr(TypeAndMut { ty, mutbl: hir::Mutability::Not })
1680     }
1681
1682     #[inline]
1683     pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
1684         self.mk_ty(Array(ty, ty::Const::from_usize(self, n)))
1685     }
1686
1687     #[inline]
1688     pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
1689         self.mk_ty(Slice(ty))
1690     }
1691
1692     #[inline]
1693     pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
1694         self.mk_ty(Tuple(self.intern_type_list(&ts)))
1695     }
1696
1697     pub fn mk_tup<I: InternAs<Ty<'tcx>, Ty<'tcx>>>(self, iter: I) -> I::Output {
1698         iter.intern_with(|ts| self.mk_ty(Tuple(self.intern_type_list(&ts))))
1699     }
1700
1701     #[inline]
1702     pub fn mk_unit(self) -> Ty<'tcx> {
1703         self.types.unit
1704     }
1705
1706     #[inline]
1707     pub fn mk_diverging_default(self) -> Ty<'tcx> {
1708         if self.features().never_type_fallback { self.types.never } else { self.types.unit }
1709     }
1710
1711     #[inline]
1712     pub fn mk_fn_def(
1713         self,
1714         def_id: DefId,
1715         substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
1716     ) -> Ty<'tcx> {
1717         let substs = self.check_substs(def_id, substs);
1718         self.mk_ty(FnDef(def_id, substs))
1719     }
1720
1721     #[inline(always)]
1722     fn check_substs(
1723         self,
1724         _def_id: DefId,
1725         substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
1726     ) -> SubstsRef<'tcx> {
1727         let substs = substs.into_iter().map(Into::into);
1728         #[cfg(debug_assertions)]
1729         {
1730             let n = self.generics_of(_def_id).count();
1731             assert_eq!(
1732                 (n, Some(n)),
1733                 substs.size_hint(),
1734                 "wrong number of generic parameters for {_def_id:?}: {:?}",
1735                 substs.collect::<Vec<_>>(),
1736             );
1737         }
1738         self.mk_substs(substs)
1739     }
1740
1741     #[inline]
1742     pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
1743         self.mk_ty(FnPtr(fty))
1744     }
1745
1746     #[inline]
1747     pub fn mk_dynamic(
1748         self,
1749         obj: &'tcx List<PolyExistentialPredicate<'tcx>>,
1750         reg: ty::Region<'tcx>,
1751         repr: DynKind,
1752     ) -> Ty<'tcx> {
1753         self.mk_ty(Dynamic(obj, reg, repr))
1754     }
1755
1756     #[inline]
1757     pub fn mk_projection(
1758         self,
1759         item_def_id: DefId,
1760         substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
1761     ) -> Ty<'tcx> {
1762         self.mk_ty(Alias(ty::Projection, self.mk_alias_ty(item_def_id, substs)))
1763     }
1764
1765     #[inline]
1766     pub fn mk_closure(self, closure_id: DefId, closure_substs: SubstsRef<'tcx>) -> Ty<'tcx> {
1767         self.mk_ty(Closure(closure_id, closure_substs))
1768     }
1769
1770     #[inline]
1771     pub fn mk_generator(
1772         self,
1773         id: DefId,
1774         generator_substs: SubstsRef<'tcx>,
1775         movability: hir::Movability,
1776     ) -> Ty<'tcx> {
1777         self.mk_ty(Generator(id, generator_substs, movability))
1778     }
1779
1780     #[inline]
1781     pub fn mk_generator_witness(self, types: ty::Binder<'tcx, &'tcx List<Ty<'tcx>>>) -> Ty<'tcx> {
1782         self.mk_ty(GeneratorWitness(types))
1783     }
1784
1785     /// Creates a `&mut Context<'_>` [`Ty`] with erased lifetimes.
1786     pub fn mk_task_context(self) -> Ty<'tcx> {
1787         let context_did = self.require_lang_item(LangItem::Context, None);
1788         let context_adt_ref = self.adt_def(context_did);
1789         let context_substs = self.intern_substs(&[self.lifetimes.re_erased.into()]);
1790         let context_ty = self.mk_adt(context_adt_ref, context_substs);
1791         self.mk_mut_ref(self.lifetimes.re_erased, context_ty)
1792     }
1793
1794     #[inline]
1795     pub fn mk_ty_var(self, v: TyVid) -> Ty<'tcx> {
1796         self.mk_ty_infer(TyVar(v))
1797     }
1798
1799     #[inline]
1800     pub fn mk_const(self, kind: impl Into<ty::ConstKind<'tcx>>, ty: Ty<'tcx>) -> Const<'tcx> {
1801         self.mk_const_internal(ty::ConstData { kind: kind.into(), ty })
1802     }
1803
1804     #[inline]
1805     pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {
1806         self.mk_ty_infer(IntVar(v))
1807     }
1808
1809     #[inline]
1810     pub fn mk_float_var(self, v: FloatVid) -> Ty<'tcx> {
1811         self.mk_ty_infer(FloatVar(v))
1812     }
1813
1814     #[inline]
1815     pub fn mk_ty_infer(self, it: InferTy) -> Ty<'tcx> {
1816         self.mk_ty(Infer(it))
1817     }
1818
1819     #[inline]
1820     pub fn mk_ty_param(self, index: u32, name: Symbol) -> Ty<'tcx> {
1821         self.mk_ty(Param(ParamTy { index, name }))
1822     }
1823
1824     pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
1825         match param.kind {
1826             GenericParamDefKind::Lifetime => {
1827                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
1828             }
1829             GenericParamDefKind::Type { .. } => self.mk_ty_param(param.index, param.name).into(),
1830             GenericParamDefKind::Const { .. } => self
1831                 .mk_const(
1832                     ParamConst { index: param.index, name: param.name },
1833                     self.type_of(param.def_id),
1834                 )
1835                 .into(),
1836         }
1837     }
1838
1839     #[inline]
1840     pub fn mk_opaque(self, def_id: DefId, substs: SubstsRef<'tcx>) -> Ty<'tcx> {
1841         self.mk_ty(Alias(ty::Opaque, self.mk_alias_ty(def_id, substs)))
1842     }
1843
1844     pub fn mk_place_field(self, place: Place<'tcx>, f: Field, ty: Ty<'tcx>) -> Place<'tcx> {
1845         self.mk_place_elem(place, PlaceElem::Field(f, ty))
1846     }
1847
1848     pub fn mk_place_deref(self, place: Place<'tcx>) -> Place<'tcx> {
1849         self.mk_place_elem(place, PlaceElem::Deref)
1850     }
1851
1852     pub fn mk_place_downcast(
1853         self,
1854         place: Place<'tcx>,
1855         adt_def: AdtDef<'tcx>,
1856         variant_index: VariantIdx,
1857     ) -> Place<'tcx> {
1858         self.mk_place_elem(
1859             place,
1860             PlaceElem::Downcast(Some(adt_def.variant(variant_index).name), variant_index),
1861         )
1862     }
1863
1864     pub fn mk_place_downcast_unnamed(
1865         self,
1866         place: Place<'tcx>,
1867         variant_index: VariantIdx,
1868     ) -> Place<'tcx> {
1869         self.mk_place_elem(place, PlaceElem::Downcast(None, variant_index))
1870     }
1871
1872     pub fn mk_place_index(self, place: Place<'tcx>, index: Local) -> Place<'tcx> {
1873         self.mk_place_elem(place, PlaceElem::Index(index))
1874     }
1875
1876     /// This method copies `Place`'s projection, add an element and reintern it. Should not be used
1877     /// to build a full `Place` it's just a convenient way to grab a projection and modify it in
1878     /// flight.
1879     pub fn mk_place_elem(self, place: Place<'tcx>, elem: PlaceElem<'tcx>) -> Place<'tcx> {
1880         let mut projection = place.projection.to_vec();
1881         projection.push(elem);
1882
1883         Place { local: place.local, projection: self.intern_place_elems(&projection) }
1884     }
1885
1886     pub fn intern_poly_existential_predicates(
1887         self,
1888         eps: &[PolyExistentialPredicate<'tcx>],
1889     ) -> &'tcx List<PolyExistentialPredicate<'tcx>> {
1890         assert!(!eps.is_empty());
1891         assert!(
1892             eps.array_windows()
1893                 .all(|[a, b]| a.skip_binder().stable_cmp(self, &b.skip_binder())
1894                     != Ordering::Greater)
1895         );
1896         self._intern_poly_existential_predicates(eps)
1897     }
1898
1899     pub fn intern_predicates(self, preds: &[Predicate<'tcx>]) -> &'tcx List<Predicate<'tcx>> {
1900         // FIXME consider asking the input slice to be sorted to avoid
1901         // re-interning permutations, in which case that would be asserted
1902         // here.
1903         if preds.is_empty() {
1904             // The macro-generated method below asserts we don't intern an empty slice.
1905             List::empty()
1906         } else {
1907             self._intern_predicates(preds)
1908         }
1909     }
1910
1911     pub fn mk_const_list<I: InternAs<ty::Const<'tcx>, &'tcx List<ty::Const<'tcx>>>>(
1912         self,
1913         iter: I,
1914     ) -> I::Output {
1915         iter.intern_with(|xs| self.intern_const_list(xs))
1916     }
1917
1918     pub fn intern_const_list(self, cs: &[ty::Const<'tcx>]) -> &'tcx List<ty::Const<'tcx>> {
1919         if cs.is_empty() { List::empty() } else { self._intern_const_list(cs) }
1920     }
1921
1922     pub fn intern_type_list(self, ts: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
1923         if ts.is_empty() {
1924             List::empty()
1925         } else {
1926             // Actually intern type lists as lists of `GenericArg`s.
1927             //
1928             // Transmuting from `Ty<'tcx>` to `GenericArg<'tcx>` is sound
1929             // as explained in ty_slice_as_generic_arg`. With this,
1930             // we guarantee that even when transmuting between `List<Ty<'tcx>>`
1931             // and `List<GenericArg<'tcx>>`, the uniqueness requirement for
1932             // lists is upheld.
1933             let substs = self._intern_substs(ty::subst::ty_slice_as_generic_args(ts));
1934             substs.try_as_type_list().unwrap()
1935         }
1936     }
1937
1938     pub fn intern_substs(self, ts: &[GenericArg<'tcx>]) -> &'tcx List<GenericArg<'tcx>> {
1939         if ts.is_empty() { List::empty() } else { self._intern_substs(ts) }
1940     }
1941
1942     pub fn intern_projs(self, ps: &[ProjectionKind]) -> &'tcx List<ProjectionKind> {
1943         if ps.is_empty() { List::empty() } else { self._intern_projs(ps) }
1944     }
1945
1946     pub fn intern_place_elems(self, ts: &[PlaceElem<'tcx>]) -> &'tcx List<PlaceElem<'tcx>> {
1947         if ts.is_empty() { List::empty() } else { self._intern_place_elems(ts) }
1948     }
1949
1950     pub fn intern_canonical_var_infos(
1951         self,
1952         ts: &[CanonicalVarInfo<'tcx>],
1953     ) -> CanonicalVarInfos<'tcx> {
1954         if ts.is_empty() { List::empty() } else { self._intern_canonical_var_infos(ts) }
1955     }
1956
1957     pub fn intern_bound_variable_kinds(
1958         self,
1959         ts: &[ty::BoundVariableKind],
1960     ) -> &'tcx List<ty::BoundVariableKind> {
1961         if ts.is_empty() { List::empty() } else { self._intern_bound_variable_kinds(ts) }
1962     }
1963
1964     pub fn mk_fn_sig<I>(
1965         self,
1966         inputs: I,
1967         output: I::Item,
1968         c_variadic: bool,
1969         unsafety: hir::Unsafety,
1970         abi: abi::Abi,
1971     ) -> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
1972     where
1973         I: Iterator<Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>,
1974     {
1975         inputs.chain(iter::once(output)).intern_with(|xs| ty::FnSig {
1976             inputs_and_output: self.intern_type_list(xs),
1977             c_variadic,
1978             unsafety,
1979             abi,
1980         })
1981     }
1982
1983     pub fn mk_poly_existential_predicates<
1984         I: InternAs<PolyExistentialPredicate<'tcx>, &'tcx List<PolyExistentialPredicate<'tcx>>>,
1985     >(
1986         self,
1987         iter: I,
1988     ) -> I::Output {
1989         iter.intern_with(|xs| self.intern_poly_existential_predicates(xs))
1990     }
1991
1992     pub fn mk_predicates<I: InternAs<Predicate<'tcx>, &'tcx List<Predicate<'tcx>>>>(
1993         self,
1994         iter: I,
1995     ) -> I::Output {
1996         iter.intern_with(|xs| self.intern_predicates(xs))
1997     }
1998
1999     pub fn mk_type_list<I: InternAs<Ty<'tcx>, &'tcx List<Ty<'tcx>>>>(self, iter: I) -> I::Output {
2000         iter.intern_with(|xs| self.intern_type_list(xs))
2001     }
2002
2003     pub fn mk_substs<I: InternAs<GenericArg<'tcx>, &'tcx List<GenericArg<'tcx>>>>(
2004         self,
2005         iter: I,
2006     ) -> I::Output {
2007         iter.intern_with(|xs| self.intern_substs(xs))
2008     }
2009
2010     pub fn mk_place_elems<I: InternAs<PlaceElem<'tcx>, &'tcx List<PlaceElem<'tcx>>>>(
2011         self,
2012         iter: I,
2013     ) -> I::Output {
2014         iter.intern_with(|xs| self.intern_place_elems(xs))
2015     }
2016
2017     pub fn mk_substs_trait(
2018         self,
2019         self_ty: Ty<'tcx>,
2020         rest: impl IntoIterator<Item = GenericArg<'tcx>>,
2021     ) -> SubstsRef<'tcx> {
2022         self.mk_substs(iter::once(self_ty.into()).chain(rest))
2023     }
2024
2025     pub fn mk_trait_ref(
2026         self,
2027         trait_def_id: DefId,
2028         substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
2029     ) -> ty::TraitRef<'tcx> {
2030         let substs = self.check_substs(trait_def_id, substs);
2031         ty::TraitRef { def_id: trait_def_id, substs, _use_mk_trait_ref_instead: () }
2032     }
2033
2034     pub fn mk_alias_ty(
2035         self,
2036         def_id: DefId,
2037         substs: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
2038     ) -> ty::AliasTy<'tcx> {
2039         let substs = self.check_substs(def_id, substs);
2040         ty::AliasTy { def_id, substs, _use_mk_alias_ty_instead: () }
2041     }
2042
2043     pub fn mk_bound_variable_kinds<
2044         I: InternAs<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>,
2045     >(
2046         self,
2047         iter: I,
2048     ) -> I::Output {
2049         iter.intern_with(|xs| self.intern_bound_variable_kinds(xs))
2050     }
2051
2052     /// Emit a lint at `span` from a lint struct (some type that implements `DecorateLint`,
2053     /// typically generated by `#[derive(LintDiagnostic)]`).
2054     pub fn emit_spanned_lint(
2055         self,
2056         lint: &'static Lint,
2057         hir_id: HirId,
2058         span: impl Into<MultiSpan>,
2059         decorator: impl for<'a> DecorateLint<'a, ()>,
2060     ) {
2061         let msg = decorator.msg();
2062         let (level, src) = self.lint_level_at_node(lint, hir_id);
2063         struct_lint_level(self.sess, lint, level, src, Some(span.into()), msg, |diag| {
2064             decorator.decorate_lint(diag)
2065         })
2066     }
2067
2068     /// Emit a lint at the appropriate level for a hir node, with an associated span.
2069     ///
2070     /// Return value of the `decorate` closure is ignored, see [`struct_lint_level`] for a detailed explanation.
2071     ///
2072     /// [`struct_lint_level`]: rustc_middle::lint::struct_lint_level#decorate-signature
2073     #[rustc_lint_diagnostics]
2074     pub fn struct_span_lint_hir(
2075         self,
2076         lint: &'static Lint,
2077         hir_id: HirId,
2078         span: impl Into<MultiSpan>,
2079         msg: impl Into<DiagnosticMessage>,
2080         decorate: impl for<'a, 'b> FnOnce(
2081             &'b mut DiagnosticBuilder<'a, ()>,
2082         ) -> &'b mut DiagnosticBuilder<'a, ()>,
2083     ) {
2084         let (level, src) = self.lint_level_at_node(lint, hir_id);
2085         struct_lint_level(self.sess, lint, level, src, Some(span.into()), msg, decorate);
2086     }
2087
2088     /// Emit a lint from a lint struct (some type that implements `DecorateLint`, typically
2089     /// generated by `#[derive(LintDiagnostic)]`).
2090     pub fn emit_lint(
2091         self,
2092         lint: &'static Lint,
2093         id: HirId,
2094         decorator: impl for<'a> DecorateLint<'a, ()>,
2095     ) {
2096         self.struct_lint_node(lint, id, decorator.msg(), |diag| decorator.decorate_lint(diag))
2097     }
2098
2099     /// Emit a lint at the appropriate level for a hir node.
2100     ///
2101     /// Return value of the `decorate` closure is ignored, see [`struct_lint_level`] for a detailed explanation.
2102     ///
2103     /// [`struct_lint_level`]: rustc_middle::lint::struct_lint_level#decorate-signature
2104     #[rustc_lint_diagnostics]
2105     pub fn struct_lint_node(
2106         self,
2107         lint: &'static Lint,
2108         id: HirId,
2109         msg: impl Into<DiagnosticMessage>,
2110         decorate: impl for<'a, 'b> FnOnce(
2111             &'b mut DiagnosticBuilder<'a, ()>,
2112         ) -> &'b mut DiagnosticBuilder<'a, ()>,
2113     ) {
2114         let (level, src) = self.lint_level_at_node(lint, id);
2115         struct_lint_level(self.sess, lint, level, src, None, msg, decorate);
2116     }
2117
2118     pub fn in_scope_traits(self, id: HirId) -> Option<&'tcx [TraitCandidate]> {
2119         let map = self.in_scope_traits_map(id.owner)?;
2120         let candidates = map.get(&id.local_id)?;
2121         Some(&*candidates)
2122     }
2123
2124     pub fn named_region(self, id: HirId) -> Option<resolve_lifetime::Region> {
2125         debug!(?id, "named_region");
2126         self.named_region_map(id.owner).and_then(|map| map.get(&id.local_id).cloned())
2127     }
2128
2129     pub fn is_late_bound(self, id: HirId) -> bool {
2130         self.is_late_bound_map(id.owner.def_id).map_or(false, |set| {
2131             let def_id = self.hir().local_def_id(id);
2132             set.contains(&def_id)
2133         })
2134     }
2135
2136     pub fn late_bound_vars(self, id: HirId) -> &'tcx List<ty::BoundVariableKind> {
2137         self.mk_bound_variable_kinds(
2138             self.late_bound_vars_map(id.owner)
2139                 .and_then(|map| map.get(&id.local_id).cloned())
2140                 .unwrap_or_else(|| {
2141                     bug!("No bound vars found for {:?} ({:?})", self.hir().node_to_string(id), id)
2142                 })
2143                 .iter(),
2144         )
2145     }
2146
2147     /// Whether the `def_id` counts as const fn in the current crate, considering all active
2148     /// feature gates
2149     pub fn is_const_fn(self, def_id: DefId) -> bool {
2150         if self.is_const_fn_raw(def_id) {
2151             match self.lookup_const_stability(def_id) {
2152                 Some(stability) if stability.is_const_unstable() => {
2153                     // has a `rustc_const_unstable` attribute, check whether the user enabled the
2154                     // corresponding feature gate.
2155                     self.features()
2156                         .declared_lib_features
2157                         .iter()
2158                         .any(|&(sym, _)| sym == stability.feature)
2159                 }
2160                 // functions without const stability are either stable user written
2161                 // const fn or the user is using feature gates and we thus don't
2162                 // care what they do
2163                 _ => true,
2164             }
2165         } else {
2166             false
2167         }
2168     }
2169
2170     /// Whether the trait impl is marked const. This does not consider stability or feature gates.
2171     pub fn is_const_trait_impl_raw(self, def_id: DefId) -> bool {
2172         let Some(local_def_id) = def_id.as_local() else { return false };
2173         let hir_id = self.local_def_id_to_hir_id(local_def_id);
2174         let node = self.hir().get(hir_id);
2175
2176         matches!(
2177             node,
2178             hir::Node::Item(hir::Item {
2179                 kind: hir::ItemKind::Impl(hir::Impl { constness: hir::Constness::Const, .. }),
2180                 ..
2181             })
2182         )
2183     }
2184 }
2185
2186 impl<'tcx> TyCtxtAt<'tcx> {
2187     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used.
2188     #[track_caller]
2189     pub fn ty_error(self) -> Ty<'tcx> {
2190         self.tcx.ty_error_with_message(self.span, "TyKind::Error constructed but no error reported")
2191     }
2192
2193     /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` with the given `msg to
2194     /// ensure it gets used.
2195     #[track_caller]
2196     pub fn ty_error_with_message(self, msg: &str) -> Ty<'tcx> {
2197         self.tcx.ty_error_with_message(self.span, msg)
2198     }
2199
2200     pub fn mk_trait_ref(
2201         self,
2202         trait_lang_item: LangItem,
2203         substs: impl IntoIterator<Item = impl Into<ty::GenericArg<'tcx>>>,
2204     ) -> ty::TraitRef<'tcx> {
2205         let trait_def_id = self.require_lang_item(trait_lang_item, Some(self.span));
2206         self.tcx.mk_trait_ref(trait_def_id, substs)
2207     }
2208 }
2209
2210 /// Parameter attributes that can only be determined by examining the body of a function instead
2211 /// of just its signature.
2212 ///
2213 /// These can be useful for optimization purposes when a function is directly called. We compute
2214 /// them and store them into the crate metadata so that downstream crates can make use of them.
2215 ///
2216 /// Right now, we only have `read_only`, but `no_capture` and `no_alias` might be useful in the
2217 /// future.
2218 #[derive(Clone, Copy, PartialEq, Debug, Default, TyDecodable, TyEncodable, HashStable)]
2219 pub struct DeducedParamAttrs {
2220     /// The parameter is marked immutable in the function and contains no `UnsafeCell` (i.e. its
2221     /// type is freeze).
2222     pub read_only: bool,
2223 }
2224
2225 // We are comparing types with different invariant lifetimes, so `ptr::eq`
2226 // won't work for us.
2227 fn ptr_eq<T, U>(t: *const T, u: *const U) -> bool {
2228     t as *const () == u as *const ()
2229 }
2230
2231 pub fn provide(providers: &mut ty::query::Providers) {
2232     providers.module_reexports =
2233         |tcx, id| tcx.resolutions(()).reexport_map.get(&id).map(|v| &v[..]);
2234     providers.maybe_unused_trait_imports =
2235         |tcx, ()| &tcx.resolutions(()).maybe_unused_trait_imports;
2236     providers.maybe_unused_extern_crates =
2237         |tcx, ()| &tcx.resolutions(()).maybe_unused_extern_crates[..];
2238     providers.names_imported_by_glob_use = |tcx, id| {
2239         tcx.arena.alloc(tcx.resolutions(()).glob_map.get(&id).cloned().unwrap_or_default())
2240     };
2241
2242     providers.extern_mod_stmt_cnum =
2243         |tcx, id| tcx.resolutions(()).extern_crate_map.get(&id).cloned();
2244     providers.is_panic_runtime = |tcx, cnum| {
2245         assert_eq!(cnum, LOCAL_CRATE);
2246         tcx.sess.contains_name(tcx.hir().krate_attrs(), sym::panic_runtime)
2247     };
2248     providers.is_compiler_builtins = |tcx, cnum| {
2249         assert_eq!(cnum, LOCAL_CRATE);
2250         tcx.sess.contains_name(tcx.hir().krate_attrs(), sym::compiler_builtins)
2251     };
2252     providers.has_panic_handler = |tcx, cnum| {
2253         assert_eq!(cnum, LOCAL_CRATE);
2254         // We want to check if the panic handler was defined in this crate
2255         tcx.lang_items().panic_impl().map_or(false, |did| did.is_local())
2256     };
2257     providers.source_span =
2258         |tcx, def_id| tcx.untracked.source_span.get(def_id).copied().unwrap_or(DUMMY_SP);
2259 }