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

impl Clone for Block

fn clone(self: &Self) -> Self

impl Debug for Block

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

impl Eq for Block

impl Freeze for Block

impl Hash for Block

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

impl Parse for Block

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

impl PartialEq for Block

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

impl RefUnwindSafe for Block

impl Send for Block

impl Sync for Block

impl ToTokens for Block

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

impl Unpin for Block

impl UnsafeUnpin for Block

impl UnwindSafe for Block

impl<T> Any for Block

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Block

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Block

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Block

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for Block

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Spanned for Block

fn span(self: &Self) -> Span

impl<T> ToOwned for Block

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for Block

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Block

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Block

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>