compiler/rustc_middle/src/ty/context.rs

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