Struct rustc_middle::middle::region::Scope [−][src]
pub struct Scope { pub id: ItemLocalId, pub data: ScopeData, }
Represents a statically-describable scope that can be used to bound the lifetime/region for values.
Node(node_id)
: Any AST node that has any scope at all has the
Node(node_id)
scope. Other variants represent special cases not
immediately derivable from the abstract syntax tree structure.
DestructionScope(node_id)
represents the scope of destructors
implicitly-attached to node_id
that run immediately after the
expression for node_id
itself. Not every AST node carries a
DestructionScope
, but those that are terminating_scopes
do;
see discussion with ScopeTree
.
Remainder { block, statement_index }
represents
the scope of user code running immediately after the initializer
expression for the indexed statement, until the end of the block.
So: the following code can be broken down into the scopes beneath:
let a = f().g( 'b: { let x = d(); let y = d(); x.h(y) } ) ;
+-+ (D12.)
+-+ (D11.)
+---------+ (R10.)
+-+ (D9.)
+----------+ (M8.)
+----------------------+ (R7.)
+-+ (D6.)
+----------+ (M5.)
+-----------------------------------+ (M4.)
+--------------------------------------------------+ (M3.)
+--+ (M2.)
+-----------------------------------------------------------+ (M1.)
(M1.): Node scope of the whole `let a = ...;` statement.
(M2.): Node scope of the `f()` expression.
(M3.): Node scope of the `f().g(..)` expression.
(M4.): Node scope of the block labeled `'b:`.
(M5.): Node scope of the `let x = d();` statement
(D6.): DestructionScope for temporaries created during M5.
(R7.): Remainder scope for block `'b:`, stmt 0 (let x = ...).
(M8.): Node scope of the `let y = d();` statement.
(D9.): DestructionScope for temporaries created during M8.
(R10.): Remainder scope for block `'b:`, stmt 1 (let y = ...).
(D11.): DestructionScope for temporaries and bindings from block `'b:`.
(D12.): DestructionScope for temporaries created during M1 (e.g., f()).
Note that while the above picture shows the destruction scopes as following their corresponding node scopes, in the internal data structures of the compiler the destruction scopes are represented as enclosing parents. This is sound because we use the enclosing parent relationship just to ensure that referenced values live long enough; phrased another way, the starting point of each range is not really the important thing in the above picture, but rather the ending point.
Fields
id: ItemLocalId
data: ScopeData
Implementations
impl Scope
[src]
pub fn item_local_id(&self) -> ItemLocalId
[src]
Returns a item-local ID associated with this scope.
N.B., likely to be replaced as API is refined; e.g., pnkfelix
anticipates fn entry_node_id
and fn each_exit_node_id
.
pub fn hir_id(&self, scope_tree: &ScopeTree) -> Option<HirId>
[src]
pub fn span(&self, tcx: TyCtxt<'_>, scope_tree: &ScopeTree) -> Span
[src]
Returns the span of this Scope
. Note that in general the
returned span may not correspond to the span of any NodeId
in
the AST.
Trait Implementations
impl Clone for Scope
[src]
impl Copy for Scope
[src]
impl Debug for Scope
[src]
impl<'tcx, __D: TyDecoder<'tcx>> Decodable<__D> for Scope
[src]
impl<'tcx, __E: TyEncoder<'tcx>> Encodable<__E> for Scope
[src]
impl Eq for Scope
[src]
impl Hash for Scope
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for Scope
[src]
fn hash_stable(
&self,
__hcx: &mut StableHashingContext<'__ctx>,
__hasher: &mut StableHasher
)
[src]
&self,
__hcx: &mut StableHashingContext<'__ctx>,
__hasher: &mut StableHasher
)
impl<'tcx> Lift<'tcx> for Scope
[src]
type Lifted = Self
fn lift_to_tcx(self, _: TyCtxt<'tcx>) -> Option<Self>
[src]
impl Ord for Scope
[src]
fn cmp(&self, other: &Scope) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl PartialEq<Scope> for Scope
[src]
impl PartialOrd<Scope> for Scope
[src]
fn partial_cmp(&self, other: &Scope) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl StructuralEq for Scope
[src]
impl StructuralPartialEq for Scope
[src]
impl<'a> ToStableHashKey<StableHashingContext<'a>> for Scope
[src]
type KeyType = Scope
fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> Scope
[src]
impl<'tcx> TypeFoldable<'tcx> for Scope
[src]
fn super_fold_with<F: TypeFolder<'tcx>>(self, _: &mut F) -> Scope
[src]
fn super_visit_with<F: TypeVisitor<'tcx>>(
&self,
_: &mut F
) -> ControlFlow<F::BreakTy>
[src]
&self,
_: &mut F
) -> ControlFlow<F::BreakTy>
fn fold_with<F: TypeFolder<'tcx>>(self, folder: &mut F) -> Self
[src]
fn visit_with<V: TypeVisitor<'tcx>>(
&self,
visitor: &mut V
) -> ControlFlow<V::BreakTy>
[src]
&self,
visitor: &mut V
) -> ControlFlow<V::BreakTy>
fn has_vars_bound_at_or_above(&self, binder: DebruijnIndex) -> bool
[src]
fn has_vars_bound_above(&self, binder: DebruijnIndex) -> bool
[src]
fn has_escaping_bound_vars(&self) -> bool
[src]
fn has_type_flags(&self, flags: TypeFlags) -> bool
[src]
fn has_projections(&self) -> bool
[src]
fn has_opaque_types(&self) -> bool
[src]
fn references_error(&self) -> bool
[src]
fn has_param_types_or_consts(&self) -> bool
[src]
fn has_infer_regions(&self) -> bool
[src]
fn has_infer_types(&self) -> bool
[src]
fn has_infer_types_or_consts(&self) -> bool
[src]
fn needs_infer(&self) -> bool
[src]
fn has_placeholders(&self) -> bool
[src]
fn needs_subst(&self) -> bool
[src]
fn has_free_regions(&self) -> bool
[src]
fn has_erased_regions(&self) -> bool
[src]
fn has_erasable_regions(&self) -> bool
[src]
fn is_global(&self) -> bool
[src]
fn has_late_bound_regions(&self) -> bool
[src]
fn still_further_specializable(&self) -> bool
[src]
Auto Trait Implementations
impl RefUnwindSafe for Scope
impl Send for Scope
impl Sync for Scope
impl Unpin for Scope
impl UnwindSafe for Scope
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<'tcx, T> ArenaAllocatable<'tcx, ()> for T where
T: Copy,
[src]
T: Copy,
pub fn allocate_on(Self, &'a Arena<'tcx>) -> &'a mut T
[src]
pub fn allocate_from_iter(
&'a Arena<'tcx>,
impl IntoIterator<Item = T>
) -> &'a mut [T]ⓘ
[src]
&'a Arena<'tcx>,
impl IntoIterator<Item = T>
) -> &'a mut [T]ⓘ
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<'a, T> Captures<'a> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> MaybeResult<T> for T
[src]
type Error = !
pub fn from(Result<T, <T as MaybeResult<T>>::Error>) -> T
[src]
pub fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>
[src]
impl<'tcx, T> Subst<'tcx> for T where
T: TypeFoldable<'tcx>,
[src]
T: TypeFoldable<'tcx>,
pub fn subst_spanned(Self, TyCtxt<'tcx>, &[GenericArg<'tcx>], Option<Span>) -> T
[src]
fn subst(self, tcx: TyCtxt<'tcx>, substs: &[GenericArg<'tcx>]) -> Self
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.