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