Struct casbin::rhai::AST

pub struct AST { /* fields omitted */ }

Compiled AST (abstract syntax tree) of a Rhai script.

Thread Safety

Currently, AST is neither Send nor Sync. Turn on the sync feature to make it Send + Sync.

Implementations

impl AST

pub fn new(
    statements: impl IntoIterator<Item = Stmt>,
    functions: impl Into<Arc<Module>>
) -> AST

Create a new AST.

pub fn new_with_source(
    statements: impl IntoIterator<Item = Stmt>,
    functions: impl Into<Arc<Module>>,
    source: impl Into<SmartString<Compact>>
) -> AST

Create a new AST with a source name.

pub fn source(&self) -> Option<&str>

Get the source, if any.

pub fn set_source(
    &mut self,
    source: impl Into<SmartString<Compact>>
) -> &mut AST

Set the source.

pub fn clear_source(&mut self) -> &mut AST

Clear the source.

pub fn clone_statements_only(&self) -> AST

Clone the AST’s script statements into a new AST. No functions are cloned.

pub fn merge(&self, other: &AST) -> AST

Merge two AST into one. Both AST’s are untouched and a new, merged, version is returned.

Statements in the second AST are simply appended to the end of the first without any processing. Thus, the return value of the first AST (if using expression-statement syntax) is buried. Of course, if the first AST uses a return statement at the end, then the second AST will essentially be dead code.

All script-defined functions in the second AST overwrite similarly-named functions in the first AST with the same number of parameters.

Example

use rhai::Engine;

let engine = Engine::new();

let ast1 = engine.compile(r#"
                fn foo(x) { 42 + x }
                foo(1)
            "#)?;

let ast2 = engine.compile(r#"
                fn foo(n) { "hello" + n }
                foo("!")
            "#)?;

let ast = ast1.merge(&ast2);    // Merge 'ast2' into 'ast1'

// Notice that using the '+' operator also works:
// let ast = &ast1 + &ast2;

// 'ast' is essentially:
//
//    fn foo(n) { "hello" + n } // <- definition of first 'foo' is overwritten
//    foo(1)                    // <- notice this will be "hello1" instead of 43,
//                              //    but it is no longer the return value
//    foo("!")                  // returns "hello!"

// Evaluate it
assert_eq!(engine.eval_ast::<String>(&ast)?, "hello!");

pub fn combine(&mut self, other: AST) -> &mut AST

Combine one AST with another. The second AST is consumed.

Statements in the second AST are simply appended to the end of the first without any processing. Thus, the return value of the first AST (if using expression-statement syntax) is buried. Of course, if the first AST uses a return statement at the end, then the second AST will essentially be dead code.

All script-defined functions in the second AST overwrite similarly-named functions in the first AST with the same number of parameters.

Example

use rhai::Engine;

let engine = Engine::new();

let mut ast1 = engine.compile(r#"
                    fn foo(x) { 42 + x }
                    foo(1)
                "#)?;

let ast2 = engine.compile(r#"
                fn foo(n) { "hello" + n }
                foo("!")
            "#)?;

ast1.combine(ast2);    // Combine 'ast2' into 'ast1'

// Notice that using the '+=' operator also works:
// ast1 += ast2;

// 'ast1' is essentially:
//
//    fn foo(n) { "hello" + n } // <- definition of first 'foo' is overwritten
//    foo(1)                    // <- notice this will be "hello1" instead of 43,
//                              //    but it is no longer the return value
//    foo("!")                  // returns "hello!"

// Evaluate it
assert_eq!(engine.eval_ast::<String>(&ast1)?, "hello!");

pub fn merge_filtered(
    &self,
    other: &AST,
    filter: impl Fn(FnNamespace, FnAccess, bool, &str, usize) -> bool
) -> AST

Merge two AST into one. Both AST’s are untouched and a new, merged, version is returned.

Statements in the second AST are simply appended to the end of the first without any processing. Thus, the return value of the first AST (if using expression-statement syntax) is buried. Of course, if the first AST uses a return statement at the end, then the second AST will essentially be dead code.

All script-defined functions in the second AST are first selected based on a filter predicate, then overwrite similarly-named functions in the first AST with the same number of parameters.

Example

use rhai::Engine;

let engine = Engine::new();

let ast1 = engine.compile(r#"
                fn foo(x) { 42 + x }
                foo(1)
            "#)?;

let ast2 = engine.compile(r#"
                fn foo(n) { "hello" + n }
                fn error() { 0 }
                foo("!")
            "#)?;

// Merge 'ast2', picking only 'error()' but not 'foo(_)', into 'ast1'
let ast = ast1.merge_filtered(&ast2, |_, _, script, name, params|
                                script && name == "error" && params == 0);

// 'ast' is essentially:
//
//    fn foo(n) { 42 + n }      // <- definition of 'ast1::foo' is not overwritten
//                              //    because 'ast2::foo' is filtered away
//    foo(1)                    // <- notice this will be 43 instead of "hello1",
//                              //    but it is no longer the return value
//    fn error() { 0 }          // <- this function passes the filter and is merged
//    foo("!")                  // <- returns "42!"

// Evaluate it
assert_eq!(engine.eval_ast::<String>(&ast)?, "42!");

pub fn combine_filtered(
    &mut self,
    other: AST,
    filter: impl Fn(FnNamespace, FnAccess, bool, &str, usize) -> bool
) -> &mut AST

Combine one AST with another. The second AST is consumed.

Statements in the second AST are simply appended to the end of the first without any processing. Thus, the return value of the first AST (if using expression-statement syntax) is buried. Of course, if the first AST uses a return statement at the end, then the second AST will essentially be dead code.

All script-defined functions in the second AST are first selected based on a filter predicate, then overwrite similarly-named functions in the first AST with the same number of parameters.

Example

use rhai::Engine;

let engine = Engine::new();

let mut ast1 = engine.compile(r#"
                    fn foo(x) { 42 + x }
                    foo(1)
                "#)?;

let ast2 = engine.compile(r#"
                fn foo(n) { "hello" + n }
                fn error() { 0 }
                foo("!")
            "#)?;

// Combine 'ast2', picking only 'error()' but not 'foo(_)', into 'ast1'
ast1.combine_filtered(ast2, |_, _, script, name, params|
                                script && name == "error" && params == 0);

// 'ast1' is essentially:
//
//    fn foo(n) { 42 + n }      // <- definition of 'ast1::foo' is not overwritten
//                              //    because 'ast2::foo' is filtered away
//    foo(1)                    // <- notice this will be 43 instead of "hello1",
//                              //    but it is no longer the return value
//    fn error() { 0 }          // <- this function passes the filter and is merged
//    foo("!")                  // <- returns "42!"

// Evaluate it
assert_eq!(engine.eval_ast::<String>(&ast1)?, "42!");

pub fn clear_statements(&mut self)

Clear all statements in the AST, leaving only function definitions.

Trait Implementations

impl<'_, A> Add<A> for &'_ AST where
    A: AsRef<AST>, 

type Output = AST

The resulting type after applying the + operator.

pub fn add(self, rhs: A) -> <&'_ AST as Add<A>>::Output

Performs the + operation.

impl<A> AddAssign<A> for AST where
    A: Into<AST>, 

pub fn add_assign(&mut self, rhs: A)

Performs the += operation.

impl AsRef<[Stmt]> for AST

pub fn as_ref(&self) -> &[Stmt]

Performs the conversion.

impl AsRef<Module> for AST

pub fn as_ref(&self) -> &Module

Performs the conversion.

impl Clone for AST

pub fn clone(&self) -> AST

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AST

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

Formats the value using the given formatter.

impl Default for AST

pub fn default() -> AST

Returns the “default value” for a type.