Struct ExpressionStore 

pub struct ExpressionStore {
    expr_only: Option<Box<ExpressionOnlyStore>>,
    pub types: Arena<TypeRef>,
    pub lifetimes: Arena<LifetimeRef>,
}

Fields

expr_only: Option<Box<ExpressionOnlyStore>>

types: Arena<TypeRef>

lifetimes: Arena<LifetimeRef>

Implementations

impl ExpressionStore

const EMPTY: &ExpressionStore

pub fn empty() -> &'static ExpressionStore

pub fn of( db: &dyn SourceDatabase, def: ExpressionStoreOwnerId, ) -> &ExpressionStore

pub fn with_source_map( db: &dyn SourceDatabase, def: ExpressionStoreOwnerId, ) -> (&ExpressionStore, &ExpressionStoreSourceMap)

pub fn expr_roots(&self) -> impl DoubleEndedIterator<Item = ExprId>

Returns all expression root ExprIds found in this store.

fn find_root_for( &self, get: impl FnMut(&ExprRoot) -> RawIdx, find: RawIdx, ) -> ExprId

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

pub fn find_root_for_pat(&self, pat: PatId) -> ExprId

pub fn find_root_for_binding(&self, binding: BindingId) -> ExprId

pub fn blocks<'a>( &'a self, db: &'a dyn SourceDatabase, ) -> impl Iterator<Item = (BlockId, &'a 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 visit_pat_children(&self, pat_id: PatId, visitor: impl StoreVisitor)

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 binding_owner(&self, id: BindingId) -> Option<ExprId>

pub fn visit_expr_children(&self, expr_id: ExprId, visitor: impl StoreVisitor)

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

Walks the immediate children expressions and calls f for each child expression.

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

Walks the immediate children expressions and calls f for each child expression but does not walk expressions within patterns.

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

pub fn visit_type_ref_children( &self, type_ref: TypeRefId, visitor: impl StoreVisitor, )

fn assert_expr_only(&self) -> &ExpressionOnlyStore

fn binding_hygiene(&self, binding: BindingId) -> HygieneId

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

pub fn exprs(&self) -> impl Iterator<Item = (ExprId, &Expr)>

pub fn pats(&self) -> impl Iterator<Item = (PatId, &Pat)>

pub fn bindings(&self) -> impl Iterator<Item = (BindingId, &Binding)>

pub fn coroutine_for_closure(coroutine_closure: ExprId) -> ExprId

The coroutine associated with a coroutine closure.

pub fn closure_for_coroutine(coroutine: ExprId) -> ExprId

The opposite of Self::coroutine_for_closure().

Trait Implementations

impl Clone for ExpressionStore

fn clone(&self) -> ExpressionStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionStore

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

Formats the value using the given formatter.

impl Eq for ExpressionStore

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<LifetimeRef>> for ExpressionStore

type Output = LifetimeRef

The returned type after indexing.

fn index(&self, b: LifetimeRefId) -> &LifetimeRef

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 Index<PathId> for ExpressionStore

type Output = Path

The returned type after indexing.

fn index(&self, index: PathId) -> &Self::Output

Performs the indexing (container[index]) operation.

impl PartialEq for ExpressionStore

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ExpressionStore