Struct rune::macros::MacroContext

pub struct MacroContext<'a, 'b, 'arena> { /* private fields */ }

Context for a running macro.

Implementations

impl<'a, 'b, 'arena> MacroContext<'a, 'b, 'arena>

pub fn eval(&mut self, target: &Expr) -> Result<Value>

Evaluate the given target as a constant expression.

Panics

This will panic if it’s called outside of a macro context.

Examples

use rune::ast;
use rune::macros::{self, quote};
use rune::parse::{Parser};

macros::test(|cx| {
    let stream = quote!(1 + 2).into_token_stream(cx)?;

    let mut p = Parser::from_token_stream(&stream, cx.input_span());
    let expr = p.parse_all::<ast::Expr>()?;
    let value = cx.eval(&expr)?;

    let integer = value.into_integer::<u32>().context("Expected integer")?;
    assert_eq!(3, integer);
    Ok(())
})?;

pub fn lit<T>(&mut self, lit: T) -> Result<Lit>

where T: IntoLit,

Construct a new literal from within a macro context.

Examples

use rune::ast;
use rune::macros;

macros::test(|cx| {
    let lit = cx.lit("hello world")?;
    assert!(matches!(lit, ast::Lit::Str(..)));
    Ok(())
})?;

pub fn ident(&mut self, ident: &str) -> Result<Ident>

Construct a new identifier from the given string from inside of a macro context.

Examples

use rune::ast;
use rune::macros;

macros::test(|cx| {
    let lit = cx.ident("foo")?;
    assert!(matches!(lit, ast::Ident { .. }));
    Ok(())
})?;

pub fn label(&mut self, label: &str) -> Result<Label>

Construct a new label from the given string. The string should be specified without the leading ', so "foo" instead of "'foo".

This constructor does not panic when called outside of a macro context but requires access to a span and storage.

Examples

use rune::ast;
use rune::macros;

macros::test(|cx| {
    let lit = cx.label("foo")?;
    assert!(matches!(lit, ast::Label { .. }));
    Ok(())
})?;

pub fn stringify<T>( &mut self, tokens: &T ) -> Result<Stringify<'_, 'a, 'b, 'arena>>

where T: ToTokens,

Stringify the token stream.

pub fn resolve<'r, T>(&'r self, item: T) -> Result<T::Output>

where T: Resolve<'r>,

Resolve the value of a token.

pub fn insert_source(&mut self, name: &str, source: &str) -> Result<SourceId>

Insert the given source so that it has a SourceId that can be used in combination with parsing functions such as parse_source.

pub fn parse_source<T>(&self, id: SourceId) -> Result<T>

where T: Parse,

Parse the given input as the given type that implements Parse.

pub fn macro_span(&self) -> Span

The span of the macro call including the name of the macro.

If the macro call was stringify!(a + b) this would refer to the whole macro call.

pub fn input_span(&self) -> Span

The span of the macro stream (the argument).

If the macro call was stringify!(a + b) this would refer to a + b.