Struct rune::ast::ExprBlock

pub struct ExprBlock {
    pub async_: Option<Async>,
    pub open: OpenBrace,
    pub exprs: Vec<(Expr, Option<SemiColon>)>,
    pub trailing_expr: Option<Box<Expr>>,
    pub close: CloseBrace,
}

A block of expressions.

Fields

async_: Option<Async>

If the block is async or not.

open: OpenBrace

The close brace.

exprs: Vec<(Expr, Option<SemiColon>)>

Expressions in the block.

trailing_expr: Option<Box<Expr>>

Test if the expression is trailing.

close: CloseBrace

The close brace.

Implementations

impl ExprBlock

pub fn span(&self) -> Span

Get the span of the block.

pub fn produces_nothing(&self) -> bool

Test if the block is empty.

pub fn is_const(&self) -> bool

ExprBlock is constant if a trailing expression exists and is all literal.

Trait Implementations

impl Clone for ExprBlock

fn clone(&self) -> ExprBlock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExprBlock

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

Formats the value using the given formatter.

impl Parse for ExprBlock

Parse implementation for a block.

Examples

use rune::{parse_all, ast};

let block = parse_all::<ast::ExprBlock>("async {}")?.item;
assert_eq!(block.exprs.len(), 0);
assert!(block.trailing_expr.is_none());
assert!(block.async_.is_some());

let block = parse_all::<ast::ExprBlock>("{}")?.item;
assert_eq!(block.exprs.len(), 0);
assert!(block.trailing_expr.is_none());

let block = parse_all::<ast::ExprBlock>("{ foo }")?.item;
assert_eq!(block.exprs.len(), 0);
assert!(block.trailing_expr.is_some());

let block = parse_all::<ast::ExprBlock>("{ foo; }")?.item;
assert_eq!(block.exprs.len(), 1);
assert!(block.trailing_expr.is_none());

let block = parse_all::<ast::ExprBlock>(r#"
    {
        let foo = 42;
        let bar = "string";
        baz
    }
"#)?.item;
assert!(block.async_.is_none());
assert_eq!(block.exprs.len(), 2);
assert!(block.trailing_expr.is_some());

fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError>

Parse the current item from the parser.