use crate::util::common::ErrorReported;
use crate::util::nodemap::{DefIdMap, DefIdSet, ItemLocalMap, ItemLocalSet};
use crate::util::nodemap::{FxHashMap, FxHashSet};
+use crate::util::profiling::SelfProfilerRef;
use errors::DiagnosticBuilder;
use arena::SyncDroplessArena;
pub substs: SubstsRef<'tcx>,
}
+/// Whenever a value may be live across a generator yield, the type of that value winds up in the
+/// `GeneratorInteriorTypeCause` struct. This struct adds additional information about such
+/// captured types that can be useful for diagnostics. In particular, it stores the span that
+/// caused a given type to be recorded, along with the scope that enclosed the value (which can
+/// be used to find the await that the value is live across).
+///
+/// For example:
+///
+/// ```ignore (pseudo-Rust)
+/// async move {
+/// let x: T = ...;
+/// foo.await
+/// ...
+/// }
+/// ```
+///
+/// Here, we would store the type `T`, the span of the value `x`, and the "scope-span" for
+/// the scope that contains `x`.
+#[derive(RustcEncodable, RustcDecodable, Clone, Debug, Eq, Hash, HashStable, PartialEq)]
+pub struct GeneratorInteriorTypeCause<'tcx> {
+ /// Type of the captured binding.
+ pub ty: Ty<'tcx>,
+ /// Span of the binding that was captured.
+ pub span: Span,
+ /// Span of the scope of the captured binding.
+ pub scope_span: Option<Span>,
+}
+
+BraceStructTypeFoldableImpl! {
+ impl<'tcx> TypeFoldable<'tcx> for GeneratorInteriorTypeCause<'tcx> {
+ ty, span, scope_span
+ }
+}
+
#[derive(RustcEncodable, RustcDecodable, Debug)]
pub struct TypeckTables<'tcx> {
/// The HirId::owner all ItemLocalIds in this table are relative to.
/// leading to the member of the struct or tuple that is used instead of the
/// entire variable.
pub upvar_list: ty::UpvarListMap,
+
+ /// Stores the type, span and optional scope span of all types
+ /// that are live across the yield of this generator (if a generator).
+ pub generator_interior_types: Vec<GeneratorInteriorTypeCause<'tcx>>,
}
impl<'tcx> TypeckTables<'tcx> {
free_region_map: Default::default(),
concrete_opaque_types: Default::default(),
upvar_list: Default::default(),
+ generator_interior_types: Default::default(),
}
}
ref free_region_map,
ref concrete_opaque_types,
ref upvar_list,
+ ref generator_interior_types,
} = *self;
free_region_map.hash_stable(hcx, hasher);
concrete_opaque_types.hash_stable(hcx, hasher);
upvar_list.hash_stable(hcx, hasher);
+ generator_interior_types.hash_stable(hcx, hasher);
})
}
}
pub dep_graph: DepGraph,
+ pub prof: SelfProfilerRef,
+
/// Common objects.
pub common: Common<'tcx>,
arena: WorkerLocal::new(|_| Arena::default()),
interners,
dep_graph,
+ prof: s.prof.clone(),
common,
types: common_types,
lifetimes: common_lifetimes,
}
}
-macro_rules! intern_method {
- ($lt_tcx:tt, $name:ident: $method:ident($alloc:ty,
- $alloc_method:expr,
- $alloc_to_key:expr) -> $ty:ty) => {
- impl<$lt_tcx> TyCtxt<$lt_tcx> {
- pub fn $method(self, v: $alloc) -> &$lt_tcx $ty {
- let key = ($alloc_to_key)(&v);
-
- self.interners.$name.intern_ref(key, || {
- Interned($alloc_method(&self.interners.arena, v))
-
- }).0
- }
- }
- }
-}
-
macro_rules! direct_interners {
- ($lt_tcx:tt, $($name:ident: $method:ident($ty:ty)),+) => {
- $(impl<$lt_tcx> PartialEq for Interned<$lt_tcx, $ty> {
+ ($($name:ident: $method:ident($ty:ty)),+) => {
+ $(impl<'tcx> PartialEq for Interned<'tcx, $ty> {
fn eq(&self, other: &Self) -> bool {
self.0 == other.0
}
}
- impl<$lt_tcx> Eq for Interned<$lt_tcx, $ty> {}
+ impl<'tcx> Eq for Interned<'tcx, $ty> {}
- impl<$lt_tcx> Hash for Interned<$lt_tcx, $ty> {
+ impl<'tcx> Hash for Interned<'tcx, $ty> {
fn hash<H: Hasher>(&self, s: &mut H) {
self.0.hash(s)
}
}
- intern_method!(
- $lt_tcx,
- $name: $method($ty,
- |a: &$lt_tcx SyncDroplessArena, v| -> &$lt_tcx $ty { a.alloc(v) },
- |x| x) -> $ty);)+
+ impl<'tcx> TyCtxt<'tcx> {
+ pub fn $method(self, v: $ty) -> &'tcx $ty {
+ self.interners.$name.intern_ref(&v, || {
+ Interned(self.interners.arena.alloc(v))
+ }).0
+ }
+ })+
}
}
x.has_type_flags(ty::TypeFlags::KEEP_IN_LOCAL_TCX)
}
-direct_interners!('tcx,
+direct_interners!(
region: mk_region(RegionKind),
goal: mk_goal(GoalKind<'tcx>),
const_: mk_const(Const<'tcx>)
macro_rules! slice_interners {
($($field:ident: $method:ident($ty:ty)),+) => (
- $(intern_method!( 'tcx, $field: $method(
- &[$ty],
- |a, v| List::from_arena(a, v),
- Deref::deref) -> List<$ty>);)+
+ $(impl<'tcx> TyCtxt<'tcx> {
+ pub fn $method(self, v: &[$ty]) -> &'tcx List<$ty> {
+ self.interners.$field.intern_ref(v, || {
+ Interned(List::from_arena(&self.interners.arena, v))
+ }).0
+ }
+ })+
);
}
slice_interners!(
- existential_predicates: _intern_existential_predicates(ExistentialPredicate<'tcx>),
- predicates: _intern_predicates(Predicate<'tcx>),
type_list: _intern_type_list(Ty<'tcx>),
substs: _intern_substs(GenericArg<'tcx>),
+ canonical_var_infos: _intern_canonical_var_infos(CanonicalVarInfo),
+ existential_predicates: _intern_existential_predicates(ExistentialPredicate<'tcx>),
+ predicates: _intern_predicates(Predicate<'tcx>),
clauses: _intern_clauses(Clause<'tcx>),
goal_list: _intern_goals(Goal<'tcx>),
projs: _intern_projs(ProjectionKind)
);
-// This isn't a perfect fit: `CanonicalVarInfo` slices are always
-// allocated in the global arena, so this `intern_method!` macro is
-// overly general. However, 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],
- |a, v| List::from_arena(a, v),
- Deref::deref
- ) -> List<CanonicalVarInfo>
-}
-
impl<'tcx> TyCtxt<'tcx> {
/// Given a `fn` type, returns an equivalent `unsafe fn` type;
/// that is, a `fn` type that is equivalent in every way for being
projects / rust.git / blobdiff