Struct rustc::middle::region::ScopeTree [−][src]
pub struct ScopeTree { root_body: Option<HirId>, root_parent: Option<NodeId>, parent_map: FxHashMap<Scope, (Scope, ScopeDepth)>, var_map: FxHashMap<ItemLocalId, Scope>, destruction_scopes: FxHashMap<ItemLocalId, Scope>, rvalue_scopes: FxHashMap<ItemLocalId, Option<Scope>>, closure_tree: FxHashMap<ItemLocalId, ItemLocalId>, yield_in_scope: FxHashMap<Scope, (Span, usize)>, body_expr_count: FxHashMap<BodyId, usize>, }
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
The region scope tree encodes information about region relationships.
Fields
root_body: Option<HirId>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
If not empty, this body is the root of this region hierarchy.
root_parent: Option<NodeId>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
The parent of the root body owner, if the latter is an an associated const or method, as impls/traits can also have lifetime parameters free in this body.
parent_map: FxHashMap<Scope, (Scope, ScopeDepth)>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
parent_map
maps from a scope id to the enclosing scope id;
this is usually corresponding to the lexical nesting, though
in the case of closures the parent scope is the innermost
conditional expression or repeating block. (Note that the
enclosing scope id for the block associated with a closure is
the closure itself.)
var_map: FxHashMap<ItemLocalId, Scope>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
var_map
maps from a variable or binding id to the block in
which that variable is declared.
destruction_scopes: FxHashMap<ItemLocalId, Scope>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
maps from a node-id to the associated destruction scope (if any)
rvalue_scopes: FxHashMap<ItemLocalId, Option<Scope>>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
rvalue_scopes
includes entries for those expressions whose cleanup scope is
larger than the default. The map goes from the expression id
to the cleanup scope id. For rvalues not present in this
table, the appropriate cleanup scope is the innermost
enclosing statement, conditional expression, or repeating
block (see terminating_scopes
).
In constants, None is used to indicate that certain expressions
escape into 'static and should have no local cleanup scope.
closure_tree: FxHashMap<ItemLocalId, ItemLocalId>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Encodes the hierarchy of fn bodies. Every fn body (including closures) forms its own distinct region hierarchy, rooted in the block that is the fn body. This map points from the id of that root block to the id of the root block for the enclosing fn, if any. Thus the map structures the fn bodies into a hierarchy based on their lexical mapping. This is used to handle the relationships between regions in a fn and in a closure defined by that fn. See the "Modeling closures" section of the README in infer::region_constraints for more details.
yield_in_scope: FxHashMap<Scope, (Span, usize)>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
If there are any yield
nested within a scope, this map
stores the Span
of the last one and its index in the
postorder of the Visitor traversal on the HIR.
HIR Visitor postorder indexes might seem like a peculiar thing to care about. but it turns out that HIR bindings and the temporary results of HIR expressions are never storage-live at the end of HIR nodes with postorder indexes lower than theirs, and therefore don't need to be suspended at yield-points at these indexes.
For an example, suppose we have some code such as:
foo(f(), yield y, bar(g()))
With the HIR tree (calls numbered for expository purposes)
Call#0(foo, [Call#1(f), Yield(y), Call#2(bar, Call#3(g))])
Obviously, the result of f()
was created before the yield
(and therefore needs to be kept valid over the yield) while
the result of g()
occurs after the yield (and therefore
doesn't). If we want to infer that, we can look at the
postorder traversal:
`foo` `f` Call#1 `y` Yield `bar` `g` Call#3 Call#2 Call#0
In which we can easily see that Call#1
occurs before the yield,
and Call#3
after it.
To see that this method works, consider:
Let D
be our binding/temporary and U
be our other HIR node, with
HIR-postorder(U) < HIR-postorder(D)
(in our example, U would be
the yield and D would be one of the calls). Let's show that
D
is storage-dead at U
.
Remember that storage-live/storage-dead refers to the state of the storage, and does not consider moves/drop flags.
Then:
1. From the ordering guarantee of HIR visitors (see
rustc::hir::intravisit
), D
does not dominate U
.
2. Therefore, D
is potentially storage-dead at U
(because
we might visit U
without ever getting to D
).
3. However, we guarantee that at each HIR point, each
binding/temporary is always either always storage-live
or always storage-dead. This is what is being guaranteed
by terminating_scopes
including all blocks where the
count of executions is not guaranteed.
4. By 2.
and 3.
, D
is statically storage-dead at U
,
QED.
I don't think this property relies on 3.
in an essential way - it
is probably still correct even if we have "unrestricted" terminating
scopes. However, why use the complicated proof when a simple one
works?
A subtle thing: box
expressions, such as box (&x, yield 2, &y)
. It
might seem that a box
expression creates a Box<T>
temporary
when it starts executing, at HIR-preorder(BOX-EXPR)
. That might
be true in the MIR desugaring, but it is not important in the semantics.
The reason is that semantically, until the box
expression returns,
the values are still owned by their containing expressions. So
we'll see that &x
.
body_expr_count: FxHashMap<BodyId, usize>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
The number of visit_expr and visit_pat calls done in the body. Used to sanity check visit_expr/visit_pat call count when calculating generator interiors.
Methods
impl<'tcx> ScopeTree
[src]
impl<'tcx> ScopeTree
pub fn record_scope_parent(
&mut self,
child: Scope,
parent: Option<(Scope, ScopeDepth)>
)
[src]
pub fn record_scope_parent(
&mut self,
child: Scope,
parent: Option<(Scope, ScopeDepth)>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn each_encl_scope<E>(&self, e: E) where
E: FnMut(Scope, Scope),
[src]
pub fn each_encl_scope<E>(&self, e: E) where
E: FnMut(Scope, Scope),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn each_var_scope<E>(&self, e: E) where
E: FnMut(&ItemLocalId, Scope),
[src]
pub fn each_var_scope<E>(&self, e: E) where
E: FnMut(&ItemLocalId, Scope),
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn opt_destruction_scope(&self, n: ItemLocalId) -> Option<Scope>
[src]
pub fn opt_destruction_scope(&self, n: ItemLocalId) -> Option<Scope>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn record_closure_parent(
&mut self,
sub_closure: ItemLocalId,
sup_closure: ItemLocalId
)
[src]
fn record_closure_parent(
&mut self,
sub_closure: ItemLocalId,
sup_closure: ItemLocalId
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Records that sub_closure
is defined within sup_closure
. These ids
should be the id of the block that is the fn body, which is
also the root of the region hierarchy for that fn.
fn record_var_scope(&mut self, var: ItemLocalId, lifetime: Scope)
[src]
fn record_var_scope(&mut self, var: ItemLocalId, lifetime: Scope)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
fn record_rvalue_scope(&mut self, var: ItemLocalId, lifetime: Option<Scope>)
[src]
fn record_rvalue_scope(&mut self, var: ItemLocalId, lifetime: Option<Scope>)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn opt_encl_scope(&self, id: Scope) -> Option<Scope>
[src]
pub fn opt_encl_scope(&self, id: Scope) -> Option<Scope>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns the narrowest scope that encloses id
, if any.
pub fn encl_scope(&self, id: Scope) -> Scope
[src]
pub fn encl_scope(&self, id: Scope) -> Scope
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns the narrowest scope that encloses id
, if any.
pub fn var_scope(&self, var_id: ItemLocalId) -> Scope
[src]
pub fn var_scope(&self, var_id: ItemLocalId) -> Scope
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns the lifetime of the local variable var_id
pub fn temporary_scope(&self, expr_id: ItemLocalId) -> Option<Scope>
[src]
pub fn temporary_scope(&self, expr_id: ItemLocalId) -> Option<Scope>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns the scope when temp created by expr_id will be cleaned up
pub fn var_region(&self, id: ItemLocalId) -> RegionKind
[src]
pub fn var_region(&self, id: ItemLocalId) -> RegionKind
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns the lifetime of the variable id
.
pub fn scopes_intersect(&self, scope1: Scope, scope2: Scope) -> bool
[src]
pub fn scopes_intersect(&self, scope1: Scope, scope2: Scope) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
pub fn is_subscope_of(&self, subscope: Scope, superscope: Scope) -> bool
[src]
pub fn is_subscope_of(&self, subscope: Scope, superscope: Scope) -> bool
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns true if subscope
is equal to or is lexically nested inside superscope
and false
otherwise.
pub fn containing_body(&self, scope: Scope) -> Option<ItemLocalId>
[src]
pub fn containing_body(&self, scope: Scope) -> Option<ItemLocalId>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Returns the id of the innermost containing body
pub fn nearest_common_ancestor(&self, scope_a: Scope, scope_b: Scope) -> Scope
[src]
pub fn nearest_common_ancestor(&self, scope_a: Scope, scope_b: Scope) -> Scope
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Finds the nearest common ancestor of two scopes. That is, finds the
smallest scope which is greater than or equal to both scope_a
and
scope_b
.
pub fn early_free_scope<'a, 'gcx>(
&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
br: &EarlyBoundRegion
) -> Scope
[src]
pub fn early_free_scope<'a, 'gcx>(
&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
br: &EarlyBoundRegion
) -> Scope
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Assuming that the provided region was defined within this ScopeTree
,
returns the outermost Scope
that the region outlives.
pub fn free_scope<'a, 'gcx>(
&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
fr: &FreeRegion
) -> Scope
[src]
pub fn free_scope<'a, 'gcx>(
&self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
fr: &FreeRegion
) -> Scope
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Assuming that the provided region was defined within this ScopeTree
,
returns the outermost Scope
that the region outlives.
pub fn yield_in_scope(&self, scope: Scope) -> Option<(Span, usize)>
[src]
pub fn yield_in_scope(&self, scope: Scope) -> Option<(Span, usize)>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Checks whether the given scope contains a yield
. If so,
returns Some((span, expr_count))
with the span of a yield we found and
the number of expressions and patterns appearing before the yield
in the body + 1.
If there a are multiple yields in a scope, the one with the highest number is returned.
pub fn yield_in_scope_for_expr(
&self,
scope: Scope,
expr: NodeId,
body: &'tcx Body
) -> Option<Span>
[src]
pub fn yield_in_scope_for_expr(
&self,
scope: Scope,
expr: NodeId,
body: &'tcx Body
) -> Option<Span>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Checks whether the given scope contains a yield
and if that yield could execute
after expr
. If so, it returns the span of that yield
.
scope
must be inside the body.
pub fn body_expr_count(&self, body_id: BodyId) -> Option<usize>
[src]
pub fn body_expr_count(&self, body_id: BodyId) -> Option<usize>
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?
Gives the number of expressions visited in a body. Used to sanity check visit_expr call count when calculating generator interiors.
Trait Implementations
impl Default for ScopeTree
[src]
impl Default for ScopeTree
impl Debug for ScopeTree
[src]
impl Debug for ScopeTree
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl<'a> HashStable<StableHashingContext<'a>> for ScopeTree
[src]
impl<'a> HashStable<StableHashingContext<'a>> for ScopeTree
fn hash_stable<W: StableHasherResult>(
&self,
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>
)
[src]
fn hash_stable<W: StableHasherResult>(
&self,
hcx: &mut StableHashingContext<'a>,
hasher: &mut StableHasher<W>
)
🔬 This is a nightly-only experimental API. (rustc_private
)
this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml
instead?