Struct syn::Block

pub struct Block {
    pub brace_token: Brace,
    pub stmts: Vec<Stmt>,
}

This is supported on crate feature full only.

A braced block containing Rust statements.

This type is available only if Syn is built with the "full" feature.

Fields

brace_token: Brace

stmts: Vec<Stmt>

Statements in a block

Implementations

impl Block

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

This is supported on crate feature parsing only.

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

This function is available only if Syn is built with the "parsing" feature.

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

Trait Implementations

impl Clone for Block

This is supported on crate feature clone-impls only.

pub fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

This is supported on crate feature extra-traits only.

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

Formats the value using the given formatter.

impl Eq for Block

This is supported on crate feature extra-traits only.

impl Hash for Block

This is supported on crate feature extra-traits only.

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Parse for Block

This is supported on crate feature parsing only.

pub fn parse(input: ParseStream<'_>) -> Result<Self>

impl PartialEq<Block> for Block

This is supported on crate feature extra-traits only.

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl ToTokens for Block

This is supported on crate feature printing only.

pub fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

pub fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

pub fn into_token_stream(self) -> TokenStream

Convert self directly into a TokenStream object.