Struct Body

pub struct Body {
    pub exprs: Arena<Expr>,
    pub pats: Arena<Pat>,
    pub bindings: Arena<Binding>,
    pub labels: Arena<Label>,
    pub binding_owners: FxHashMap<BindingId, ExprId>,
    pub params: Box<[PatId]>,
    pub self_param: Option<BindingId>,
    pub body_expr: ExprId,
    pub types: TypesMap,
    /* private fields */
}

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

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.

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.

types: TypesMap

Implementations

impl Body

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 body that define inner items.

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

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 Body

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

Formats the value using the given formatter.

impl Default for Body

fn default() -> Self

Returns the “default value” for a type.

impl Index<Idx<Binding>> for Body

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 Body

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 Body

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 Body

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 Body

type Output = TypeRef

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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