src/librustc/ty/context.rs

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