Struct ExpressionStore

pub struct ExpressionStore {
    pub exprs: Arena<Expr>,
    pub pats: Arena<Pat>,
    pub bindings: Arena<Binding>,
    pub labels: Arena<Label>,
    pub binding_owners: FxHashMap<BindingId, ExprId>,
    pub types: TypesMap,
    /* private fields */
}

Fields

exprs: Arena<Expr>

pats: Arena<Pat>

bindings: Arena<Binding>

labels: Arena<Label>

binding_owners: FxHashMap<BindingId, ExprId>

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

types: TypesMap

Implementations

impl ExpressionStore

pub fn blocks<'a>( &'a self, db: &'a dyn DefDatabase, ) -> impl Iterator<Item = (BlockId, Arc<DefMap>)> + 'a

Returns an iterator over all block expressions in this store that define inner items.

pub fn walk_bindings_in_pat(&self, pat_id: PatId, f: impl FnMut(BindingId))

pub fn walk_pats_shallow(&self, pat_id: PatId, f: impl FnMut(PatId))

pub fn walk_pats(&self, pat_id: PatId, f: &mut impl FnMut(PatId))

pub fn is_binding_upvar(&self, binding: BindingId, relative_to: ExprId) -> bool

pub fn walk_child_exprs(&self, expr_id: ExprId, f: impl FnMut(ExprId))

pub fn walk_child_exprs_without_pats( &self, expr_id: ExprId, f: impl FnMut(ExprId), )

pub fn walk_exprs_in_pat(&self, pat_id: PatId, f: &mut impl FnMut(ExprId))

pub fn expr_path_hygiene(&self, expr: ExprId) -> HygieneId

pub fn pat_path_hygiene(&self, pat: PatId) -> HygieneId

pub fn expr_or_pat_path_hygiene(&self, id: ExprOrPatId) -> HygieneId

Trait Implementations

impl Debug for ExpressionStore

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

Formats the value using the given formatter.

impl Index<Idx<Binding>> for ExpressionStore

type Output = Binding

The returned type after indexing.

fn index(&self, b: BindingId) -> &Binding

Performs the indexing (container[index]) operation.

impl Index<Idx<Expr>> for ExpressionStore

type Output = Expr

The returned type after indexing.

fn index(&self, expr: ExprId) -> &Expr

Performs the indexing (container[index]) operation.

impl Index<Idx<Label>> for ExpressionStore

type Output = Label

The returned type after indexing.

fn index(&self, label: LabelId) -> &Label

Performs the indexing (container[index]) operation.

impl Index<Idx<Pat>> for ExpressionStore

type Output = Pat

The returned type after indexing.

fn index(&self, pat: PatId) -> &Pat

Performs the indexing (container[index]) operation.

impl Index<Idx<TypeRef>> for ExpressionStore

type Output = TypeRef

The returned type after indexing.

fn index(&self, b: TypeRefId) -> &TypeRef

Performs the indexing (container[index]) operation.

impl PartialEq for ExpressionStore

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ExpressionStore

impl StructuralPartialEq for ExpressionStore