Struct Body

pub struct Body {
    pub store: ExpressionStore,
    pub params: Box<[PatId]>,
    pub self_param: Option<BindingId>,
    pub body_expr: ExprId,
}

The body of an item (function, const etc.).

Fields

store: ExpressionStore

params: Box<[PatId]>

The patterns for the function’s parameters. While the parameter types are part of the function signature, the patterns are not (they don’t change the external type of the function).

If this Body is for the body of a constant, this will just be empty.

self_param: Option<BindingId>

body_expr: ExprId

The ExprId of the actual body expression.

Implementations

impl Body

pub fn pretty_print( &self, db: &dyn DefDatabase, owner: DefWithBodyId, edition: Edition, ) -> String

pub fn pretty_print_expr( &self, db: &dyn DefDatabase, owner: DefWithBodyId, expr: ExprId, edition: Edition, ) -> String

pub fn pretty_print_pat( &self, db: &dyn DefDatabase, owner: DefWithBodyId, pat: PatId, oneline: bool, edition: Edition, ) -> String

Methods from Deref<Target = ExpressionStore>

pub fn blocks<'a>( &'a self, db: &'a dyn DefDatabase, ) -> 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 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 binding_owner(&self, id: BindingId) -> Option<ExprId>

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

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

Note that this does not walk const blocks.

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

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

Note that this does not walk const blocks.

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

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)>

Trait Implementations

impl Debug for Body

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

Formats the value using the given formatter.

impl Deref for Body

type Target = ExpressionStore

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl PartialEq for Body

fn eq(&self, other: &Body) -> 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 Body

impl StructuralPartialEq for Body