//! type context book-keeping
-use dep_graph::{DepGraph, DepTrackingMap};
+use dep_graph::DepGraph;
+use dep_graph::{DepNode, DepConstructor};
+use errors::DiagnosticBuilder;
use session::Session;
+use session::config::{BorrowckMode, OutputFilenames, OptLevel};
+use session::config::CrateType::*;
use middle;
-use hir::TraitMap;
-use hir::def::DefMap;
+use hir::{TraitCandidate, HirId, ItemLocalId};
+use hir::def::{Def, Export};
use hir::def_id::{CrateNum, DefId, DefIndex, LOCAL_CRATE};
-use hir::map as ast_map;
-use hir::map::{DefKey, DefPath, DefPathData, DisambiguatedDefPathData};
-use middle::free_region::FreeRegionMap;
-use middle::region::RegionMaps;
-use middle::resolve_lifetime;
+use hir::map as hir_map;
+use hir::map::DefPathHash;
+use lint::{self, Lint};
+use ich::{StableHashingContext, NodeIdHashingMode};
+use infer::canonical::{CanonicalVarInfo, CanonicalVarInfos};
+use infer::outlives::free_region_map::FreeRegionMap;
+use middle::const_val::ConstVal;
+use middle::cstore::{CrateStore, LinkMeta};
+use middle::cstore::EncodedMetadata;
+use middle::lang_items;
+use middle::resolve_lifetime::{self, ObjectLifetimeDefault};
use middle::stability;
-use ty::subst::Substs;
+use mir::{self, Mir, interpret};
+use mir::interpret::{Value, PrimVal};
+use ty::subst::{Kind, Substs, Subst};
+use ty::ReprOptions;
+use ty::Instance;
use traits;
-use ty::{self, TraitRef, Ty, TypeAndMut};
+use traits::{Clause, Clauses, Goal, Goals};
+use ty::{self, Ty, TypeAndMut};
use ty::{TyS, TypeVariants, Slice};
-use ty::{AdtKind, AdtDef, ClosureSubsts, Region};
-use hir::FreevarMap;
-use ty::{BareFnTy, InferTy, ParamTy, ProjectionTy, TraitObject};
+use ty::{AdtKind, AdtDef, ClosureSubsts, GeneratorInterior, Region, Const};
+use ty::{PolyFnSig, InferTy, ParamTy, ProjectionTy, ExistentialPredicate, Predicate};
+use ty::RegionKind;
use ty::{TyVar, TyVid, IntVar, IntVid, FloatVar, FloatVid};
use ty::TypeVariants::*;
-use ty::layout::{Layout, TargetDataLayout};
+use ty::layout::{LayoutDetails, TargetDataLayout};
use ty::maps;
-use util::common::MemoizationMap;
-use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet};
-use util::nodemap::{FnvHashMap, FnvHashSet};
-
-use arena::TypedArena;
+use ty::steal::Steal;
+use ty::BindingMode;
+use ty::CanonicalTy;
+use util::nodemap::{DefIdSet, ItemLocalMap};
+use util::nodemap::{FxHashMap, FxHashSet};
+use rustc_data_structures::accumulate_vec::AccumulateVec;
+use rustc_data_structures::stable_hasher::{HashStable, hash_stable_hashmap,
+ StableHasher, StableHasherResult,
+ StableVec};
+use arena::{TypedArena, SyncDroplessArena};
+use rustc_data_structures::indexed_vec::IndexVec;
+use rustc_data_structures::sync::{Lrc, Lock};
+use std::any::Any;
use std::borrow::Borrow;
-use std::cell::{Cell, RefCell, Ref};
+use std::cmp::Ordering;
+use std::collections::hash_map::{self, Entry};
use std::hash::{Hash, Hasher};
use std::mem;
use std::ops::Deref;
-use std::rc::Rc;
-use syntax::ast::{self, Name, NodeId};
+use std::iter;
+use std::sync::mpsc;
+use std::sync::Arc;
+use rustc_target::spec::abi;
+use syntax::ast::{self, NodeId};
use syntax::attr;
-use syntax::parse::token::{self, keywords};
+use syntax::codemap::MultiSpan;
+use syntax::feature_gate;
+use syntax::symbol::{Symbol, keywords, InternedString};
+use syntax_pos::Span;
use hir;
+pub struct AllArenas<'tcx> {
+ pub global: GlobalArenas<'tcx>,
+ pub interner: SyncDroplessArena,
+}
+
+impl<'tcx> AllArenas<'tcx> {
+ pub fn new() -> Self {
+ AllArenas {
+ global: GlobalArenas::new(),
+ interner: SyncDroplessArena::new(),
+ }
+ }
+}
+
/// Internal storage
-pub struct CtxtArenas<'tcx> {
+pub struct GlobalArenas<'tcx> {
// internings
- type_: TypedArena<TyS<'tcx>>,
- type_list: TypedArena<Vec<Ty<'tcx>>>,
- substs: TypedArena<Substs<'tcx>>,
- bare_fn: TypedArena<BareFnTy<'tcx>>,
- region: TypedArena<Region>,
- stability: TypedArena<attr::Stability>,
- layout: TypedArena<Layout>,
+ layout: TypedArena<LayoutDetails>,
// references
- generics: TypedArena<ty::Generics<'tcx>>,
- trait_defs: TypedArena<ty::TraitDef<'tcx>>,
- adt_defs: TypedArena<ty::AdtDefData<'tcx, 'tcx>>,
-}
-
-impl<'tcx> CtxtArenas<'tcx> {
- pub fn new() -> CtxtArenas<'tcx> {
- CtxtArenas {
- type_: TypedArena::new(),
- type_list: TypedArena::new(),
- substs: TypedArena::new(),
- bare_fn: TypedArena::new(),
- region: TypedArena::new(),
- stability: TypedArena::new(),
- layout: TypedArena::new(),
+ generics: TypedArena<ty::Generics>,
+ trait_def: TypedArena<ty::TraitDef>,
+ adt_def: TypedArena<ty::AdtDef>,
+ steal_mir: TypedArena<Steal<Mir<'tcx>>>,
+ mir: TypedArena<Mir<'tcx>>,
+ tables: TypedArena<ty::TypeckTables<'tcx>>,
+ /// miri allocations
+ const_allocs: TypedArena<interpret::Allocation>,
+}
+impl<'tcx> GlobalArenas<'tcx> {
+ pub fn new() -> GlobalArenas<'tcx> {
+ GlobalArenas {
+ layout: TypedArena::new(),
generics: TypedArena::new(),
- trait_defs: TypedArena::new(),
- adt_defs: TypedArena::new()
+ trait_def: TypedArena::new(),
+ adt_def: TypedArena::new(),
+ steal_mir: TypedArena::new(),
+ mir: TypedArena::new(),
+ tables: TypedArena::new(),
+ const_allocs: TypedArena::new(),
}
}
}
+type InternedSet<'tcx, T> = Lock<FxHashSet<Interned<'tcx, T>>>;
+
pub struct CtxtInterners<'tcx> {
- /// The arenas that types etc are allocated from.
- arenas: &'tcx CtxtArenas<'tcx>,
+ /// The arena that types, regions, etc are allocated from
+ arena: &'tcx SyncDroplessArena,
/// Specifically use a speedy hash algorithm for these hash sets,
/// they're accessed quite often.
- type_: RefCell<FnvHashSet<Interned<'tcx, TyS<'tcx>>>>,
- type_list: RefCell<FnvHashSet<Interned<'tcx, Slice<Ty<'tcx>>>>>,
- substs: RefCell<FnvHashSet<Interned<'tcx, Substs<'tcx>>>>,
- bare_fn: RefCell<FnvHashSet<Interned<'tcx, BareFnTy<'tcx>>>>,
- region: RefCell<FnvHashSet<Interned<'tcx, Region>>>,
- stability: RefCell<FnvHashSet<&'tcx attr::Stability>>,
- layout: RefCell<FnvHashSet<&'tcx Layout>>,
+ type_: InternedSet<'tcx, TyS<'tcx>>,
+ type_list: InternedSet<'tcx, Slice<Ty<'tcx>>>,
+ substs: InternedSet<'tcx, Substs<'tcx>>,
+ canonical_var_infos: InternedSet<'tcx, Slice<CanonicalVarInfo>>,
+ region: InternedSet<'tcx, RegionKind>,
+ existential_predicates: InternedSet<'tcx, Slice<ExistentialPredicate<'tcx>>>,
+ predicates: InternedSet<'tcx, Slice<Predicate<'tcx>>>,
+ const_: InternedSet<'tcx, Const<'tcx>>,
+ clauses: InternedSet<'tcx, Slice<Clause<'tcx>>>,
+ goals: InternedSet<'tcx, Slice<Goal<'tcx>>>,
}
impl<'gcx: 'tcx, 'tcx> CtxtInterners<'tcx> {
- fn new(arenas: &'tcx CtxtArenas<'tcx>) -> CtxtInterners<'tcx> {
+ fn new(arena: &'tcx SyncDroplessArena) -> CtxtInterners<'tcx> {
CtxtInterners {
- arenas: arenas,
- type_: RefCell::new(FnvHashSet()),
- type_list: RefCell::new(FnvHashSet()),
- substs: RefCell::new(FnvHashSet()),
- bare_fn: RefCell::new(FnvHashSet()),
- region: RefCell::new(FnvHashSet()),
- stability: RefCell::new(FnvHashSet()),
- layout: RefCell::new(FnvHashSet())
+ arena,
+ type_: Default::default(),
+ type_list: Default::default(),
+ substs: Default::default(),
+ region: Default::default(),
+ existential_predicates: Default::default(),
+ canonical_var_infos: Default::default(),
+ predicates: Default::default(),
+ const_: Default::default(),
+ clauses: Default::default(),
+ goals: Default::default(),
}
}
-> Ty<'tcx> {
let ty = {
let mut interner = self.type_.borrow_mut();
- let global_interner = global_interners.map(|interners| {
- interners.type_.borrow_mut()
- });
if let Some(&Interned(ty)) = interner.get(&st) {
return ty;
}
- if let Some(ref interner) = global_interner {
- if let Some(&Interned(ty)) = interner.get(&st) {
+ let global_interner = global_interners.map(|interners| {
+ (interners.type_.borrow_mut(), &interners.arena)
+ });
+ if let Some((ref type_, _)) = global_interner {
+ if let Some(&Interned(ty)) = type_.get(&st) {
return ty;
}
}
let flags = super::flags::FlagComputation::for_sty(&st);
let ty_struct = TyS {
sty: st,
- flags: Cell::new(flags.flags),
+ flags: flags.flags,
region_depth: flags.depth,
};
// determine that all contents are in the global tcx.
// See comments on Lift for why we can't use that.
if !flags.flags.intersects(ty::TypeFlags::KEEP_IN_LOCAL_TCX) {
- if let Some(interner) = global_interners {
+ if let Some((mut type_, arena)) = global_interner {
let ty_struct: TyS<'gcx> = unsafe {
mem::transmute(ty_struct)
};
- let ty: Ty<'gcx> = interner.arenas.type_.alloc(ty_struct);
- global_interner.unwrap().insert(Interned(ty));
+ let ty: Ty<'gcx> = arena.alloc(ty_struct);
+ type_.insert(Interned(ty));
return ty;
}
} else {
// Make sure we don't end up with inference
// types/regions in the global tcx.
- if global_interners.is_none() {
+ if global_interner.is_none() {
drop(interner);
bug!("Attempted to intern `{:?}` which contains \
inference types/regions in the global type context",
}
// Don't be &mut TyS.
- let ty: Ty<'tcx> = self.arenas.type_.alloc(ty_struct);
+ let ty: Ty<'tcx> = self.arena.alloc(ty_struct);
interner.insert(Interned(ty));
ty
};
pub i16: Ty<'tcx>,
pub i32: Ty<'tcx>,
pub i64: Ty<'tcx>,
+ pub i128: Ty<'tcx>,
pub usize: Ty<'tcx>,
pub u8: Ty<'tcx>,
pub u16: Ty<'tcx>,
pub u32: Ty<'tcx>,
pub u64: Ty<'tcx>,
+ pub u128: Ty<'tcx>,
pub f32: Ty<'tcx>,
pub f64: Ty<'tcx>,
pub never: Ty<'tcx>,
pub err: Ty<'tcx>,
+
+ pub re_empty: Region<'tcx>,
+ pub re_static: Region<'tcx>,
+ pub re_erased: Region<'tcx>,
+}
+
+pub struct LocalTableInContext<'a, V: 'a> {
+ local_id_root: Option<DefId>,
+ data: &'a ItemLocalMap<V>
+}
+
+/// Validate that the given HirId (respectively its `local_id` part) can be
+/// safely used as a key in the tables of a TypeckTable. For that to be
+/// the case, the HirId must have the same `owner` as all the other IDs in
+/// this table (signified by `local_id_root`). Otherwise the HirId
+/// would be in a different frame of reference and using its `local_id`
+/// would result in lookup errors, or worse, in silently wrong data being
+/// stored/returned.
+fn validate_hir_id_for_typeck_tables(local_id_root: Option<DefId>,
+ hir_id: hir::HirId,
+ mut_access: bool) {
+ if cfg!(debug_assertions) {
+ if let Some(local_id_root) = local_id_root {
+ if hir_id.owner != local_id_root.index {
+ ty::tls::with(|tcx| {
+ let node_id = tcx.hir
+ .definitions()
+ .find_node_for_hir_id(hir_id);
+
+ bug!("node {} with HirId::owner {:?} cannot be placed in \
+ TypeckTables with local_id_root {:?}",
+ tcx.hir.node_to_string(node_id),
+ DefId::local(hir_id.owner),
+ local_id_root)
+ });
+ }
+ } else {
+ // We use "Null Object" TypeckTables in some of the analysis passes.
+ // These are just expected to be empty and their `local_id_root` is
+ // `None`. Therefore we cannot verify whether a given `HirId` would
+ // be a valid key for the given table. Instead we make sure that
+ // nobody tries to write to such a Null Object table.
+ if mut_access {
+ bug!("access to invalid TypeckTables")
+ }
+ }
+ }
+}
+
+impl<'a, V> LocalTableInContext<'a, V> {
+ pub fn contains_key(&self, id: hir::HirId) -> bool {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
+ self.data.contains_key(&id.local_id)
+ }
+
+ pub fn get(&self, id: hir::HirId) -> Option<&V> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
+ self.data.get(&id.local_id)
+ }
+
+ pub fn iter(&self) -> hash_map::Iter<hir::ItemLocalId, V> {
+ self.data.iter()
+ }
+}
+
+impl<'a, V> ::std::ops::Index<hir::HirId> for LocalTableInContext<'a, V> {
+ type Output = V;
+
+ fn index(&self, key: hir::HirId) -> &V {
+ self.get(key).expect("LocalTableInContext: key not found")
+ }
}
-pub struct Tables<'tcx> {
+pub struct LocalTableInContextMut<'a, V: 'a> {
+ local_id_root: Option<DefId>,
+ data: &'a mut ItemLocalMap<V>
+}
+
+impl<'a, V> LocalTableInContextMut<'a, V> {
+ pub fn get_mut(&mut self, id: hir::HirId) -> Option<&mut V> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
+ self.data.get_mut(&id.local_id)
+ }
+
+ pub fn entry(&mut self, id: hir::HirId) -> Entry<hir::ItemLocalId, V> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
+ self.data.entry(id.local_id)
+ }
+
+ pub fn insert(&mut self, id: hir::HirId, val: V) -> Option<V> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
+ self.data.insert(id.local_id, val)
+ }
+
+ pub fn remove(&mut self, id: hir::HirId) -> Option<V> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, true);
+ self.data.remove(&id.local_id)
+ }
+}
+
+#[derive(RustcEncodable, RustcDecodable, Debug)]
+pub struct TypeckTables<'tcx> {
+ /// The HirId::owner all ItemLocalIds in this table are relative to.
+ pub local_id_root: Option<DefId>,
+
+ /// Resolved definitions for `<T>::X` associated paths and
+ /// method calls, including those of overloaded operators.
+ type_dependent_defs: ItemLocalMap<Def>,
+
+ /// Resolved field indices for field accesses in expressions (`S { field }`, `obj.field`)
+ /// or patterns (`S { field }`). The index is often useful by itself, but to learn more
+ /// about the field you also need definition of the variant to which the field
+ /// belongs, but it may not exist if it's a tuple field (`tuple.0`).
+ field_indices: ItemLocalMap<usize>,
+
+ /// Stores the canonicalized types provided by the user. See also `UserAssertTy` statement in
+ /// MIR.
+ user_provided_tys: ItemLocalMap<CanonicalTy<'tcx>>,
+
/// Stores the types for various nodes in the AST. Note that this table
/// is not guaranteed to be populated until after typeck. See
/// typeck::check::fn_ctxt for details.
- pub node_types: NodeMap<Ty<'tcx>>,
+ node_types: ItemLocalMap<Ty<'tcx>>,
/// Stores the type parameters which were substituted to obtain the type
/// of this node. This only applies to nodes that refer to entities
/// parameterized by type parameters, such as generic fns, types, or
/// other items.
- pub item_substs: NodeMap<ty::ItemSubsts<'tcx>>,
+ node_substs: ItemLocalMap<&'tcx Substs<'tcx>>,
- pub adjustments: NodeMap<ty::adjustment::AutoAdjustment<'tcx>>,
+ adjustments: ItemLocalMap<Vec<ty::adjustment::Adjustment<'tcx>>>,
- pub method_map: ty::MethodMap<'tcx>,
+ /// Stores the actual binding mode for all instances of hir::BindingAnnotation.
+ pat_binding_modes: ItemLocalMap<BindingMode>,
+
+ /// Stores the types which were implicitly dereferenced in pattern binding modes
+ /// for later usage in HAIR lowering. For example,
+ ///
+ /// ```
+ /// match &&Some(5i32) {
+ /// Some(n) => {},
+ /// _ => {},
+ /// }
+ /// ```
+ /// leads to a `vec![&&Option<i32>, &Option<i32>]`. Empty vectors are not stored.
+ ///
+ /// See:
+ /// https://github.com/rust-lang/rfcs/blob/master/text/2005-match-ergonomics.md#definitions
+ pat_adjustments: ItemLocalMap<Vec<Ty<'tcx>>>,
/// Borrows
pub upvar_capture_map: ty::UpvarCaptureMap<'tcx>,
- /// Records the type of each closure. The def ID is the ID of the
- /// expression defining the closure.
- pub closure_tys: DefIdMap<ty::ClosureTy<'tcx>>,
-
- /// Records the type of each closure. The def ID is the ID of the
- /// expression defining the closure.
- pub closure_kinds: DefIdMap<ty::ClosureKind>,
+ /// Records the reasons that we picked the kind of each closure;
+ /// not all closures are present in the map.
+ closure_kind_origins: ItemLocalMap<(Span, ast::Name)>,
/// For each fn, records the "liberated" types of its arguments
/// and return type. Liberated means that all bound regions
/// (including late-bound regions) are replaced with free
/// equivalents. This table is not used in trans (since regions
/// are erased there) and hence is not serialized to metadata.
- pub liberated_fn_sigs: NodeMap<ty::FnSig<'tcx>>,
+ liberated_fn_sigs: ItemLocalMap<ty::FnSig<'tcx>>,
/// For each FRU expression, record the normalized types of the fields
/// of the struct - this is needed because it is non-trivial to
/// normalize while preserving regions. This table is used only in
/// MIR construction and hence is not serialized to metadata.
- pub fru_field_types: NodeMap<Vec<Ty<'tcx>>>
+ fru_field_types: ItemLocalMap<Vec<Ty<'tcx>>>,
+
+ /// Maps a cast expression to its kind. This is keyed on the
+ /// *from* expression of the cast, not the cast itself.
+ cast_kinds: ItemLocalMap<ty::cast::CastKind>,
+
+ /// Set of trait imports actually used in the method resolution.
+ /// This is used for warning unused imports. During type
+ /// checking, this `Lrc` should not be cloned: it must have a ref-count
+ /// of 1 so that we can insert things into the set mutably.
+ pub used_trait_imports: Lrc<DefIdSet>,
+
+ /// If any errors occurred while type-checking this body,
+ /// this field will be set to `true`.
+ pub tainted_by_errors: bool,
+
+ /// Stores the free-region relationships that were deduced from
+ /// its where clauses and parameter types. These are then
+ /// read-again by borrowck.
+ pub free_region_map: FreeRegionMap<'tcx>,
}
-impl<'a, 'gcx, 'tcx> Tables<'tcx> {
- pub fn empty() -> Tables<'tcx> {
- Tables {
- node_types: FnvHashMap(),
- item_substs: NodeMap(),
- adjustments: NodeMap(),
- method_map: FnvHashMap(),
- upvar_capture_map: FnvHashMap(),
- closure_tys: DefIdMap(),
- closure_kinds: DefIdMap(),
- liberated_fn_sigs: NodeMap(),
- fru_field_types: NodeMap()
+impl<'tcx> TypeckTables<'tcx> {
+ pub fn empty(local_id_root: Option<DefId>) -> TypeckTables<'tcx> {
+ TypeckTables {
+ local_id_root,
+ type_dependent_defs: ItemLocalMap(),
+ field_indices: ItemLocalMap(),
+ user_provided_tys: ItemLocalMap(),
+ node_types: ItemLocalMap(),
+ node_substs: ItemLocalMap(),
+ adjustments: ItemLocalMap(),
+ pat_binding_modes: ItemLocalMap(),
+ pat_adjustments: ItemLocalMap(),
+ upvar_capture_map: FxHashMap(),
+ closure_kind_origins: ItemLocalMap(),
+ liberated_fn_sigs: ItemLocalMap(),
+ fru_field_types: ItemLocalMap(),
+ cast_kinds: ItemLocalMap(),
+ used_trait_imports: Lrc::new(DefIdSet()),
+ tainted_by_errors: false,
+ free_region_map: FreeRegionMap::new(),
+ }
+ }
+
+ /// Returns the final resolution of a `QPath` in an `Expr` or `Pat` node.
+ pub fn qpath_def(&self, qpath: &hir::QPath, id: hir::HirId) -> Def {
+ match *qpath {
+ hir::QPath::Resolved(_, ref path) => path.def,
+ hir::QPath::TypeRelative(..) => {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
+ self.type_dependent_defs.get(&id.local_id).cloned().unwrap_or(Def::Err)
+ }
+ }
+ }
+
+ pub fn type_dependent_defs(&self) -> LocalTableInContext<Def> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.type_dependent_defs
+ }
+ }
+
+ pub fn type_dependent_defs_mut(&mut self) -> LocalTableInContextMut<Def> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.type_dependent_defs
+ }
+ }
+
+ pub fn field_indices(&self) -> LocalTableInContext<usize> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.field_indices
+ }
+ }
+
+ pub fn field_indices_mut(&mut self) -> LocalTableInContextMut<usize> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.field_indices
+ }
+ }
+
+ pub fn user_provided_tys(&self) -> LocalTableInContext<CanonicalTy<'tcx>> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.user_provided_tys
+ }
+ }
+
+ pub fn user_provided_tys_mut(&mut self) -> LocalTableInContextMut<CanonicalTy<'tcx>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.user_provided_tys
+ }
+ }
+
+ pub fn node_types(&self) -> LocalTableInContext<Ty<'tcx>> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.node_types
+ }
+ }
+
+ pub fn node_types_mut(&mut self) -> LocalTableInContextMut<Ty<'tcx>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.node_types
+ }
+ }
+
+ pub fn node_id_to_type(&self, id: hir::HirId) -> Ty<'tcx> {
+ match self.node_id_to_type_opt(id) {
+ Some(ty) => ty,
+ None => {
+ bug!("node_id_to_type: no type for node `{}`",
+ tls::with(|tcx| {
+ let id = tcx.hir.definitions().find_node_for_hir_id(id);
+ tcx.hir.node_to_string(id)
+ }))
+ }
+ }
+ }
+
+ pub fn node_id_to_type_opt(&self, id: hir::HirId) -> Option<Ty<'tcx>> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
+ self.node_types.get(&id.local_id).cloned()
+ }
+
+ pub fn node_substs_mut(&mut self) -> LocalTableInContextMut<&'tcx Substs<'tcx>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.node_substs
+ }
+ }
+
+ pub fn node_substs(&self, id: hir::HirId) -> &'tcx Substs<'tcx> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
+ self.node_substs.get(&id.local_id).cloned().unwrap_or(Substs::empty())
+ }
+
+ pub fn node_substs_opt(&self, id: hir::HirId) -> Option<&'tcx Substs<'tcx>> {
+ validate_hir_id_for_typeck_tables(self.local_id_root, id, false);
+ self.node_substs.get(&id.local_id).cloned()
+ }
+
+ // Returns the type of a pattern as a monotype. Like @expr_ty, this function
+ // doesn't provide type parameter substitutions.
+ pub fn pat_ty(&self, pat: &hir::Pat) -> Ty<'tcx> {
+ self.node_id_to_type(pat.hir_id)
+ }
+
+ pub fn pat_ty_opt(&self, pat: &hir::Pat) -> Option<Ty<'tcx>> {
+ self.node_id_to_type_opt(pat.hir_id)
+ }
+
+ // Returns the type of an expression as a monotype.
+ //
+ // NB (1): This is the PRE-ADJUSTMENT TYPE for the expression. That is, in
+ // some cases, we insert `Adjustment` annotations such as auto-deref or
+ // auto-ref. The type returned by this function does not consider such
+ // adjustments. See `expr_ty_adjusted()` instead.
+ //
+ // NB (2): This type doesn't provide type parameter substitutions; e.g. if you
+ // ask for the type of "id" in "id(3)", it will return "fn(&isize) -> isize"
+ // instead of "fn(ty) -> T with T = isize".
+ pub fn expr_ty(&self, expr: &hir::Expr) -> Ty<'tcx> {
+ self.node_id_to_type(expr.hir_id)
+ }
+
+ pub fn expr_ty_opt(&self, expr: &hir::Expr) -> Option<Ty<'tcx>> {
+ self.node_id_to_type_opt(expr.hir_id)
+ }
+
+ pub fn adjustments(&self) -> LocalTableInContext<Vec<ty::adjustment::Adjustment<'tcx>>> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.adjustments
+ }
+ }
+
+ pub fn adjustments_mut(&mut self)
+ -> LocalTableInContextMut<Vec<ty::adjustment::Adjustment<'tcx>>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.adjustments
+ }
+ }
+
+ pub fn expr_adjustments(&self, expr: &hir::Expr)
+ -> &[ty::adjustment::Adjustment<'tcx>] {
+ validate_hir_id_for_typeck_tables(self.local_id_root, expr.hir_id, false);
+ self.adjustments.get(&expr.hir_id.local_id).map_or(&[], |a| &a[..])
+ }
+
+ /// Returns the type of `expr`, considering any `Adjustment`
+ /// entry recorded for that expression.
+ pub fn expr_ty_adjusted(&self, expr: &hir::Expr) -> Ty<'tcx> {
+ self.expr_adjustments(expr)
+ .last()
+ .map_or_else(|| self.expr_ty(expr), |adj| adj.target)
+ }
+
+ pub fn expr_ty_adjusted_opt(&self, expr: &hir::Expr) -> Option<Ty<'tcx>> {
+ self.expr_adjustments(expr)
+ .last()
+ .map(|adj| adj.target)
+ .or_else(|| self.expr_ty_opt(expr))
+ }
+
+ pub fn is_method_call(&self, expr: &hir::Expr) -> bool {
+ // Only paths and method calls/overloaded operators have
+ // entries in type_dependent_defs, ignore the former here.
+ if let hir::ExprPath(_) = expr.node {
+ return false;
+ }
+
+ match self.type_dependent_defs().get(expr.hir_id) {
+ Some(&Def::Method(_)) => true,
+ _ => false
}
}
+
+ pub fn pat_binding_modes(&self) -> LocalTableInContext<BindingMode> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.pat_binding_modes
+ }
+ }
+
+ pub fn pat_binding_modes_mut(&mut self)
+ -> LocalTableInContextMut<BindingMode> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.pat_binding_modes
+ }
+ }
+
+ pub fn pat_adjustments(&self) -> LocalTableInContext<Vec<Ty<'tcx>>> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.pat_adjustments,
+ }
+ }
+
+ pub fn pat_adjustments_mut(&mut self)
+ -> LocalTableInContextMut<Vec<Ty<'tcx>>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.pat_adjustments,
+ }
+ }
+
+ pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> ty::UpvarCapture<'tcx> {
+ self.upvar_capture_map[&upvar_id]
+ }
+
+ pub fn closure_kind_origins(&self) -> LocalTableInContext<(Span, ast::Name)> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.closure_kind_origins
+ }
+ }
+
+ pub fn closure_kind_origins_mut(&mut self) -> LocalTableInContextMut<(Span, ast::Name)> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.closure_kind_origins
+ }
+ }
+
+ pub fn liberated_fn_sigs(&self) -> LocalTableInContext<ty::FnSig<'tcx>> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.liberated_fn_sigs
+ }
+ }
+
+ pub fn liberated_fn_sigs_mut(&mut self) -> LocalTableInContextMut<ty::FnSig<'tcx>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.liberated_fn_sigs
+ }
+ }
+
+ pub fn fru_field_types(&self) -> LocalTableInContext<Vec<Ty<'tcx>>> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.fru_field_types
+ }
+ }
+
+ pub fn fru_field_types_mut(&mut self) -> LocalTableInContextMut<Vec<Ty<'tcx>>> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.fru_field_types
+ }
+ }
+
+ pub fn cast_kinds(&self) -> LocalTableInContext<ty::cast::CastKind> {
+ LocalTableInContext {
+ local_id_root: self.local_id_root,
+ data: &self.cast_kinds
+ }
+ }
+
+ pub fn cast_kinds_mut(&mut self) -> LocalTableInContextMut<ty::cast::CastKind> {
+ LocalTableInContextMut {
+ local_id_root: self.local_id_root,
+ data: &mut self.cast_kinds
+ }
+ }
+}
+
+impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for TypeckTables<'gcx> {
+ fn hash_stable<W: StableHasherResult>(&self,
+ hcx: &mut StableHashingContext<'a>,
+ hasher: &mut StableHasher<W>) {
+ let ty::TypeckTables {
+ local_id_root,
+ ref type_dependent_defs,
+ ref field_indices,
+ ref user_provided_tys,
+ ref node_types,
+ ref node_substs,
+ ref adjustments,
+ ref pat_binding_modes,
+ ref pat_adjustments,
+ ref upvar_capture_map,
+ ref closure_kind_origins,
+ ref liberated_fn_sigs,
+ ref fru_field_types,
+
+ ref cast_kinds,
+
+ ref used_trait_imports,
+ tainted_by_errors,
+ ref free_region_map,
+ } = *self;
+
+ hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
+ type_dependent_defs.hash_stable(hcx, hasher);
+ field_indices.hash_stable(hcx, hasher);
+ user_provided_tys.hash_stable(hcx, hasher);
+ node_types.hash_stable(hcx, hasher);
+ node_substs.hash_stable(hcx, hasher);
+ adjustments.hash_stable(hcx, hasher);
+ pat_binding_modes.hash_stable(hcx, hasher);
+ pat_adjustments.hash_stable(hcx, hasher);
+ hash_stable_hashmap(hcx, hasher, upvar_capture_map, |up_var_id, hcx| {
+ let ty::UpvarId {
+ var_id,
+ closure_expr_id
+ } = *up_var_id;
+
+ let local_id_root =
+ local_id_root.expect("trying to hash invalid TypeckTables");
+
+ let var_owner_def_id = DefId {
+ krate: local_id_root.krate,
+ index: var_id.owner,
+ };
+ let closure_def_id = DefId {
+ krate: local_id_root.krate,
+ index: closure_expr_id.to_def_id().index,
+ };
+ (hcx.def_path_hash(var_owner_def_id),
+ var_id.local_id,
+ hcx.def_path_hash(closure_def_id))
+ });
+
+ closure_kind_origins.hash_stable(hcx, hasher);
+ liberated_fn_sigs.hash_stable(hcx, hasher);
+ fru_field_types.hash_stable(hcx, hasher);
+ cast_kinds.hash_stable(hcx, hasher);
+ used_trait_imports.hash_stable(hcx, hasher);
+ tainted_by_errors.hash_stable(hcx, hasher);
+ free_region_map.hash_stable(hcx, hasher);
+ })
+ }
}
impl<'tcx> CommonTypes<'tcx> {
fn new(interners: &CtxtInterners<'tcx>) -> CommonTypes<'tcx> {
let mk = |sty| interners.intern_ty(sty, None);
+ let mk_region = |r| {
+ if let Some(r) = interners.region.borrow().get(&r) {
+ return r.0;
+ }
+ let r = interners.arena.alloc(r);
+ interners.region.borrow_mut().insert(Interned(r));
+ &*r
+ };
CommonTypes {
bool: mk(TyBool),
char: mk(TyChar),
never: mk(TyNever),
err: mk(TyError),
- isize: mk(TyInt(ast::IntTy::Is)),
+ isize: mk(TyInt(ast::IntTy::Isize)),
i8: mk(TyInt(ast::IntTy::I8)),
i16: mk(TyInt(ast::IntTy::I16)),
i32: mk(TyInt(ast::IntTy::I32)),
i64: mk(TyInt(ast::IntTy::I64)),
- usize: mk(TyUint(ast::UintTy::Us)),
+ i128: mk(TyInt(ast::IntTy::I128)),
+ usize: mk(TyUint(ast::UintTy::Usize)),
u8: mk(TyUint(ast::UintTy::U8)),
u16: mk(TyUint(ast::UintTy::U16)),
u32: mk(TyUint(ast::UintTy::U32)),
u64: mk(TyUint(ast::UintTy::U64)),
+ u128: mk(TyUint(ast::UintTy::U128)),
f32: mk(TyFloat(ast::FloatTy::F32)),
f64: mk(TyFloat(ast::FloatTy::F64)),
+
+ re_empty: mk_region(RegionKind::ReEmpty),
+ re_static: mk_region(RegionKind::ReStatic),
+ re_erased: mk_region(RegionKind::ReErased),
}
}
}
-/// The data structure to keep track of all the information that typechecker
-/// generates so that so that it can be reused and doesn't have to be redone
-/// later on.
+/// The central data structure of the compiler. It stores references
+/// to the various **arenas** and also houses the results of the
+/// various **compiler queries** that have been performed. See the
+/// [rustc guide] for more details.
+///
+/// [rustc guide]: https://rust-lang-nursery.github.io/rustc-guide/ty.html
#[derive(Copy, Clone)]
pub struct TyCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
gcx: &'a GlobalCtxt<'gcx>,
}
pub struct GlobalCtxt<'tcx> {
+ global_arenas: &'tcx GlobalArenas<'tcx>,
global_interners: CtxtInterners<'tcx>,
- pub specializes_cache: RefCell<traits::SpecializesCache>,
+ cstore: &'tcx dyn CrateStore,
+
+ pub sess: &'tcx Session,
pub dep_graph: DepGraph,
+ /// This provides access to the incr. comp. on-disk cache for query results.
+ /// Do not access this directly. It is only meant to be used by
+ /// `DepGraph::try_mark_green()` and the query infrastructure in `ty::maps`.
+ pub(crate) on_disk_query_result_cache: maps::OnDiskCache<'tcx>,
+
/// Common types, pre-interned for your convenience.
pub types: CommonTypes<'tcx>,
- pub sess: &'tcx Session,
-
- /// Map from path id to the results from resolve; generated
- /// initially by resolve and updated during typeck in some cases
- /// (e.g., UFCS paths)
- pub def_map: RefCell<DefMap>,
-
/// Map indicating what traits are in scope for places where this
/// is relevant; generated by resolve.
- pub trait_map: TraitMap,
-
- pub named_region_map: resolve_lifetime::NamedRegionMap,
-
- pub region_maps: RegionMaps,
+ trait_map: FxHashMap<DefIndex,
+ Lrc<FxHashMap<ItemLocalId,
+ Lrc<StableVec<TraitCandidate>>>>>,
- // For each fn declared in the local crate, type check stores the
- // free-region relationships that were deduced from its where
- // clauses and parameter types. These are then read-again by
- // borrowck. (They are not used during trans, and hence are not
- // serialized or needed for cross-crate fns.)
- free_region_maps: RefCell<NodeMap<FreeRegionMap>>,
- // FIXME: jroesch make this a refcell
+ /// Export map produced by name resolution.
+ export_map: FxHashMap<DefId, Lrc<Vec<Export>>>,
- pub tables: RefCell<Tables<'tcx>>,
+ pub hir: hir_map::Map<'tcx>,
- /// Maps from a trait item to the trait item "descriptor"
- pub impl_or_trait_items: RefCell<DepTrackingMap<maps::ImplOrTraitItems<'tcx>>>,
+ /// A map from DefPathHash -> DefId. Includes DefIds from the local crate
+ /// as well as all upstream crates. Only populated in incremental mode.
+ pub def_path_hash_to_def_id: Option<FxHashMap<DefPathHash, DefId>>,
- /// Maps from an impl/trait def-id to a list of the def-ids of its items
- pub impl_or_trait_item_def_ids: RefCell<DepTrackingMap<maps::ImplOrTraitItemDefIds<'tcx>>>,
-
- /// A cache for the trait_items() routine; note that the routine
- /// itself pushes the `TraitItems` dependency node.
- trait_items_cache: RefCell<DepTrackingMap<maps::TraitItems<'tcx>>>,
-
- pub impl_trait_refs: RefCell<DepTrackingMap<maps::ImplTraitRefs<'tcx>>>,
- pub trait_defs: RefCell<DepTrackingMap<maps::TraitDefs<'tcx>>>,
- pub adt_defs: RefCell<DepTrackingMap<maps::AdtDefs<'tcx>>>,
-
- /// Maps from the def-id of an item (trait/struct/enum/fn) to its
- /// associated generics and predicates.
- pub generics: RefCell<DepTrackingMap<maps::Generics<'tcx>>>,
- pub predicates: RefCell<DepTrackingMap<maps::Predicates<'tcx>>>,
-
- /// Maps from the def-id of a trait to the list of
- /// super-predicates. This is a subset of the full list of
- /// predicates. We store these in a separate map because we must
- /// evaluate them even during type conversion, often before the
- /// full predicates are available (note that supertraits have
- /// additional acyclicity requirements).
- pub super_predicates: RefCell<DepTrackingMap<maps::Predicates<'tcx>>>,
-
- pub map: ast_map::Map<'tcx>,
+ pub maps: maps::Maps<'tcx>,
// Records the free variables refrenced by every closure
// expression. Do not track deps for this, just recompute it from
// scratch every time.
- pub freevars: RefCell<FreevarMap>,
+ freevars: FxHashMap<DefId, Lrc<Vec<hir::Freevar>>>,
- pub maybe_unused_trait_imports: NodeSet,
+ maybe_unused_trait_imports: FxHashSet<DefId>,
- // Records the type of every item.
- pub tcache: RefCell<DepTrackingMap<maps::Tcache<'tcx>>>,
+ maybe_unused_extern_crates: Vec<(DefId, Span)>,
// Internal cache for metadata decoding. No need to track deps on this.
- pub rcache: RefCell<FnvHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
-
- // Cache for the type-contents routine. FIXME -- track deps?
- pub tc_cache: RefCell<FnvHashMap<Ty<'tcx>, ty::contents::TypeContents>>,
-
- // FIXME no dep tracking, but we should be able to remove this
- pub ty_param_defs: RefCell<NodeMap<ty::TypeParameterDef<'tcx>>>,
-
- // FIXME dep tracking -- should be harmless enough
- pub normalized_cache: RefCell<FnvHashMap<Ty<'tcx>, Ty<'tcx>>>,
-
- pub lang_items: middle::lang_items::LanguageItems,
-
- /// Maps from def-id of a type or region parameter to its
- /// (inferred) variance.
- pub item_variance_map: RefCell<DepTrackingMap<maps::ItemVariances<'tcx>>>,
-
- /// True if the variance has been computed yet; false otherwise.
- pub variance_computed: Cell<bool>,
-
- /// Maps a DefId of a type to a list of its inherent impls.
- /// Contains implementations of methods that are inherent to a type.
- /// Methods in these implementations don't need to be exported.
- pub inherent_impls: RefCell<DepTrackingMap<maps::InherentImpls<'tcx>>>,
-
- /// Set of used unsafe nodes (functions or blocks). Unsafe nodes not
- /// present in this set can be warned about.
- pub used_unsafe: RefCell<NodeSet>,
-
- /// Set of nodes which mark locals as mutable which end up getting used at
- /// some point. Local variable definitions not in this set can be warned
- /// about.
- pub used_mut_nodes: RefCell<NodeSet>,
-
- /// Set of trait imports actually used in the method resolution.
- /// This is used for warning unused imports.
- pub used_trait_imports: RefCell<NodeSet>,
-
- /// The set of external nominal types whose implementations have been read.
- /// This is used for lazy resolution of methods.
- pub populated_external_types: RefCell<DefIdSet>,
-
- /// The set of external primitive types whose implementations have been read.
- /// FIXME(arielb1): why is this separate from populated_external_types?
- pub populated_external_primitive_impls: RefCell<DefIdSet>,
-
- /// Cache used by const_eval when decoding external constants.
- /// Contains `None` when the constant has been fetched but doesn't exist.
- /// Constains `Some(expr_id, type)` otherwise.
- /// `type` is `None` in case it's not a primitive type
- pub extern_const_statics: RefCell<DefIdMap<Option<(NodeId, Option<Ty<'tcx>>)>>>,
- /// Cache used by const_eval when decoding extern const fns
- pub extern_const_fns: RefCell<DefIdMap<NodeId>>,
-
- /// Maps any item's def-id to its stability index.
- pub stability: RefCell<stability::Index<'tcx>>,
+ pub rcache: Lock<FxHashMap<ty::CReaderCacheKey, Ty<'tcx>>>,
/// Caches the results of trait selection. This cache is used
/// for things that do not have to do with the parameters in scope.
/// Merge this with `selection_cache`?
pub evaluation_cache: traits::EvaluationCache<'tcx>,
- /// A set of predicates that have been fulfilled *somewhere*.
- /// This is used to avoid duplicate work. Predicates are only
- /// added to this set when they mention only "global" names
- /// (i.e., no type or lifetime parameters).
- pub fulfilled_predicates: RefCell<traits::GlobalFulfilledPredicates<'tcx>>,
+ /// The definite name of the current crate after taking into account
+ /// attributes, commandline parameters, etc.
+ pub crate_name: Symbol,
- /// Caches the representation hints for struct definitions.
- repr_hint_cache: RefCell<DepTrackingMap<maps::ReprHints<'tcx>>>,
+ /// Data layout specification for the current target.
+ pub data_layout: TargetDataLayout,
- /// Maps Expr NodeId's to their constant qualification.
- pub const_qualif_map: RefCell<NodeMap<middle::const_qualif::ConstQualif>>,
+ stability_interner: Lock<FxHashSet<&'tcx attr::Stability>>,
- /// Caches CoerceUnsized kinds for impls on custom types.
- pub custom_coerce_unsized_kinds: RefCell<DefIdMap<ty::adjustment::CustomCoerceUnsized>>,
+ pub interpret_interner: InterpretInterner<'tcx>,
- /// Maps a cast expression to its kind. This is keyed on the
- /// *from* expression of the cast, not the cast itself.
- pub cast_kinds: RefCell<NodeMap<ty::cast::CastKind>>,
+ layout_interner: Lock<FxHashSet<&'tcx LayoutDetails>>,
- /// Maps Fn items to a collection of fragment infos.
- ///
- /// The main goal is to identify data (each of which may be moved
- /// or assigned) whose subparts are not moved nor assigned
- /// (i.e. their state is *unfragmented*) and corresponding ast
- /// nodes where the path to that data is moved or assigned.
- ///
- /// In the long term, unfragmented values will have their
- /// destructor entirely driven by a single stack-local drop-flag,
- /// and their parents, the collections of the unfragmented values
- /// (or more simply, "fragmented values"), are mapped to the
- /// corresponding collections of stack-local drop-flags.
+ /// A general purpose channel to throw data out the back towards LLVM worker
+ /// threads.
///
- /// (However, in the short term that is not the case; e.g. some
- /// unfragmented paths still need to be zeroed, namely when they
- /// reference parent data from an outer scope that was not
- /// entirely moved, and therefore that needs to be zeroed so that
- /// we do not get double-drop when we hit the end of the parent
- /// scope.)
- ///
- /// Also: currently the table solely holds keys for node-ids of
- /// unfragmented values (see `FragmentInfo` enum definition), but
- /// longer-term we will need to also store mappings from
- /// fragmented data to the set of unfragmented pieces that
- /// constitute it.
- pub fragment_infos: RefCell<DefIdMap<Vec<ty::FragmentInfo>>>,
+ /// This is intended to only get used during the trans phase of the compiler
+ /// when satisfying the query for a particular codegen unit. Internally in
+ /// the query it'll send data along this channel to get processed later.
+ pub tx_to_llvm_workers: Lock<mpsc::Sender<Box<dyn Any + Send>>>,
- /// The definite name of the current crate after taking into account
- /// attributes, commandline parameters, etc.
- pub crate_name: token::InternedString,
+ output_filenames: Arc<OutputFilenames>,
+}
- /// Data layout specification for the current target.
- pub data_layout: TargetDataLayout,
+/// Everything needed to efficiently work with interned allocations
+#[derive(Debug, Default)]
+pub struct InterpretInterner<'tcx> {
+ inner: Lock<InterpretInternerInner<'tcx>>,
+}
+
+#[derive(Debug, Default)]
+struct InterpretInternerInner<'tcx> {
+ /// Stores the value of constants (and deduplicates the actual memory)
+ allocs: FxHashSet<&'tcx interpret::Allocation>,
+
+ /// Allows obtaining function instance handles via a unique identifier
+ functions: FxHashMap<interpret::AllocId, Instance<'tcx>>,
+
+ /// Inverse map of `interpret_functions`.
+ /// Used so we don't allocate a new pointer every time we need one
+ function_cache: FxHashMap<Instance<'tcx>, interpret::AllocId>,
+
+ /// Allows obtaining const allocs via a unique identifier
+ alloc_by_id: FxHashMap<interpret::AllocId, &'tcx interpret::Allocation>,
- /// Cache for layouts computed from types.
- pub layout_cache: RefCell<FnvHashMap<Ty<'tcx>, &'tcx Layout>>,
+ /// Allows obtaining static def ids via a unique id
+ statics: FxHashMap<interpret::AllocId, DefId>,
- /// Used to prevent layout from recursing too deeply.
- pub layout_depth: Cell<usize>,
+ /// The AllocId to assign to the next new regular allocation.
+ /// Always incremented, never gets smaller.
+ next_id: interpret::AllocId,
- /// Map from function to the `#[derive]` mode that it's defining. Only used
- /// by `rustc-macro` crates.
- pub derive_macros: RefCell<NodeMap<token::InternedString>>,
+ /// Inverse map of `statics`
+ /// Used so we don't allocate a new pointer every time we need one
+ static_cache: FxHashMap<DefId, interpret::AllocId>,
+
+ /// A cache for basic byte allocations keyed by their contents. This is used to deduplicate
+ /// allocations for string and bytestring literals.
+ literal_alloc_cache: FxHashMap<Vec<u8>, interpret::AllocId>,
}
-impl<'tcx> GlobalCtxt<'tcx> {
- /// Get the global TyCtxt.
- pub fn global_tcx<'a>(&'a self) -> TyCtxt<'a, 'tcx, 'tcx> {
- TyCtxt {
- gcx: self,
- interners: &self.global_interners
+impl<'tcx> InterpretInterner<'tcx> {
+ pub fn create_fn_alloc(&self, instance: Instance<'tcx>) -> interpret::AllocId {
+ if let Some(&alloc_id) = self.inner.borrow().function_cache.get(&instance) {
+ return alloc_id;
+ }
+ let id = self.reserve();
+ debug!("creating fn ptr: {}", id);
+ let mut inner = self.inner.borrow_mut();
+ inner.functions.insert(id, instance);
+ inner.function_cache.insert(instance, id);
+ id
+ }
+
+ pub fn get_fn(
+ &self,
+ id: interpret::AllocId,
+ ) -> Option<Instance<'tcx>> {
+ self.inner.borrow().functions.get(&id).cloned()
+ }
+
+ pub fn get_alloc(
+ &self,
+ id: interpret::AllocId,
+ ) -> Option<&'tcx interpret::Allocation> {
+ self.inner.borrow().alloc_by_id.get(&id).cloned()
+ }
+
+ pub fn cache_static(
+ &self,
+ static_id: DefId,
+ ) -> interpret::AllocId {
+ if let Some(alloc_id) = self.inner.borrow().static_cache.get(&static_id).cloned() {
+ return alloc_id;
}
+ let alloc_id = self.reserve();
+ let mut inner = self.inner.borrow_mut();
+ inner.static_cache.insert(static_id, alloc_id);
+ inner.statics.insert(alloc_id, static_id);
+ alloc_id
+ }
+
+ pub fn get_static(
+ &self,
+ ptr: interpret::AllocId,
+ ) -> Option<DefId> {
+ self.inner.borrow().statics.get(&ptr).cloned()
+ }
+
+ pub fn intern_at_reserved(
+ &self,
+ id: interpret::AllocId,
+ alloc: &'tcx interpret::Allocation,
+ ) {
+ if let Some(old) = self.inner.borrow_mut().alloc_by_id.insert(id, alloc) {
+ bug!("tried to intern allocation at {}, but was already existing as {:#?}", id, old);
+ }
+ }
+
+ /// obtains a new allocation ID that can be referenced but does not
+ /// yet have an allocation backing it.
+ pub fn reserve(
+ &self,
+ ) -> interpret::AllocId {
+ let mut inner = self.inner.borrow_mut();
+ let next = inner.next_id;
+ inner.next_id.0 = inner.next_id.0
+ .checked_add(1)
+ .expect("You overflowed a u64 by incrementing by 1... \
+ You've just earned yourself a free drink if we ever meet. \
+ Seriously, how did you do that?!");
+ next
}
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
- pub fn crate_name(self, cnum: CrateNum) -> token::InternedString {
- if cnum == LOCAL_CRATE {
- self.crate_name.clone()
- } else {
- self.sess.cstore.crate_name(cnum)
+ /// Get the global TyCtxt.
+ #[inline]
+ pub fn global_tcx(self) -> TyCtxt<'a, 'gcx, 'gcx> {
+ TyCtxt {
+ gcx: self.gcx,
+ interners: &self.gcx.global_interners,
}
}
- pub fn original_crate_name(self, cnum: CrateNum) -> token::InternedString {
- if cnum == LOCAL_CRATE {
- self.crate_name.clone()
+ pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
+ self.global_arenas.generics.alloc(generics)
+ }
+
+ pub fn alloc_steal_mir(self, mir: Mir<'gcx>) -> &'gcx Steal<Mir<'gcx>> {
+ self.global_arenas.steal_mir.alloc(Steal::new(mir))
+ }
+
+ pub fn alloc_mir(self, mir: Mir<'gcx>) -> &'gcx Mir<'gcx> {
+ self.global_arenas.mir.alloc(mir)
+ }
+
+ pub fn alloc_tables(self, tables: ty::TypeckTables<'gcx>) -> &'gcx ty::TypeckTables<'gcx> {
+ self.global_arenas.tables.alloc(tables)
+ }
+
+ pub fn alloc_trait_def(self, def: ty::TraitDef) -> &'gcx ty::TraitDef {
+ self.global_arenas.trait_def.alloc(def)
+ }
+
+ pub fn alloc_adt_def(self,
+ did: DefId,
+ kind: AdtKind,
+ variants: Vec<ty::VariantDef>,
+ repr: ReprOptions)
+ -> &'gcx ty::AdtDef {
+ let def = ty::AdtDef::new(self, did, kind, variants, repr);
+ self.global_arenas.adt_def.alloc(def)
+ }
+
+ pub fn alloc_byte_array(self, bytes: &[u8]) -> &'gcx [u8] {
+ if bytes.is_empty() {
+ &[]
} else {
- self.sess.cstore.original_crate_name(cnum)
+ self.global_interners.arena.alloc_slice(bytes)
}
}
- pub fn crate_disambiguator(self, cnum: CrateNum) -> token::InternedString {
- if cnum == LOCAL_CRATE {
- self.sess.local_crate_disambiguator()
+ pub fn alloc_const_slice(self, values: &[&'tcx ty::Const<'tcx>])
+ -> &'tcx [&'tcx ty::Const<'tcx>] {
+ if values.is_empty() {
+ &[]
} else {
- self.sess.cstore.crate_disambiguator(cnum)
+ self.interners.arena.alloc_slice(values)
}
}
- /// Given a def-key `key` and a crate `krate`, finds the def-index
- /// that `krate` assigned to `key`. This `DefIndex` will always be
- /// relative to `krate`.
- ///
- /// Returns `None` if there is no `DefIndex` with that key.
- pub fn def_index_for_def_key(self, krate: CrateNum, key: DefKey)
- -> Option<DefIndex> {
- if krate == LOCAL_CRATE {
- self.map.def_index_for_def_key(key)
+ pub fn alloc_name_const_slice(self, values: &[(ast::Name, &'tcx ty::Const<'tcx>)])
+ -> &'tcx [(ast::Name, &'tcx ty::Const<'tcx>)] {
+ if values.is_empty() {
+ &[]
} else {
- self.sess.cstore.def_index_for_def_key(krate, key)
+ self.interners.arena.alloc_slice(values)
}
}
- pub fn retrace_path(self, path: &DefPath) -> Option<DefId> {
- debug!("retrace_path(path={:?}, krate={:?})", path, self.crate_name(path.krate));
+ pub fn intern_const_alloc(
+ self,
+ alloc: interpret::Allocation,
+ ) -> &'gcx interpret::Allocation {
+ let allocs = &mut self.interpret_interner.inner.borrow_mut().allocs;
+ if let Some(alloc) = allocs.get(&alloc) {
+ return alloc;
+ }
- let root_key = DefKey {
- parent: None,
- disambiguated_data: DisambiguatedDefPathData {
- data: DefPathData::CrateRoot,
- disambiguator: 0,
- },
- };
+ let interned = self.global_arenas.const_allocs.alloc(alloc);
+ if let Some(prev) = allocs.replace(interned) {
+ bug!("Tried to overwrite interned Allocation: {:#?}", prev)
+ }
+ interned
+ }
- let root_index = self.def_index_for_def_key(path.krate, root_key)
- .expect("no root key?");
+ /// Allocates a byte or string literal for `mir::interpret`
+ pub fn allocate_cached(self, bytes: &[u8]) -> interpret::AllocId {
+ // check whether we already allocated this literal or a constant with the same memory
+ if let Some(&alloc_id) = self.interpret_interner.inner.borrow()
+ .literal_alloc_cache.get(bytes) {
+ return alloc_id;
+ }
+ // create an allocation that just contains these bytes
+ let alloc = interpret::Allocation::from_bytes(bytes);
+ let alloc = self.intern_const_alloc(alloc);
- debug!("retrace_path: root_index={:?}", root_index);
+ // the next unique id
+ let id = self.interpret_interner.reserve();
+ // make the allocation identifiable
+ self.interpret_interner.inner.borrow_mut().alloc_by_id.insert(id, alloc);
+ // cache it for the future
+ self.interpret_interner.inner.borrow_mut().literal_alloc_cache.insert(bytes.to_owned(), id);
+ id
+ }
- let mut index = root_index;
- for data in &path.data {
- let key = DefKey { parent: Some(index), disambiguated_data: data.clone() };
- debug!("retrace_path: key={:?}", key);
- match self.def_index_for_def_key(path.krate, key) {
- Some(i) => index = i,
- None => return None,
- }
+ pub fn intern_stability(self, stab: attr::Stability) -> &'gcx attr::Stability {
+ let mut stability_interner = self.stability_interner.borrow_mut();
+ if let Some(st) = stability_interner.get(&stab) {
+ return st;
}
- Some(DefId { krate: path.krate, index: index })
+ let interned = self.global_interners.arena.alloc(stab);
+ if let Some(prev) = stability_interner.replace(interned) {
+ bug!("Tried to overwrite interned Stability: {:?}", prev)
+ }
+ interned
}
- pub fn type_parameter_def(self,
- node_id: NodeId)
- -> ty::TypeParameterDef<'tcx>
- {
- self.ty_param_defs.borrow().get(&node_id).unwrap().clone()
- }
+ pub fn intern_layout(self, layout: LayoutDetails) -> &'gcx LayoutDetails {
+ let mut layout_interner = self.layout_interner.borrow_mut();
+ if let Some(layout) = layout_interner.get(&layout) {
+ return layout;
+ }
- pub fn node_types(self) -> Ref<'a, NodeMap<Ty<'tcx>>> {
- fn projection<'a, 'tcx>(tables: &'a Tables<'tcx>) -> &'a NodeMap<Ty<'tcx>> {
- &tables.node_types
+ let interned = self.global_arenas.layout.alloc(layout);
+ if let Some(prev) = layout_interner.replace(interned) {
+ bug!("Tried to overwrite interned Layout: {:?}", prev)
}
+ interned
+ }
- Ref::map(self.tables.borrow(), projection)
+ pub fn lift<T: ?Sized + Lift<'tcx>>(self, value: &T) -> Option<T::Lifted> {
+ value.lift_to_tcx(self)
}
- pub fn node_type_insert(self, id: NodeId, ty: Ty<'gcx>) {
- self.tables.borrow_mut().node_types.insert(id, ty);
+ /// Like lift, but only tries in the global tcx.
+ pub fn lift_to_global<T: ?Sized + Lift<'gcx>>(self, value: &T) -> Option<T::Lifted> {
+ value.lift_to_tcx(self.global_tcx())
}
- pub fn alloc_generics(self, generics: ty::Generics<'gcx>)
- -> &'gcx ty::Generics<'gcx> {
- self.global_interners.arenas.generics.alloc(generics)
+ /// Returns true if self is the same as self.global_tcx().
+ fn is_global(self) -> bool {
+ let local = self.interners as *const _;
+ let global = &self.global_interners as *const _;
+ local as usize == global as usize
}
- pub fn intern_trait_def(self, def: ty::TraitDef<'gcx>)
- -> &'gcx ty::TraitDef<'gcx> {
- let did = def.trait_ref.def_id;
- let interned = self.alloc_trait_def(def);
- if let Some(prev) = self.trait_defs.borrow_mut().insert(did, interned) {
- bug!("Tried to overwrite interned TraitDef: {:?}", prev)
+ /// Create a type context and call the closure with a `TyCtxt` reference
+ /// to the context. The closure enforces that the type context and any interned
+ /// value (types, substs, etc.) can only be used while `ty::tls` has a valid
+ /// reference to the context, to allow formatting values that need it.
+ pub fn create_and_enter<F, R>(s: &'tcx Session,
+ cstore: &'tcx dyn CrateStore,
+ local_providers: ty::maps::Providers<'tcx>,
+ extern_providers: ty::maps::Providers<'tcx>,
+ arenas: &'tcx AllArenas<'tcx>,
+ resolutions: ty::Resolutions,
+ hir: hir_map::Map<'tcx>,
+ on_disk_query_result_cache: maps::OnDiskCache<'tcx>,
+ crate_name: &str,
+ tx: mpsc::Sender<Box<dyn Any + Send>>,
+ output_filenames: &OutputFilenames,
+ f: F) -> R
+ where F: for<'b> FnOnce(TyCtxt<'b, 'tcx, 'tcx>) -> R
+ {
+ let data_layout = TargetDataLayout::parse(&s.target.target).unwrap_or_else(|err| {
+ s.fatal(&err);
+ });
+ let interners = CtxtInterners::new(&arenas.interner);
+ let common_types = CommonTypes::new(&interners);
+ let dep_graph = hir.dep_graph.clone();
+ let max_cnum = cstore.crates_untracked().iter().map(|c| c.as_usize()).max().unwrap_or(0);
+ let mut providers = IndexVec::from_elem_n(extern_providers, max_cnum + 1);
+ providers[LOCAL_CRATE] = local_providers;
+
+ let def_path_hash_to_def_id = if s.opts.build_dep_graph() {
+ let upstream_def_path_tables: Vec<(CrateNum, Lrc<_>)> = cstore
+ .crates_untracked()
+ .iter()
+ .map(|&cnum| (cnum, cstore.def_path_table(cnum)))
+ .collect();
+
+ let def_path_tables = || {
+ upstream_def_path_tables
+ .iter()
+ .map(|&(cnum, ref rc)| (cnum, &**rc))
+ .chain(iter::once((LOCAL_CRATE, hir.definitions().def_path_table())))
+ };
+
+ // Precompute the capacity of the hashmap so we don't have to
+ // re-allocate when populating it.
+ let capacity = def_path_tables().map(|(_, t)| t.size()).sum::<usize>();
+
+ let mut map: FxHashMap<_, _> = FxHashMap::with_capacity_and_hasher(
+ capacity,
+ ::std::default::Default::default()
+ );
+
+ for (cnum, def_path_table) in def_path_tables() {
+ def_path_table.add_def_path_hashes_to(cnum, &mut map);
+ }
+
+ Some(map)
+ } else {
+ None
+ };
+
+ let mut trait_map = FxHashMap();
+ for (k, v) in resolutions.trait_map {
+ let hir_id = hir.node_to_hir_id(k);
+ let map = trait_map.entry(hir_id.owner)
+ .or_insert_with(|| Lrc::new(FxHashMap()));
+ Lrc::get_mut(map).unwrap()
+ .insert(hir_id.local_id,
+ Lrc::new(StableVec::new(v)));
}
- self.generics.borrow_mut().insert(did, interned.generics);
- interned
- }
- pub fn alloc_trait_def(self, def: ty::TraitDef<'gcx>)
- -> &'gcx ty::TraitDef<'gcx> {
- self.global_interners.arenas.trait_defs.alloc(def)
+ let gcx = &GlobalCtxt {
+ sess: s,
+ cstore,
+ global_arenas: &arenas.global,
+ global_interners: interners,
+ dep_graph: dep_graph.clone(),
+ on_disk_query_result_cache,
+ types: common_types,
+ trait_map,
+ export_map: resolutions.export_map.into_iter().map(|(k, v)| {
+ (k, Lrc::new(v))
+ }).collect(),
+ freevars: resolutions.freevars.into_iter().map(|(k, v)| {
+ (hir.local_def_id(k), Lrc::new(v))
+ }).collect(),
+ maybe_unused_trait_imports:
+ resolutions.maybe_unused_trait_imports
+ .into_iter()
+ .map(|id| hir.local_def_id(id))
+ .collect(),
+ maybe_unused_extern_crates:
+ resolutions.maybe_unused_extern_crates
+ .into_iter()
+ .map(|(id, sp)| (hir.local_def_id(id), sp))
+ .collect(),
+ hir,
+ def_path_hash_to_def_id,
+ maps: maps::Maps::new(providers),
+ rcache: Lock::new(FxHashMap()),
+ selection_cache: traits::SelectionCache::new(),
+ evaluation_cache: traits::EvaluationCache::new(),
+ crate_name: Symbol::intern(crate_name),
+ data_layout,
+ layout_interner: Lock::new(FxHashSet()),
+ stability_interner: Lock::new(FxHashSet()),
+ interpret_interner: Default::default(),
+ tx_to_llvm_workers: Lock::new(tx),
+ output_filenames: Arc::new(output_filenames.clone()),
+ };
+
+ tls::enter_global(gcx, f)
}
- pub fn insert_adt_def(self, did: DefId, adt_def: ty::AdtDefMaster<'gcx>) {
- // this will need a transmute when reverse-variance is removed
- if let Some(prev) = self.adt_defs.borrow_mut().insert(did, adt_def) {
- bug!("Tried to overwrite interned AdtDef: {:?}", prev)
- }
+ pub fn consider_optimizing<T: Fn() -> String>(&self, msg: T) -> bool {
+ let cname = self.crate_name(LOCAL_CRATE).as_str();
+ self.sess.consider_optimizing(&cname, msg)
}
- pub fn intern_adt_def(self,
- did: DefId,
- kind: AdtKind,
- variants: Vec<ty::VariantDefData<'gcx, 'gcx>>)
- -> ty::AdtDefMaster<'gcx> {
- let def = ty::AdtDefData::new(self, did, kind, variants);
- let interned = self.global_interners.arenas.adt_defs.alloc(def);
- self.insert_adt_def(did, interned);
- interned
+ pub fn lang_items(self) -> Lrc<middle::lang_items::LanguageItems> {
+ self.get_lang_items(LOCAL_CRATE)
}
- pub fn intern_stability(self, stab: attr::Stability) -> &'gcx attr::Stability {
- if let Some(st) = self.global_interners.stability.borrow().get(&stab) {
- return st;
+ /// Due to missing llvm support for lowering 128 bit math to software emulation
+ /// (on some targets), the lowering can be done in MIR.
+ ///
+ /// This function only exists until said support is implemented.
+ pub fn is_binop_lang_item(&self, def_id: DefId) -> Option<(mir::BinOp, bool)> {
+ let items = self.lang_items();
+ let def_id = Some(def_id);
+ if items.i128_add_fn() == def_id { Some((mir::BinOp::Add, false)) }
+ else if items.u128_add_fn() == def_id { Some((mir::BinOp::Add, false)) }
+ else if items.i128_sub_fn() == def_id { Some((mir::BinOp::Sub, false)) }
+ else if items.u128_sub_fn() == def_id { Some((mir::BinOp::Sub, false)) }
+ else if items.i128_mul_fn() == def_id { Some((mir::BinOp::Mul, false)) }
+ else if items.u128_mul_fn() == def_id { Some((mir::BinOp::Mul, false)) }
+ else if items.i128_div_fn() == def_id { Some((mir::BinOp::Div, false)) }
+ else if items.u128_div_fn() == def_id { Some((mir::BinOp::Div, false)) }
+ else if items.i128_rem_fn() == def_id { Some((mir::BinOp::Rem, false)) }
+ else if items.u128_rem_fn() == def_id { Some((mir::BinOp::Rem, false)) }
+ else if items.i128_shl_fn() == def_id { Some((mir::BinOp::Shl, false)) }
+ else if items.u128_shl_fn() == def_id { Some((mir::BinOp::Shl, false)) }
+ else if items.i128_shr_fn() == def_id { Some((mir::BinOp::Shr, false)) }
+ else if items.u128_shr_fn() == def_id { Some((mir::BinOp::Shr, false)) }
+ else if items.i128_addo_fn() == def_id { Some((mir::BinOp::Add, true)) }
+ else if items.u128_addo_fn() == def_id { Some((mir::BinOp::Add, true)) }
+ else if items.i128_subo_fn() == def_id { Some((mir::BinOp::Sub, true)) }
+ else if items.u128_subo_fn() == def_id { Some((mir::BinOp::Sub, true)) }
+ else if items.i128_mulo_fn() == def_id { Some((mir::BinOp::Mul, true)) }
+ else if items.u128_mulo_fn() == def_id { Some((mir::BinOp::Mul, true)) }
+ else if items.i128_shlo_fn() == def_id { Some((mir::BinOp::Shl, true)) }
+ else if items.u128_shlo_fn() == def_id { Some((mir::BinOp::Shl, true)) }
+ else if items.i128_shro_fn() == def_id { Some((mir::BinOp::Shr, true)) }
+ else if items.u128_shro_fn() == def_id { Some((mir::BinOp::Shr, true)) }
+ else { None }
+ }
+
+ pub fn stability(self) -> Lrc<stability::Index<'tcx>> {
+ self.stability_index(LOCAL_CRATE)
+ }
+
+ pub fn crates(self) -> Lrc<Vec<CrateNum>> {
+ self.all_crate_nums(LOCAL_CRATE)
+ }
+
+ pub fn features(self) -> Lrc<feature_gate::Features> {
+ self.features_query(LOCAL_CRATE)
+ }
+
+ pub fn def_key(self, id: DefId) -> hir_map::DefKey {
+ if id.is_local() {
+ self.hir.def_key(id)
+ } else {
+ self.cstore.def_key(id)
}
+ }
- let interned = self.global_interners.arenas.stability.alloc(stab);
- if let Some(prev) = self.global_interners.stability
- .borrow_mut()
- .replace(interned) {
- bug!("Tried to overwrite interned Stability: {:?}", prev)
+ /// Convert a `DefId` into its fully expanded `DefPath` (every
+ /// `DefId` is really just an interned def-path).
+ ///
+ /// Note that if `id` is not local to this crate, the result will
+ /// be a non-local `DefPath`.
+ pub fn def_path(self, id: DefId) -> hir_map::DefPath {
+ if id.is_local() {
+ self.hir.def_path(id)
+ } else {
+ self.cstore.def_path(id)
}
- interned
}
- pub fn intern_layout(self, layout: Layout) -> &'gcx Layout {
- if let Some(layout) = self.global_interners.layout.borrow().get(&layout) {
- return layout;
+ #[inline]
+ pub fn def_path_hash(self, def_id: DefId) -> hir_map::DefPathHash {
+ if def_id.is_local() {
+ self.hir.definitions().def_path_hash(def_id.index)
+ } else {
+ self.cstore.def_path_hash(def_id)
}
+ }
- let interned = self.global_interners.arenas.layout.alloc(layout);
- if let Some(prev) = self.global_interners.layout
- .borrow_mut()
- .replace(interned) {
- bug!("Tried to overwrite interned Layout: {:?}", prev)
+ pub fn def_path_debug_str(self, def_id: DefId) -> String {
+ // We are explicitly not going through queries here in order to get
+ // crate name and disambiguator since this code is called from debug!()
+ // statements within the query system and we'd run into endless
+ // recursion otherwise.
+ let (crate_name, crate_disambiguator) = if def_id.is_local() {
+ (self.crate_name.clone(),
+ self.sess.local_crate_disambiguator())
+ } else {
+ (self.cstore.crate_name_untracked(def_id.krate),
+ self.cstore.crate_disambiguator_untracked(def_id.krate))
+ };
+
+ format!("{}[{}]{}",
+ crate_name,
+ // Don't print the whole crate disambiguator. That's just
+ // annoying in debug output.
+ &(crate_disambiguator.to_fingerprint().to_hex())[..4],
+ self.def_path(def_id).to_string_no_crate())
+ }
+
+ pub fn metadata_encoding_version(self) -> Vec<u8> {
+ self.cstore.metadata_encoding_version().to_vec()
+ }
+
+ // Note that this is *untracked* and should only be used within the query
+ // system if the result is otherwise tracked through queries
+ pub fn crate_data_as_rc_any(self, cnum: CrateNum) -> Lrc<dyn Any> {
+ self.cstore.crate_data_as_rc_any(cnum)
+ }
+
+ pub fn create_stable_hashing_context(self) -> StableHashingContext<'a> {
+ let krate = self.dep_graph.with_ignore(|| self.gcx.hir.krate());
+
+ StableHashingContext::new(self.sess,
+ krate,
+ self.hir.definitions(),
+ self.cstore)
+ }
+
+ // This method makes sure that we have a DepNode and a Fingerprint for
+ // every upstream crate. It needs to be called once right after the tcx is
+ // created.
+ // With full-fledged red/green, the method will probably become unnecessary
+ // as this will be done on-demand.
+ pub fn allocate_metadata_dep_nodes(self) {
+ // We cannot use the query versions of crates() and crate_hash(), since
+ // those would need the DepNodes that we are allocating here.
+ for cnum in self.cstore.crates_untracked() {
+ let dep_node = DepNode::new(self, DepConstructor::CrateMetadata(cnum));
+ let crate_hash = self.cstore.crate_hash_untracked(cnum);
+ self.dep_graph.with_task(dep_node,
+ self,
+ crate_hash,
+ |_, x| x // No transformation needed
+ );
}
- interned
}
- pub fn store_free_region_map(self, id: NodeId, map: FreeRegionMap) {
- if self.free_region_maps.borrow_mut().insert(id, map).is_some() {
- bug!("Tried to overwrite interned FreeRegionMap for NodeId {:?}", id)
+ // This method exercises the `in_scope_traits_map` query for all possible
+ // values so that we have their fingerprints available in the DepGraph.
+ // This is only required as long as we still use the old dependency tracking
+ // which needs to have the fingerprints of all input nodes beforehand.
+ pub fn precompute_in_scope_traits_hashes(self) {
+ for &def_index in self.trait_map.keys() {
+ self.in_scope_traits_map(def_index);
}
}
- pub fn free_region_map(self, id: NodeId) -> FreeRegionMap {
- self.free_region_maps.borrow()[&id].clone()
+ pub fn serialize_query_result_cache<E>(self,
+ encoder: &mut E)
+ -> Result<(), E::Error>
+ where E: ty::codec::TyEncoder
+ {
+ self.on_disk_query_result_cache.serialize(self.global_tcx(), encoder)
}
- pub fn lift<T: ?Sized + Lift<'tcx>>(self, value: &T) -> Option<T::Lifted> {
- value.lift_to_tcx(self)
+ /// If true, we should use the MIR-based borrowck (we may *also* use
+ /// the AST-based borrowck).
+ pub fn use_mir_borrowck(self) -> bool {
+ self.borrowck_mode().use_mir()
}
- /// Like lift, but only tries in the global tcx.
- pub fn lift_to_global<T: ?Sized + Lift<'gcx>>(self, value: &T) -> Option<T::Lifted> {
- value.lift_to_tcx(self.global_tcx())
+ /// If true, pattern variables for use in guards on match arms
+ /// will be bound as references to the data, and occurrences of
+ /// those variables in the guard expression will implicitly
+ /// dereference those bindings. (See rust-lang/rust#27282.)
+ pub fn all_pat_vars_are_implicit_refs_within_guards(self) -> bool {
+ self.borrowck_mode().use_mir()
+ }
+
+ /// If true, we should enable two-phase borrows checks. This is
+ /// done with either `-Ztwo-phase-borrows` or with
+ /// `#![feature(nll)]`.
+ pub fn two_phase_borrows(self) -> bool {
+ self.features().nll || self.sess.opts.debugging_opts.two_phase_borrows
+ }
+
+ /// What mode(s) of borrowck should we run? AST? MIR? both?
+ /// (Also considers the `#![feature(nll)]` setting.)
+ pub fn borrowck_mode(&self) -> BorrowckMode {
+ match self.sess.opts.borrowck_mode {
+ mode @ BorrowckMode::Mir |
+ mode @ BorrowckMode::Compare => mode,
+
+ mode @ BorrowckMode::Ast => {
+ if self.features().nll {
+ BorrowckMode::Mir
+ } else {
+ mode
+ }
+ }
+
+ }
+ }
+
+ /// Should we emit EndRegion MIR statements? These are consumed by
+ /// MIR borrowck, but not when NLL is used. They are also consumed
+ /// by the validation stuff.
+ pub fn emit_end_regions(self) -> bool {
+ self.sess.opts.debugging_opts.emit_end_regions ||
+ self.sess.opts.debugging_opts.mir_emit_validate > 0 ||
+ self.use_mir_borrowck()
+ }
+
+ #[inline]
+ pub fn share_generics(self) -> bool {
+ match self.sess.opts.debugging_opts.share_generics {
+ Some(setting) => setting,
+ None => {
+ self.sess.opts.incremental.is_some() ||
+ match self.sess.opts.optimize {
+ OptLevel::No |
+ OptLevel::Less |
+ OptLevel::Size |
+ OptLevel::SizeMin => true,
+ OptLevel::Default |
+ OptLevel::Aggressive => false,
+ }
+ }
+ }
}
- /// Returns true if self is the same as self.global_tcx().
- fn is_global(self) -> bool {
- let local = self.interners as *const _;
- let global = &self.global_interners as *const _;
- local as usize == global as usize
+ #[inline]
+ pub fn local_crate_exports_generics(self) -> bool {
+ debug_assert!(self.share_generics());
+
+ self.sess.crate_types.borrow().iter().any(|crate_type| {
+ match crate_type {
+ CrateTypeExecutable |
+ CrateTypeStaticlib |
+ CrateTypeProcMacro |
+ CrateTypeCdylib => false,
+ CrateTypeRlib |
+ CrateTypeDylib => true,
+ }
+ })
}
+}
- /// Create a type context and call the closure with a `TyCtxt` reference
- /// to the context. The closure enforces that the type context and any interned
- /// value (types, substs, etc.) can only be used while `ty::tls` has a valid
- /// reference to the context, to allow formatting values that need it.
- pub fn create_and_enter<F, R>(s: &'tcx Session,
- arenas: &'tcx CtxtArenas<'tcx>,
- def_map: DefMap,
- trait_map: TraitMap,
- named_region_map: resolve_lifetime::NamedRegionMap,
- map: ast_map::Map<'tcx>,
- freevars: FreevarMap,
- maybe_unused_trait_imports: NodeSet,
- region_maps: RegionMaps,
- lang_items: middle::lang_items::LanguageItems,
- stability: stability::Index<'tcx>,
- crate_name: &str,
- f: F) -> R
- where F: for<'b> FnOnce(TyCtxt<'b, 'tcx, 'tcx>) -> R
+impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> {
+ pub fn encode_metadata(self, link_meta: &LinkMeta)
+ -> EncodedMetadata
{
- let data_layout = TargetDataLayout::parse(s);
- let interners = CtxtInterners::new(arenas);
- let common_types = CommonTypes::new(&interners);
- let dep_graph = map.dep_graph.clone();
- let fulfilled_predicates = traits::GlobalFulfilledPredicates::new(dep_graph.clone());
- tls::enter_global(GlobalCtxt {
- specializes_cache: RefCell::new(traits::SpecializesCache::new()),
- global_interners: interners,
- dep_graph: dep_graph.clone(),
- types: common_types,
- named_region_map: named_region_map,
- region_maps: region_maps,
- free_region_maps: RefCell::new(FnvHashMap()),
- item_variance_map: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- variance_computed: Cell::new(false),
- sess: s,
- def_map: RefCell::new(def_map),
- trait_map: trait_map,
- tables: RefCell::new(Tables::empty()),
- impl_trait_refs: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- trait_defs: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- adt_defs: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- generics: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- predicates: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- super_predicates: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- fulfilled_predicates: RefCell::new(fulfilled_predicates),
- map: map,
- freevars: RefCell::new(freevars),
- maybe_unused_trait_imports: maybe_unused_trait_imports,
- tcache: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- rcache: RefCell::new(FnvHashMap()),
- tc_cache: RefCell::new(FnvHashMap()),
- impl_or_trait_items: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- impl_or_trait_item_def_ids: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- trait_items_cache: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- ty_param_defs: RefCell::new(NodeMap()),
- normalized_cache: RefCell::new(FnvHashMap()),
- lang_items: lang_items,
- inherent_impls: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- used_unsafe: RefCell::new(NodeSet()),
- used_mut_nodes: RefCell::new(NodeSet()),
- used_trait_imports: RefCell::new(NodeSet()),
- populated_external_types: RefCell::new(DefIdSet()),
- populated_external_primitive_impls: RefCell::new(DefIdSet()),
- extern_const_statics: RefCell::new(DefIdMap()),
- extern_const_fns: RefCell::new(DefIdMap()),
- stability: RefCell::new(stability),
- selection_cache: traits::SelectionCache::new(),
- evaluation_cache: traits::EvaluationCache::new(),
- repr_hint_cache: RefCell::new(DepTrackingMap::new(dep_graph.clone())),
- const_qualif_map: RefCell::new(NodeMap()),
- custom_coerce_unsized_kinds: RefCell::new(DefIdMap()),
- cast_kinds: RefCell::new(NodeMap()),
- fragment_infos: RefCell::new(DefIdMap()),
- crate_name: token::intern_and_get_ident(crate_name),
- data_layout: data_layout,
- layout_cache: RefCell::new(FnvHashMap()),
- layout_depth: Cell::new(0),
- derive_macros: RefCell::new(NodeMap()),
- }, f)
+ self.cstore.encode_metadata(self, link_meta)
}
}
impl<'gcx: 'tcx, 'tcx> GlobalCtxt<'gcx> {
- /// Call the closure with a local `TyCtxt` using the given arenas.
- pub fn enter_local<F, R>(&self, arenas: &'tcx CtxtArenas<'tcx>, f: F) -> R
- where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
+ /// Call the closure with a local `TyCtxt` using the given arena.
+ pub fn enter_local<F, R>(
+ &self,
+ arena: &'tcx SyncDroplessArena,
+ f: F
+ ) -> R
+ where
+ F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
{
- let interners = CtxtInterners::new(arenas);
- tls::enter(self, &interners, f)
+ let interners = CtxtInterners::new(arena);
+ let tcx = TyCtxt {
+ gcx: self,
+ interners: &interners,
+ };
+ ty::tls::with_related_context(tcx.global_tcx(), |icx| {
+ let new_icx = ty::tls::ImplicitCtxt {
+ tcx,
+ query: icx.query.clone(),
+ layout_depth: icx.layout_depth,
+ task: icx.task,
+ };
+ ty::tls::enter_context(&new_icx, |new_icx| {
+ f(new_icx.tcx)
+ })
+ })
}
}
/// pointer differs. The latter case is possible if a primitive type,
/// e.g. `()` or `u8`, was interned in a different context.
pub trait Lift<'tcx> {
- type Lifted;
+ type Lifted: 'tcx;
fn lift_to_tcx<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option<Self::Lifted>;
}
impl<'a, 'tcx> Lift<'tcx> for Ty<'a> {
type Lifted = Ty<'tcx>;
fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Ty<'tcx>> {
- if let Some(&Interned(ty)) = tcx.interners.type_.borrow().get(&self.sty) {
- if *self as *const _ == ty as *const _ {
- return Some(ty);
- }
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
}
// Also try in the global tcx if we're not that.
if !tcx.is_global() {
}
}
-impl<'a, 'tcx> Lift<'tcx> for &'a Substs<'a> {
- type Lifted = &'tcx Substs<'tcx>;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<&'tcx Substs<'tcx>> {
- if let Some(&Interned(substs)) = tcx.interners.substs.borrow().get(*self) {
- if *self as *const _ == substs as *const _ {
- return Some(substs);
- }
+impl<'a, 'tcx> Lift<'tcx> for Region<'a> {
+ type Lifted = Region<'tcx>;
+ fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Region<'tcx>> {
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
}
// Also try in the global tcx if we're not that.
if !tcx.is_global() {
}
}
-impl<'a, 'tcx> Lift<'tcx> for &'a Region {
- type Lifted = &'tcx Region;
- fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<&'tcx Region> {
- if let Some(&Interned(region)) = tcx.interners.region.borrow().get(*self) {
- if *self as *const _ == region as *const _ {
- return Some(region);
- }
+impl<'a, 'tcx> Lift<'tcx> for &'a Const<'a> {
+ type Lifted = &'tcx Const<'tcx>;
+ fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<&'tcx Const<'tcx>> {
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
+ }
+ // Also try in the global tcx if we're not that.
+ if !tcx.is_global() {
+ self.lift_to_tcx(tcx.global_tcx())
+ } else {
+ None
+ }
+ }
+}
+
+impl<'a, 'tcx> Lift<'tcx> for &'a Substs<'a> {
+ type Lifted = &'tcx Substs<'tcx>;
+ fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<&'tcx Substs<'tcx>> {
+ if self.len() == 0 {
+ return Some(Slice::empty());
+ }
+ if tcx.interners.arena.in_arena(&self[..] as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
}
// Also try in the global tcx if we're not that.
if !tcx.is_global() {
type Lifted = &'tcx Slice<Ty<'tcx>>;
fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>)
-> Option<&'tcx Slice<Ty<'tcx>>> {
- if let Some(&Interned(list)) = tcx.interners.type_list.borrow().get(&self[..]) {
- if *self as *const _ == list as *const _ {
- return Some(list);
- }
+ if self.len() == 0 {
+ return Some(Slice::empty());
+ }
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
}
// Also try in the global tcx if we're not that.
if !tcx.is_global() {
}
}
-impl<'a, 'tcx> Lift<'tcx> for &'a BareFnTy<'a> {
- type Lifted = &'tcx BareFnTy<'tcx>;
+impl<'a, 'tcx> Lift<'tcx> for &'a Slice<ExistentialPredicate<'a>> {
+ type Lifted = &'tcx Slice<ExistentialPredicate<'tcx>>;
fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>)
- -> Option<&'tcx BareFnTy<'tcx>> {
- if let Some(&Interned(fty)) = tcx.interners.bare_fn.borrow().get(*self) {
- if *self as *const _ == fty as *const _ {
- return Some(fty);
- }
+ -> Option<&'tcx Slice<ExistentialPredicate<'tcx>>> {
+ if self.is_empty() {
+ return Some(Slice::empty());
+ }
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
+ }
+ // Also try in the global tcx if we're not that.
+ if !tcx.is_global() {
+ self.lift_to_tcx(tcx.global_tcx())
+ } else {
+ None
+ }
+ }
+}
+
+impl<'a, 'tcx> Lift<'tcx> for &'a Slice<Predicate<'a>> {
+ type Lifted = &'tcx Slice<Predicate<'tcx>>;
+ fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>)
+ -> Option<&'tcx Slice<Predicate<'tcx>>> {
+ if self.is_empty() {
+ return Some(Slice::empty());
+ }
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
}
// Also try in the global tcx if we're not that.
if !tcx.is_global() {
}
}
+impl<'a, 'tcx> Lift<'tcx> for &'a Slice<CanonicalVarInfo> {
+ type Lifted = &'tcx Slice<CanonicalVarInfo>;
+ fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
+ if self.len() == 0 {
+ return Some(Slice::empty());
+ }
+ if tcx.interners.arena.in_arena(*self as *const _) {
+ return Some(unsafe { mem::transmute(*self) });
+ }
+ // Also try in the global tcx if we're not that.
+ if !tcx.is_global() {
+ self.lift_to_tcx(tcx.global_tcx())
+ } else {
+ None
+ }
+ }
+}
pub mod tls {
- use super::{CtxtInterners, GlobalCtxt, TyCtxt};
+ use super::{GlobalCtxt, TyCtxt};
use std::cell::Cell;
use std::fmt;
+ use std::mem;
use syntax_pos;
+ use ty::maps;
+ use errors::{Diagnostic, TRACK_DIAGNOSTICS};
+ use rustc_data_structures::OnDrop;
+ use rustc_data_structures::sync::Lrc;
+ use dep_graph::OpenTask;
+
+ /// This is the implicit state of rustc. It contains the current
+ /// TyCtxt and query. It is updated when creating a local interner or
+ /// executing a new query. Whenever there's a TyCtxt value available
+ /// you should also have access to an ImplicitCtxt through the functions
+ /// in this module.
+ #[derive(Clone)]
+ pub struct ImplicitCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
+ /// The current TyCtxt. Initially created by `enter_global` and updated
+ /// by `enter_local` with a new local interner
+ pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
+
+ /// The current query job, if any. This is updated by start_job in
+ /// ty::maps::plumbing when executing a query
+ pub query: Option<Lrc<maps::QueryJob<'gcx>>>,
+
+ /// Used to prevent layout from recursing too deeply.
+ pub layout_depth: usize,
+
+ /// The current dep graph task. This is used to add dependencies to queries
+ /// when executing them
+ pub task: &'a OpenTask,
+ }
- /// Marker types used for the scoped TLS slot.
- /// The type context cannot be used directly because the scoped TLS
- /// in libstd doesn't allow types generic over lifetimes.
- enum ThreadLocalGlobalCtxt {}
- enum ThreadLocalInterners {}
+ // A thread local value which stores a pointer to the current ImplicitCtxt
+ thread_local!(static TLV: Cell<usize> = Cell::new(0));
- thread_local! {
- static TLS_TCX: Cell<Option<(*const ThreadLocalGlobalCtxt,
- *const ThreadLocalInterners)>> = Cell::new(None)
+ fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
+ let old = get_tlv();
+ let _reset = OnDrop(move || TLV.with(|tlv| tlv.set(old)));
+ TLV.with(|tlv| tlv.set(value));
+ f()
}
+ fn get_tlv() -> usize {
+ TLV.with(|tlv| tlv.get())
+ }
+
+ /// This is a callback from libsyntax as it cannot access the implicit state
+ /// in librustc otherwise
fn span_debug(span: syntax_pos::Span, f: &mut fmt::Formatter) -> fmt::Result {
with(|tcx| {
write!(f, "{}", tcx.sess.codemap().span_to_string(span))
})
}
- pub fn enter_global<'gcx, F, R>(gcx: GlobalCtxt<'gcx>, f: F) -> R
- where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'gcx>) -> R
+ /// This is a callback from libsyntax as it cannot access the implicit state
+ /// in librustc otherwise. It is used to when diagnostic messages are
+ /// emitted and stores them in the current query, if there is one.
+ fn track_diagnostic(diagnostic: &Diagnostic) {
+ with_context(|context| {
+ if let Some(ref query) = context.query {
+ query.diagnostics.lock().push(diagnostic.clone());
+ }
+ })
+ }
+
+ /// Sets up the callbacks from libsyntax on the current thread
+ pub fn with_thread_locals<F, R>(f: F) -> R
+ where F: FnOnce() -> R
{
syntax_pos::SPAN_DEBUG.with(|span_dbg| {
let original_span_debug = span_dbg.get();
span_dbg.set(span_debug);
- let result = enter(&gcx, &gcx.global_interners, f);
- span_dbg.set(original_span_debug);
- result
+
+ let _on_drop = OnDrop(move || {
+ span_dbg.set(original_span_debug);
+ });
+
+ TRACK_DIAGNOSTICS.with(|current| {
+ let original = current.get();
+ current.set(track_diagnostic);
+
+ let _on_drop = OnDrop(move || {
+ current.set(original);
+ });
+
+ f()
+ })
})
}
- pub fn enter<'a, 'gcx: 'tcx, 'tcx, F, R>(gcx: &'a GlobalCtxt<'gcx>,
- interners: &'a CtxtInterners<'tcx>,
- f: F) -> R
- where F: FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
+ /// Sets `context` as the new current ImplicitCtxt for the duration of the function `f`
+ pub fn enter_context<'a, 'gcx: 'tcx, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'gcx, 'tcx>,
+ f: F) -> R
+ where F: FnOnce(&ImplicitCtxt<'a, 'gcx, 'tcx>) -> R
{
- let gcx_ptr = gcx as *const _ as *const ThreadLocalGlobalCtxt;
- let interners_ptr = interners as *const _ as *const ThreadLocalInterners;
- TLS_TCX.with(|tls| {
- let prev = tls.get();
- tls.set(Some((gcx_ptr, interners_ptr)));
- let ret = f(TyCtxt {
- gcx: gcx,
- interners: interners
- });
- tls.set(prev);
- ret
+ set_tlv(context as *const _ as usize, || {
+ f(&context)
})
}
- pub fn with<F, R>(f: F) -> R
- where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
+ /// Enters GlobalCtxt by setting up libsyntax callbacks and
+ /// creating a initial TyCtxt and ImplicitCtxt.
+ /// This happens once per rustc session and TyCtxts only exists
+ /// inside the `f` function.
+ pub fn enter_global<'gcx, F, R>(gcx: &GlobalCtxt<'gcx>, f: F) -> R
+ where F: for<'a> FnOnce(TyCtxt<'a, 'gcx, 'gcx>) -> R
{
- TLS_TCX.with(|tcx| {
- let (gcx, interners) = tcx.get().unwrap();
- let gcx = unsafe { &*(gcx as *const GlobalCtxt) };
- let interners = unsafe { &*(interners as *const CtxtInterners) };
- f(TyCtxt {
- gcx: gcx,
- interners: interners
+ with_thread_locals(|| {
+ let tcx = TyCtxt {
+ gcx,
+ interners: &gcx.global_interners,
+ };
+ let icx = ImplicitCtxt {
+ tcx,
+ query: None,
+ layout_depth: 0,
+ task: &OpenTask::Ignore,
+ };
+ enter_context(&icx, |_| {
+ f(tcx)
})
})
}
- pub fn with_opt<F, R>(f: F) -> R
- where F: for<'a, 'gcx, 'tcx> FnOnce(Option<TyCtxt<'a, 'gcx, 'tcx>>) -> R
+ /// Allows access to the current ImplicitCtxt in a closure if one is available
+ pub fn with_context_opt<F, R>(f: F) -> R
+ where F: for<'a, 'gcx, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'gcx, 'tcx>>) -> R
{
- if TLS_TCX.with(|tcx| tcx.get().is_some()) {
- with(|v| f(Some(v)))
- } else {
+ let context = get_tlv();
+ if context == 0 {
f(None)
+ } else {
+ unsafe { f(Some(&*(context as *const ImplicitCtxt))) }
}
}
+
+ /// Allows access to the current ImplicitCtxt.
+ /// Panics if there is no ImplicitCtxt available
+ pub fn with_context<F, R>(f: F) -> R
+ where F: for<'a, 'gcx, 'tcx> FnOnce(&ImplicitCtxt<'a, 'gcx, 'tcx>) -> R
+ {
+ with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
+ }
+
+ /// Allows access to the current ImplicitCtxt whose tcx field has the same global
+ /// interner as the tcx argument passed in. This means the closure is given an ImplicitCtxt
+ /// with the same 'gcx lifetime as the TyCtxt passed in.
+ /// This will panic if you pass it a TyCtxt which has a different global interner from
+ /// the current ImplicitCtxt's tcx field.
+ pub fn with_related_context<'a, 'gcx, 'tcx1, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx1>, f: F) -> R
+ where F: for<'b, 'tcx2> FnOnce(&ImplicitCtxt<'b, 'gcx, 'tcx2>) -> R
+ {
+ with_context(|context| {
+ unsafe {
+ let gcx = tcx.gcx as *const _ as usize;
+ assert!(context.tcx.gcx as *const _ as usize == gcx);
+ let context: &ImplicitCtxt = mem::transmute(context);
+ f(context)
+ }
+ })
+ }
+
+ /// Allows access to the current ImplicitCtxt whose tcx field has the same global
+ /// interner and local interner as the tcx argument passed in. This means the closure
+ /// is given an ImplicitCtxt with the same 'tcx and 'gcx lifetimes as the TyCtxt passed in.
+ /// This will panic if you pass it a TyCtxt which has a different global interner or
+ /// a different local interner from the current ImplicitCtxt's tcx field.
+ pub fn with_fully_related_context<'a, 'gcx, 'tcx, F, R>(tcx: TyCtxt<'a, 'gcx, 'tcx>, f: F) -> R
+ where F: for<'b> FnOnce(&ImplicitCtxt<'b, 'gcx, 'tcx>) -> R
+ {
+ with_context(|context| {
+ unsafe {
+ let gcx = tcx.gcx as *const _ as usize;
+ let interners = tcx.interners as *const _ as usize;
+ assert!(context.tcx.gcx as *const _ as usize == gcx);
+ assert!(context.tcx.interners as *const _ as usize == interners);
+ let context: &ImplicitCtxt = mem::transmute(context);
+ f(context)
+ }
+ })
+ }
+
+ /// Allows access to the TyCtxt in the current ImplicitCtxt.
+ /// Panics if there is no ImplicitCtxt available
+ pub fn with<F, R>(f: F) -> R
+ where F: for<'a, 'gcx, 'tcx> FnOnce(TyCtxt<'a, 'gcx, 'tcx>) -> R
+ {
+ with_context(|context| f(context.tcx))
+ }
+
+ /// Allows access to the TyCtxt in the current ImplicitCtxt.
+ /// The closure is passed None if there is no ImplicitCtxt available
+ pub fn with_opt<F, R>(f: F) -> R
+ where F: for<'a, 'gcx, 'tcx> FnOnce(Option<TyCtxt<'a, 'gcx, 'tcx>>) -> R
+ {
+ with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
+ }
}
macro_rules! sty_debug_print {
ty::TyError => /* unimportant */ continue,
$(ty::$variant(..) => &mut $variant,)*
};
- let region = t.flags.get().intersects(ty::TypeFlags::HAS_RE_INFER);
- let ty = t.flags.get().intersects(ty::TypeFlags::HAS_TY_INFER);
+ let region = t.flags.intersects(ty::TypeFlags::HAS_RE_INFER);
+ let ty = t.flags.intersects(ty::TypeFlags::HAS_TY_INFER);
variant.total += 1;
total.total += 1;
pub fn print_debug_stats(self) {
sty_debug_print!(
self,
- TyAdt, TyBox, TyArray, TySlice, TyRawPtr, TyRef, TyFnDef, TyFnPtr,
- TyTrait, TyClosure, TyTuple, TyParam, TyInfer, TyProjection, TyAnon);
+ TyAdt, TyArray, TySlice, TyRawPtr, TyRef, TyFnDef, TyFnPtr,
+ TyGenerator, TyGeneratorWitness, TyDynamic, TyClosure, TyTuple,
+ TyParam, TyInfer, TyProjection, TyAnon, TyForeign);
println!("Substs interner: #{}", self.interners.substs.borrow().len());
- println!("BareFnTy interner: #{}", self.interners.bare_fn.borrow().len());
println!("Region interner: #{}", self.interners.region.borrow().len());
- println!("Stability interner: #{}", self.interners.stability.borrow().len());
- println!("Layout interner: #{}", self.interners.layout.borrow().len());
+ println!("Stability interner: #{}", self.stability_interner.borrow().len());
+ println!("Interpret interner: #{}", self.interpret_interner.inner.borrow().allocs.len());
+ println!("Layout interner: #{}", self.layout_interner.borrow().len());
}
}
}
}
-impl<'tcx: 'lcx, 'lcx> Borrow<Substs<'lcx>> for Interned<'tcx, Substs<'tcx>> {
- fn borrow<'a>(&'a self) -> &'a Substs<'lcx> {
- self.0
+impl<'tcx: 'lcx, 'lcx> Borrow<[CanonicalVarInfo]> for Interned<'tcx, Slice<CanonicalVarInfo>> {
+ fn borrow<'a>(&'a self) -> &'a [CanonicalVarInfo] {
+ &self.0[..]
+ }
+}
+
+impl<'tcx: 'lcx, 'lcx> Borrow<[Kind<'lcx>]> for Interned<'tcx, Substs<'tcx>> {
+ fn borrow<'a>(&'a self) -> &'a [Kind<'lcx>] {
+ &self.0[..]
+ }
+}
+
+impl<'tcx> Borrow<RegionKind> for Interned<'tcx, RegionKind> {
+ fn borrow<'a>(&'a self) -> &'a RegionKind {
+ &self.0
+ }
+}
+
+impl<'tcx: 'lcx, 'lcx> Borrow<[ExistentialPredicate<'lcx>]>
+ for Interned<'tcx, Slice<ExistentialPredicate<'tcx>>> {
+ fn borrow<'a>(&'a self) -> &'a [ExistentialPredicate<'lcx>] {
+ &self.0[..]
+ }
+}
+
+impl<'tcx: 'lcx, 'lcx> Borrow<[Predicate<'lcx>]>
+ for Interned<'tcx, Slice<Predicate<'tcx>>> {
+ fn borrow<'a>(&'a self) -> &'a [Predicate<'lcx>] {
+ &self.0[..]
+ }
+}
+
+impl<'tcx: 'lcx, 'lcx> Borrow<Const<'lcx>> for Interned<'tcx, Const<'tcx>> {
+ fn borrow<'a>(&'a self) -> &'a Const<'lcx> {
+ &self.0
}
}
-impl<'tcx: 'lcx, 'lcx> Borrow<BareFnTy<'lcx>> for Interned<'tcx, BareFnTy<'tcx>> {
- fn borrow<'a>(&'a self) -> &'a BareFnTy<'lcx> {
- self.0
+impl<'tcx: 'lcx, 'lcx> Borrow<[Clause<'lcx>]>
+for Interned<'tcx, Slice<Clause<'tcx>>> {
+ fn borrow<'a>(&'a self) -> &'a [Clause<'lcx>] {
+ &self.0[..]
}
}
-impl<'tcx> Borrow<Region> for Interned<'tcx, Region> {
- fn borrow<'a>(&'a self) -> &'a Region {
- self.0
+impl<'tcx: 'lcx, 'lcx> Borrow<[Goal<'lcx>]>
+for Interned<'tcx, Slice<Goal<'tcx>>> {
+ fn borrow<'a>(&'a self) -> &'a [Goal<'lcx>] {
+ &self.0[..]
}
}
macro_rules! intern_method {
($lt_tcx:tt, $name:ident: $method:ident($alloc:ty,
+ $alloc_method:ident,
$alloc_to_key:expr,
$alloc_to_ret:expr,
- $needs_infer:expr) -> $ty:ty) => {
+ $keep_in_local_tcx:expr) -> $ty:ty) => {
impl<'a, 'gcx, $lt_tcx> TyCtxt<'a, 'gcx, $lt_tcx> {
pub fn $method(self, v: $alloc) -> &$lt_tcx $ty {
{
// HACK(eddyb) Depend on flags being accurate to
// determine that all contents are in the global tcx.
// See comments on Lift for why we can't use that.
- if !($needs_infer)(&v) {
+ if !($keep_in_local_tcx)(&v) {
if !self.is_global() {
let v = unsafe {
mem::transmute(v)
};
- let i = ($alloc_to_ret)(self.global_interners.arenas.$name.alloc(v));
+ let i = ($alloc_to_ret)(self.global_interners.arena.$alloc_method(v));
self.global_interners.$name.borrow_mut().insert(Interned(i));
return i;
}
}
}
- let i = ($alloc_to_ret)(self.interners.arenas.$name.alloc(v));
+ let i = ($alloc_to_ret)(self.interners.arena.$alloc_method(v));
self.interners.$name.borrow_mut().insert(Interned(i));
i
}
}
macro_rules! direct_interners {
- ($lt_tcx:tt, $($name:ident: $method:ident($needs_infer:expr) -> $ty:ty),+) => {
+ ($lt_tcx:tt, $($name:ident: $method:ident($keep_in_local_tcx:expr) -> $ty:ty),+) => {
$(impl<$lt_tcx> PartialEq for Interned<$lt_tcx, $ty> {
fn eq(&self, other: &Self) -> bool {
self.0 == other.0
}
}
- intern_method!($lt_tcx, $name: $method($ty, |x| x, |x| x, $needs_infer) -> $ty);)+
+ intern_method!(
+ $lt_tcx,
+ $name: $method($ty, alloc, |x| x, |x| x, $keep_in_local_tcx) -> $ty
+ );)+
}
}
-fn keep_local<'tcx, T: ty::TypeFoldable<'tcx>>(x: &T) -> bool {
+pub fn keep_local<'tcx, T: ty::TypeFoldable<'tcx>>(x: &T) -> bool {
x.has_type_flags(ty::TypeFlags::KEEP_IN_LOCAL_TCX)
}
direct_interners!('tcx,
- substs: mk_substs(|substs: &Substs| {
- substs.params().iter().any(keep_local)
- }) -> Substs<'tcx>,
- bare_fn: mk_bare_fn(|fty: &BareFnTy| {
- keep_local(&fty.sig)
- }) -> BareFnTy<'tcx>,
- region: mk_region(|r| {
- match r {
- &ty::ReVar(_) | &ty::ReSkolemized(..) => true,
- _ => false
- }
- }) -> Region
+ region: mk_region(|r: &RegionKind| r.keep_in_local_tcx()) -> RegionKind,
+ const_: mk_const(|c: &Const| keep_local(&c.ty) || keep_local(&c.val)) -> Const<'tcx>
);
-intern_method!('tcx,
- type_list: mk_type_list(Vec<Ty<'tcx>>, Deref::deref, |xs: &[Ty]| -> &Slice<Ty> {
- unsafe { mem::transmute(xs) }
- }, keep_local) -> Slice<Ty<'tcx>>
+macro_rules! slice_interners {
+ ($($field:ident: $method:ident($ty:ident)),+) => (
+ $(intern_method!('tcx, $field: $method(&[$ty<'tcx>], alloc_slice, Deref::deref,
+ |xs: &[$ty]| -> &Slice<$ty> {
+ unsafe { mem::transmute(xs) }
+ }, |xs: &[$ty]| xs.iter().any(keep_local)) -> Slice<$ty<'tcx>>);)+
+ )
+}
+
+slice_interners!(
+ existential_predicates: _intern_existential_predicates(ExistentialPredicate),
+ predicates: _intern_predicates(Predicate),
+ type_list: _intern_type_list(Ty),
+ substs: _intern_substs(Kind),
+ clauses: _intern_clauses(Clause),
+ goals: _intern_goals(Goal)
);
+// This isn't a perfect fit: CanonicalVarInfo slices are always
+// allocated in the global arena, so this `intern_method!` macro is
+// overly general. But we just return false for the code that checks
+// whether they belong in the thread-local arena, so no harm done, and
+// seems better than open-coding the rest.
+intern_method! {
+ 'tcx,
+ canonical_var_infos: _intern_canonical_var_infos(
+ &[CanonicalVarInfo],
+ alloc_slice,
+ Deref::deref,
+ |xs: &[CanonicalVarInfo]| -> &Slice<CanonicalVarInfo> { unsafe { mem::transmute(xs) } },
+ |_xs: &[CanonicalVarInfo]| -> bool { false }
+ ) -> Slice<CanonicalVarInfo>
+}
+
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
- /// Create an unsafe fn ty based on a safe fn ty.
- pub fn safe_to_unsafe_fn_ty(self, bare_fn: &BareFnTy<'tcx>) -> Ty<'tcx> {
- assert_eq!(bare_fn.unsafety, hir::Unsafety::Normal);
- self.mk_fn_ptr(self.mk_bare_fn(ty::BareFnTy {
+ /// Given a `fn` type, returns an equivalent `unsafe fn` type;
+ /// that is, a `fn` type that is equivalent in every way for being
+ /// unsafe.
+ pub fn safe_to_unsafe_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
+ assert_eq!(sig.unsafety(), hir::Unsafety::Normal);
+ self.mk_fn_ptr(sig.map_bound(|sig| ty::FnSig {
unsafety: hir::Unsafety::Unsafe,
- abi: bare_fn.abi,
- sig: bare_fn.sig.clone()
+ ..sig
}))
}
+ /// Given a closure signature `sig`, returns an equivalent `fn`
+ /// type with the same signature. Detuples and so forth -- so
+ /// e.g. if we have a sig with `Fn<(u32, i32)>` then you would get
+ /// a `fn(u32, i32)`.
+ pub fn coerce_closure_fn_ty(self, sig: PolyFnSig<'tcx>) -> Ty<'tcx> {
+ let converted_sig = sig.map_bound(|s| {
+ let params_iter = match s.inputs()[0].sty {
+ ty::TyTuple(params) => {
+ params.into_iter().cloned()
+ }
+ _ => bug!(),
+ };
+ self.mk_fn_sig(
+ params_iter,
+ s.output(),
+ s.variadic,
+ hir::Unsafety::Normal,
+ abi::Abi::Rust,
+ )
+ });
+
+ self.mk_fn_ptr(converted_sig)
+ }
+
// Interns a type/name combination, stores the resulting box in cx.interners,
// and returns the box as cast to an unsafe ptr (see comments for Ty above).
pub fn mk_ty(self, st: TypeVariants<'tcx>) -> Ty<'tcx> {
pub fn mk_mach_int(self, tm: ast::IntTy) -> Ty<'tcx> {
match tm {
- ast::IntTy::Is => self.types.isize,
+ ast::IntTy::Isize => self.types.isize,
ast::IntTy::I8 => self.types.i8,
ast::IntTy::I16 => self.types.i16,
ast::IntTy::I32 => self.types.i32,
ast::IntTy::I64 => self.types.i64,
+ ast::IntTy::I128 => self.types.i128,
}
}
pub fn mk_mach_uint(self, tm: ast::UintTy) -> Ty<'tcx> {
match tm {
- ast::UintTy::Us => self.types.usize,
+ ast::UintTy::Usize => self.types.usize,
ast::UintTy::U8 => self.types.u8,
ast::UintTy::U16 => self.types.u16,
ast::UintTy::U32 => self.types.u32,
ast::UintTy::U64 => self.types.u64,
+ ast::UintTy::U128 => self.types.u128,
}
}
}
pub fn mk_static_str(self) -> Ty<'tcx> {
- self.mk_imm_ref(self.mk_region(ty::ReStatic), self.mk_str())
+ self.mk_imm_ref(self.types.re_static, self.mk_str())
}
- pub fn mk_adt(self, def: AdtDef<'tcx>, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
+ pub fn mk_adt(self, def: &'tcx AdtDef, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
// take a copy of substs so that we own the vectors inside
self.mk_ty(TyAdt(def, substs))
}
+ pub fn mk_foreign(self, def_id: DefId) -> Ty<'tcx> {
+ self.mk_ty(TyForeign(def_id))
+ }
+
pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> {
- self.mk_ty(TyBox(ty))
+ let def_id = self.require_lang_item(lang_items::OwnedBoxLangItem);
+ let adt_def = self.adt_def(def_id);
+ let generics = self.generics_of(def_id);
+ let mut substs = vec![Kind::from(ty)];
+ // Add defaults for other generic params if there are some.
+ for def in generics.types.iter().skip(1) {
+ assert!(def.has_default);
+ let ty = self.type_of(def.def_id).subst(self, &substs);
+ substs.push(ty.into());
+ }
+ let substs = self.mk_substs(substs.into_iter());
+ self.mk_ty(TyAdt(adt_def, substs))
}
pub fn mk_ptr(self, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
self.mk_ty(TyRawPtr(tm))
}
- pub fn mk_ref(self, r: &'tcx Region, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
+ pub fn mk_ref(self, r: Region<'tcx>, tm: TypeAndMut<'tcx>) -> Ty<'tcx> {
self.mk_ty(TyRef(r, tm))
}
- pub fn mk_mut_ref(self, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> {
+ pub fn mk_mut_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutMutable})
}
- pub fn mk_imm_ref(self, r: &'tcx Region, ty: Ty<'tcx>) -> Ty<'tcx> {
+ pub fn mk_imm_ref(self, r: Region<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
self.mk_ref(r, TypeAndMut {ty: ty, mutbl: hir::MutImmutable})
}
self.mk_imm_ptr(self.mk_nil())
}
- pub fn mk_array(self, ty: Ty<'tcx>, n: usize) -> Ty<'tcx> {
- self.mk_ty(TyArray(ty, n))
+ pub fn mk_array(self, ty: Ty<'tcx>, n: u64) -> Ty<'tcx> {
+ self.mk_ty(TyArray(ty, self.mk_const(ty::Const {
+ val: ConstVal::Value(Value::ByVal(PrimVal::Bytes(n.into()))),
+ ty: self.types.usize
+ })))
}
pub fn mk_slice(self, ty: Ty<'tcx>) -> Ty<'tcx> {
self.mk_ty(TySlice(ty))
}
- pub fn mk_tup(self, ts: Vec<Ty<'tcx>>) -> Ty<'tcx> {
- self.mk_ty(TyTuple(self.mk_type_list(ts)))
+ pub fn intern_tup(self, ts: &[Ty<'tcx>]) -> Ty<'tcx> {
+ self.mk_ty(TyTuple(self.intern_type_list(ts)))
+ }
+
+ pub fn mk_tup<I: InternAs<[Ty<'tcx>], Ty<'tcx>>>(self, iter: I) -> I::Output {
+ iter.intern_with(|ts| self.mk_ty(TyTuple(self.intern_type_list(ts))))
}
pub fn mk_nil(self) -> Ty<'tcx> {
- self.mk_tup(Vec::new())
+ self.intern_tup(&[])
}
pub fn mk_diverging_default(self) -> Ty<'tcx> {
- if self.sess.features.borrow().never_type {
+ if self.features().never_type {
self.types.never
} else {
- self.mk_nil()
+ self.intern_tup(&[])
}
}
}
pub fn mk_fn_def(self, def_id: DefId,
- substs: &'tcx Substs<'tcx>,
- fty: &'tcx BareFnTy<'tcx>) -> Ty<'tcx> {
- self.mk_ty(TyFnDef(def_id, substs, fty))
+ substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
+ self.mk_ty(TyFnDef(def_id, substs))
}
- pub fn mk_fn_ptr(self, fty: &'tcx BareFnTy<'tcx>) -> Ty<'tcx> {
+ pub fn mk_fn_ptr(self, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
self.mk_ty(TyFnPtr(fty))
}
- pub fn mk_trait(self, mut obj: TraitObject<'tcx>) -> Ty<'tcx> {
- obj.projection_bounds.sort_by_key(|b| b.sort_key(self));
- self.mk_ty(TyTrait(box obj))
+ pub fn mk_dynamic(
+ self,
+ obj: ty::Binder<&'tcx Slice<ExistentialPredicate<'tcx>>>,
+ reg: ty::Region<'tcx>
+ ) -> Ty<'tcx> {
+ self.mk_ty(TyDynamic(obj, reg))
}
pub fn mk_projection(self,
- trait_ref: TraitRef<'tcx>,
- item_name: Name)
- -> Ty<'tcx> {
- // take a copy of substs so that we own the vectors inside
- let inner = ProjectionTy { trait_ref: trait_ref, item_name: item_name };
- self.mk_ty(TyProjection(inner))
- }
+ item_def_id: DefId,
+ substs: &'tcx Substs<'tcx>)
+ -> Ty<'tcx> {
+ self.mk_ty(TyProjection(ProjectionTy {
+ item_def_id,
+ substs,
+ }))
+ }
pub fn mk_closure(self,
closure_id: DefId,
- substs: &'tcx Substs<'tcx>,
- tys: Vec<Ty<'tcx>>)
+ substs: ClosureSubsts<'tcx>)
-> Ty<'tcx> {
- self.mk_closure_from_closure_substs(closure_id, ClosureSubsts {
- func_substs: substs,
- upvar_tys: self.mk_type_list(tys)
- })
+ self.mk_closure_from_closure_substs(closure_id, substs)
}
pub fn mk_closure_from_closure_substs(self,
self.mk_ty(TyClosure(closure_id, closure_substs))
}
+ pub fn mk_generator(self,
+ id: DefId,
+ closure_substs: ClosureSubsts<'tcx>,
+ interior: GeneratorInterior<'tcx>)
+ -> Ty<'tcx> {
+ self.mk_ty(TyGenerator(id, closure_substs, interior))
+ }
+
+ pub fn mk_generator_witness(self, types: ty::Binder<&'tcx Slice<Ty<'tcx>>>) -> Ty<'tcx> {
+ self.mk_ty(TyGeneratorWitness(types))
+ }
+
pub fn mk_var(self, v: TyVid) -> Ty<'tcx> {
self.mk_infer(TyVar(v))
}
pub fn mk_param(self,
index: u32,
- name: Name) -> Ty<'tcx> {
+ name: InternedString) -> Ty<'tcx> {
self.mk_ty(TyParam(ParamTy { idx: index, name: name }))
}
pub fn mk_self_type(self) -> Ty<'tcx> {
- self.mk_param(0, keywords::SelfType.name())
+ self.mk_param(0, keywords::SelfType.name().as_interned_str())
}
pub fn mk_param_from_def(self, def: &ty::TypeParameterDef) -> Ty<'tcx> {
self.mk_ty(TyAnon(def_id, substs))
}
- pub fn trait_items(self, trait_did: DefId) -> Rc<Vec<ty::ImplOrTraitItem<'gcx>>> {
- self.trait_items_cache.memoize(trait_did, || {
- let def_ids = self.impl_or_trait_items(trait_did);
- Rc::new(def_ids.iter()
- .map(|&def_id| self.impl_or_trait_item(def_id))
- .collect())
+ pub fn intern_existential_predicates(self, eps: &[ExistentialPredicate<'tcx>])
+ -> &'tcx Slice<ExistentialPredicate<'tcx>> {
+ assert!(!eps.is_empty());
+ assert!(eps.windows(2).all(|w| w[0].cmp(self, &w[1]) != Ordering::Greater));
+ self._intern_existential_predicates(eps)
+ }
+
+ pub fn intern_predicates(self, preds: &[Predicate<'tcx>])
+ -> &'tcx Slice<Predicate<'tcx>> {
+ // FIXME consider asking the input slice to be sorted to avoid
+ // re-interning permutations, in which case that would be asserted
+ // here.
+ if preds.len() == 0 {
+ // The macro-generated method below asserts we don't intern an empty slice.
+ Slice::empty()
+ } else {
+ self._intern_predicates(preds)
+ }
+ }
+
+ pub fn intern_type_list(self, ts: &[Ty<'tcx>]) -> &'tcx Slice<Ty<'tcx>> {
+ if ts.len() == 0 {
+ Slice::empty()
+ } else {
+ self._intern_type_list(ts)
+ }
+ }
+
+ pub fn intern_substs(self, ts: &[Kind<'tcx>]) -> &'tcx Slice<Kind<'tcx>> {
+ if ts.len() == 0 {
+ Slice::empty()
+ } else {
+ self._intern_substs(ts)
+ }
+ }
+
+ pub fn intern_canonical_var_infos(self, ts: &[CanonicalVarInfo]) -> CanonicalVarInfos<'gcx> {
+ if ts.len() == 0 {
+ Slice::empty()
+ } else {
+ self.global_tcx()._intern_canonical_var_infos(ts)
+ }
+ }
+
+ pub fn intern_clauses(self, ts: &[Clause<'tcx>]) -> Clauses<'tcx> {
+ if ts.len() == 0 {
+ Slice::empty()
+ } else {
+ self._intern_clauses(ts)
+ }
+ }
+
+ pub fn intern_goals(self, ts: &[Goal<'tcx>]) -> Goals<'tcx> {
+ if ts.len() == 0 {
+ Slice::empty()
+ } else {
+ self._intern_goals(ts)
+ }
+ }
+
+ pub fn mk_fn_sig<I>(self,
+ inputs: I,
+ output: I::Item,
+ variadic: bool,
+ unsafety: hir::Unsafety,
+ abi: abi::Abi)
+ -> <I::Item as InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>>::Output
+ where I: Iterator,
+ I::Item: InternIteratorElement<Ty<'tcx>, ty::FnSig<'tcx>>
+ {
+ inputs.chain(iter::once(output)).intern_with(|xs| ty::FnSig {
+ inputs_and_output: self.intern_type_list(xs),
+ variadic, unsafety, abi
})
}
- /// Obtain the representation annotation for a struct definition.
- pub fn lookup_repr_hints(self, did: DefId) -> Rc<Vec<attr::ReprAttr>> {
- self.repr_hint_cache.memoize(did, || {
- Rc::new(self.get_attrs(did).iter().flat_map(|meta| {
- attr::find_repr_attrs(self.sess.diagnostic(), meta).into_iter()
- }).collect())
+ pub fn mk_existential_predicates<I: InternAs<[ExistentialPredicate<'tcx>],
+ &'tcx Slice<ExistentialPredicate<'tcx>>>>(self, iter: I)
+ -> I::Output {
+ iter.intern_with(|xs| self.intern_existential_predicates(xs))
+ }
+
+ pub fn mk_predicates<I: InternAs<[Predicate<'tcx>],
+ &'tcx Slice<Predicate<'tcx>>>>(self, iter: I)
+ -> I::Output {
+ iter.intern_with(|xs| self.intern_predicates(xs))
+ }
+
+ pub fn mk_type_list<I: InternAs<[Ty<'tcx>],
+ &'tcx Slice<Ty<'tcx>>>>(self, iter: I) -> I::Output {
+ iter.intern_with(|xs| self.intern_type_list(xs))
+ }
+
+ pub fn mk_substs<I: InternAs<[Kind<'tcx>],
+ &'tcx Slice<Kind<'tcx>>>>(self, iter: I) -> I::Output {
+ iter.intern_with(|xs| self.intern_substs(xs))
+ }
+
+ pub fn mk_substs_trait(self,
+ s: Ty<'tcx>,
+ t: &[Ty<'tcx>])
+ -> &'tcx Substs<'tcx>
+ {
+ self.mk_substs(iter::once(s).chain(t.into_iter().cloned()).map(Kind::from))
+ }
+
+ pub fn mk_clauses<I: InternAs<[Clause<'tcx>], Clauses<'tcx>>>(self, iter: I) -> I::Output {
+ iter.intern_with(|xs| self.intern_clauses(xs))
+ }
+
+ pub fn mk_goals<I: InternAs<[Goal<'tcx>], Goals<'tcx>>>(self, iter: I) -> I::Output {
+ iter.intern_with(|xs| self.intern_goals(xs))
+ }
+
+ pub fn mk_goal(self, goal: Goal<'tcx>) -> &'tcx Goal {
+ &self.mk_goals(iter::once(goal))[0]
+ }
+
+ pub fn lint_node<S: Into<MultiSpan>>(self,
+ lint: &'static Lint,
+ id: NodeId,
+ span: S,
+ msg: &str) {
+ self.struct_span_lint_node(lint, id, span.into(), msg).emit()
+ }
+
+ pub fn lint_node_note<S: Into<MultiSpan>>(self,
+ lint: &'static Lint,
+ id: NodeId,
+ span: S,
+ msg: &str,
+ note: &str) {
+ let mut err = self.struct_span_lint_node(lint, id, span.into(), msg);
+ err.note(note);
+ err.emit()
+ }
+
+ pub fn lint_level_at_node(self, lint: &'static Lint, mut id: NodeId)
+ -> (lint::Level, lint::LintSource)
+ {
+ // Right now we insert a `with_ignore` node in the dep graph here to
+ // ignore the fact that `lint_levels` below depends on the entire crate.
+ // For now this'll prevent false positives of recompiling too much when
+ // anything changes.
+ //
+ // Once red/green incremental compilation lands we should be able to
+ // remove this because while the crate changes often the lint level map
+ // will change rarely.
+ self.dep_graph.with_ignore(|| {
+ let sets = self.lint_levels(LOCAL_CRATE);
+ loop {
+ let hir_id = self.hir.definitions().node_to_hir_id(id);
+ if let Some(pair) = sets.level_and_source(lint, hir_id, self.sess) {
+ return pair
+ }
+ let next = self.hir.get_parent_node(id);
+ if next == id {
+ bug!("lint traversal reached the root of the crate");
+ }
+ id = next;
+ }
})
}
+
+ pub fn struct_span_lint_node<S: Into<MultiSpan>>(self,
+ lint: &'static Lint,
+ id: NodeId,
+ span: S,
+ msg: &str)
+ -> DiagnosticBuilder<'tcx>
+ {
+ let (level, src) = self.lint_level_at_node(lint, id);
+ lint::struct_lint_level(self.sess, lint, level, src, Some(span.into()), msg)
+ }
+
+ pub fn struct_lint_node(self, lint: &'static Lint, id: NodeId, msg: &str)
+ -> DiagnosticBuilder<'tcx>
+ {
+ let (level, src) = self.lint_level_at_node(lint, id);
+ lint::struct_lint_level(self.sess, lint, level, src, None, msg)
+ }
+
+ pub fn in_scope_traits(self, id: HirId) -> Option<Lrc<StableVec<TraitCandidate>>> {
+ self.in_scope_traits_map(id.owner)
+ .and_then(|map| map.get(&id.local_id).cloned())
+ }
+
+ pub fn named_region(self, id: HirId) -> Option<resolve_lifetime::Region> {
+ self.named_region_map(id.owner)
+ .and_then(|map| map.get(&id.local_id).cloned())
+ }
+
+ pub fn is_late_bound(self, id: HirId) -> bool {
+ self.is_late_bound_map(id.owner)
+ .map(|set| set.contains(&id.local_id))
+ .unwrap_or(false)
+ }
+
+ pub fn object_lifetime_defaults(self, id: HirId)
+ -> Option<Lrc<Vec<ObjectLifetimeDefault>>>
+ {
+ self.object_lifetime_defaults_map(id.owner)
+ .and_then(|map| map.get(&id.local_id).cloned())
+ }
+}
+
+pub trait InternAs<T: ?Sized, R> {
+ type Output;
+ fn intern_with<F>(self, f: F) -> Self::Output
+ where F: FnOnce(&T) -> R;
+}
+
+impl<I, T, R, E> InternAs<[T], R> for I
+ where E: InternIteratorElement<T, R>,
+ I: Iterator<Item=E> {
+ type Output = E::Output;
+ fn intern_with<F>(self, f: F) -> Self::Output
+ where F: FnOnce(&[T]) -> R {
+ E::intern_with(self, f)
+ }
+}
+
+pub trait InternIteratorElement<T, R>: Sized {
+ type Output;
+ fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output;
+}
+
+impl<T, R> InternIteratorElement<T, R> for T {
+ type Output = R;
+ fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
+ f(&iter.collect::<AccumulateVec<[_; 8]>>())
+ }
+}
+
+impl<'a, T, R> InternIteratorElement<T, R> for &'a T
+ where T: Clone + 'a
+{
+ type Output = R;
+ fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
+ f(&iter.cloned().collect::<AccumulateVec<[_; 8]>>())
+ }
+}
+
+impl<T, R, E> InternIteratorElement<T, R> for Result<T, E> {
+ type Output = Result<R, E>;
+ fn intern_with<I: Iterator<Item=Self>, F: FnOnce(&[T]) -> R>(iter: I, f: F) -> Self::Output {
+ Ok(f(&iter.collect::<Result<AccumulateVec<[_; 8]>, _>>()?))
+ }
+}
+
+pub fn provide(providers: &mut ty::maps::Providers) {
+ // FIXME(#44234) - almost all of these queries have no sub-queries and
+ // therefore no actual inputs, they're just reading tables calculated in
+ // resolve! Does this work? Unsure! That's what the issue is about
+ providers.in_scope_traits_map = |tcx, id| tcx.gcx.trait_map.get(&id).cloned();
+ providers.module_exports = |tcx, id| tcx.gcx.export_map.get(&id).cloned();
+ providers.crate_name = |tcx, id| {
+ assert_eq!(id, LOCAL_CRATE);
+ tcx.crate_name
+ };
+ providers.get_lang_items = |tcx, id| {
+ assert_eq!(id, LOCAL_CRATE);
+ // FIXME(#42293) Right now we insert a `with_ignore` node in the dep
+ // graph here to ignore the fact that `get_lang_items` below depends on
+ // the entire crate. For now this'll prevent false positives of
+ // recompiling too much when anything changes.
+ //
+ // Once red/green incremental compilation lands we should be able to
+ // remove this because while the crate changes often the lint level map
+ // will change rarely.
+ tcx.dep_graph.with_ignore(|| Lrc::new(middle::lang_items::collect(tcx)))
+ };
+ providers.freevars = |tcx, id| tcx.gcx.freevars.get(&id).cloned();
+ providers.maybe_unused_trait_import = |tcx, id| {
+ tcx.maybe_unused_trait_imports.contains(&id)
+ };
+ providers.maybe_unused_extern_crates = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Lrc::new(tcx.maybe_unused_extern_crates.clone())
+ };
+
+ providers.stability_index = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Lrc::new(stability::Index::new(tcx))
+ };
+ providers.lookup_stability = |tcx, id| {
+ assert_eq!(id.krate, LOCAL_CRATE);
+ let id = tcx.hir.definitions().def_index_to_hir_id(id.index);
+ tcx.stability().local_stability(id)
+ };
+ providers.lookup_deprecation_entry = |tcx, id| {
+ assert_eq!(id.krate, LOCAL_CRATE);
+ let id = tcx.hir.definitions().def_index_to_hir_id(id.index);
+ tcx.stability().local_deprecation_entry(id)
+ };
+ providers.extern_mod_stmt_cnum = |tcx, id| {
+ let id = tcx.hir.as_local_node_id(id).unwrap();
+ tcx.cstore.extern_mod_stmt_cnum_untracked(id)
+ };
+ providers.all_crate_nums = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Lrc::new(tcx.cstore.crates_untracked())
+ };
+ providers.postorder_cnums = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Lrc::new(tcx.cstore.postorder_cnums_untracked())
+ };
+ providers.output_filenames = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ tcx.output_filenames.clone()
+ };
+ providers.features_query = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ Lrc::new(tcx.sess.features_untracked().clone())
+ };
+ providers.is_panic_runtime = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ attr::contains_name(tcx.hir.krate_attrs(), "panic_runtime")
+ };
+ providers.is_compiler_builtins = |tcx, cnum| {
+ assert_eq!(cnum, LOCAL_CRATE);
+ attr::contains_name(tcx.hir.krate_attrs(), "compiler_builtins")
+ };
}
projects / rustc.git / blobdiff