Struct rune::ast::Block

pub struct Block {
    pub id: Option<Id>,
    pub open: OpenBrace,
    pub statements: Vec<Stmt>,
    pub close: CloseBrace,
}

A block of expressions.

use rune::{testing, ast};

let expr = testing::roundtrip::<ast::ExprBlock>("{}");
assert_eq!(expr.block.statements.len(), 0);

let expr = testing::roundtrip::<ast::ExprBlock>("{ 42 }");
assert_eq!(expr.block.statements.len(), 1);

let expr = testing::roundtrip::<ast::ExprBlock>("#[retry] { 42 }");
assert_eq!(expr.block.statements.len(), 1);
assert_eq!(expr.attributes.len(), 1);

Fields

id: Option<Id>

The unique identifier for the block expression.

open: OpenBrace

The close brace.

statements: Vec<Stmt>

Statements in the block.

close: CloseBrace

The close brace.

Implementations

impl Block

pub fn produces_nothing(&self) -> bool

Test if the block produces nothing.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl Eq for Block

impl Parse for Block

Parse implementation for a block.

Examples

use rune::{testing, ast};

let block = testing::roundtrip::<ast::Block>("{}");
assert_eq!(block.statements.len(), 0);
assert!(block.produces_nothing());

let block = testing::roundtrip::<ast::Block>("{ foo }");
assert_eq!(block.statements.len(), 1);
assert!(!block.produces_nothing());

let block = testing::roundtrip::<ast::Block>("{ foo; }");
assert_eq!(block.statements.len(), 1);
assert!(block.produces_nothing());

let block = testing::roundtrip::<ast::Block>(r#"
    {
        let foo = 42;
        let bar = "string";
        baz
    }
"#);

assert_eq!(block.statements.len(), 3);

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

Parse the current item from the parser.

impl PartialEq<Block> for Block

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Spanned for Block

fn span(&self) -> Span

Get the span of the type.

impl StructuralEq for Block

impl StructuralPartialEq for Block

impl ToTokens for Block

fn to_tokens(&self, context: &MacroContext, stream: &mut TokenStream)

Turn the current item into tokens.