Struct rune::ast::DeclFn

pub struct DeclFn {
    pub async_: Option<Async>,
    pub fn_: Fn,
    pub name: Ident,
    pub args: Parenthesized<FnArg, Comma>,
    pub body: ExprBlock,
}

A function.

Fields

async_: Option<Async>

The optional async keyword.

fn_: Fn

The fn token.

name: Ident

The name of the function.

args: Parenthesized<FnArg, Comma>

The arguments of the function.

body: ExprBlock

The body of the function.

Implementations

impl DeclFn

pub fn item_span(&self) -> Span

Get the identifying span for this function.

pub fn span(&self) -> Span

Access the span for the function declaration.

pub fn is_instance(&self) -> bool

Test if function is an instance fn.

Trait Implementations

impl Clone for DeclFn

fn clone(&self) -> DeclFn

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DeclFn

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

Formats the value using the given formatter.

impl Parse for DeclFn

Parse implementation for a function.

Examples

use rune::{ParseAll, parse_all, ast, Resolve as _};

parse_all::<ast::DeclFn>("async fn hello() {}").unwrap();
assert!(parse_all::<ast::DeclFn>("fn async hello() {}").is_err());

let ParseAll { item, .. } = parse_all::<ast::DeclFn>("fn hello() {}").unwrap();
assert_eq!(item.args.items.len(), 0);

let ParseAll  { source, item } = parse_all::<ast::DeclFn>("fn hello(foo, bar) {}").unwrap();
assert_eq!(item.args.items.len(), 2);
assert_eq!(item.name.resolve(source).unwrap(), "hello");

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

Parse the current item from the parser.