src/librustc_middle/ty/context.rs

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