impl Block

fn parse_within(input: ParseStream<'_>) -> Result<Vec<Stmt>>

Parse the body of a block as zero or more statements, possibly including one trailing expression.

Example

use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token};
use syn::parse::{Parse, ParseStream};

// Parse a function with no generics or parameter list.
//
//     fn playground {
//         let mut x = 1;
//         x += 1;
//         println!("{}", x);
//     }
struct MiniFunction {
    attrs: Vec<Attribute>,
    fn_token: Token![fn],
    name: Ident,
    brace_token: token::Brace,
    stmts: Vec<Stmt>,
}

impl Parse for MiniFunction {
    fn parse(input: ParseStream) -> Result<Self> {
        let outer_attrs = input.call(Attribute::parse_outer)?;
        let fn_token: Token![fn] = input.parse()?;
        let name: Ident = input.parse()?;

        let content;
        let brace_token = braced!(content in input);
        let inner_attrs = content.call(Attribute::parse_inner)?;
        let stmts = content.call(Block::parse_within)?;

        Ok(MiniFunction {
            attrs: {
                let mut attrs = outer_attrs;
                attrs.extend(inner_attrs);
                attrs
            },
            fn_token,
            name,
            brace_token,
            stmts,
        })
    }
}