Struct syn::Block

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

A braced block containing Rust statements.

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

Fields

brace_token: Brace

stmts: Vec<Stmt>

Statements in a block

Methods

impl Block

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

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

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

Example

#[macro_use]
extern crate syn;

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

// 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: fn_token,
            name: name,
            brace_token: brace_token,
            stmts: stmts,
        })
    }
}

Trait Implementations

impl Parse for Block

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

impl ToTokens for Block

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

Write self to the given TokenStream.

fn into_token_stream(self) -> TokenStream

Convert self directly into a TokenStream object.

impl Debug for Block

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

Formats the value using the given formatter.

impl Eq for Block

impl PartialEq 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 Hash for Block

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.