Struct ExpressionOnlyStore 

struct ExpressionOnlyStore {
    exprs: Arena<Expr>,
    pats: Arena<Pat>,
    bindings: Arena<Binding>,
    labels: Arena<Label>,
    binding_owners: FxHashMap<BindingId, ExprId>,
    block_scopes: Box<[BlockId]>,
    ident_hygiene: FxHashMap<ExprOrPatIdPacked, HygieneId>,
    expr_roots: SmallVec<[ExprRoot; 1]>,
}

Fields

exprs: Arena<Expr>

pats: Arena<Pat>

bindings: Arena<Binding>

labels: Arena<Label>

binding_owners: FxHashMap<BindingId, ExprId>

Id of the closure/coroutine/anon const that owns the corresponding binding. If a binding is owned by the top level expression, it will not be listed in here.

block_scopes: Box<[BlockId]>

Block expressions in this store that may contain inner items.

ident_hygiene: FxHashMap<ExprOrPatIdPacked, HygieneId>

A map from an variable usages to their hygiene ID.

Expressions (and destructuring patterns) that can be recorded here are single segment path, although not all single segments path refer to variables and have hygiene (some refer to items, we don’t know at this stage).

expr_roots: SmallVec<[ExprRoot; 1]>

Maps expression roots to their origin.

Note: while every root expr is an inference root (aka. an AnonConst), there could be other roots that do not appear here. This can happen when anon consts are nested, for example:

[
    ();
    {
        // this repeat expr is anon const #1, and *only it* appears in this list.
        [
            ();
            {
                // this repeat expr is anon const #2.
                0
            }
        ];
        0
    }
]

We do this because this allows us to search this list using a binary search, and it does not bother us because we use this list for two things: constructing ExprScopes, which works fine with nested exprs, and retrieving inference results, and we copy the inner const’s inference into the outer const.

Trait Implementations

impl Clone for ExpressionOnlyStore

fn clone(&self) -> ExpressionOnlyStore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExpressionOnlyStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for ExpressionOnlyStore

impl PartialEq for ExpressionOnlyStore

fn eq(&self, other: &ExpressionOnlyStore) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ExpressionOnlyStore