New Procedural Macros Crate v0.1

codegen/src/lib.rs

@@ -0,0 +1,143 @@
+//!
+//! This crate contains procedural macros to make creating Rhai modules much easier.
+//!
+//! # Exporting a Macro to Rhai
+//!
+//! ```
+//! use rhai::{EvalAltResult, FLOAT, RegisterFn};
+//! use rhai::plugin::*;
+//! use rhai::module_resolvers::*;
+//!
+//! #[rhai::export_module]
+//! pub mod advanced_math {
+//!     use rhai::FLOAT;
+//!
+//!     pub const MYSTIC_NUMBER: FLOAT = 42.0 as FLOAT;
+//!
+//!     pub fn euclidean_distance(x1: FLOAT, y1: FLOAT, x2: FLOAT, y2: FLOAT) -> FLOAT {
+//!         ((y2 - y1).abs().powf(2.0) + (x2 -x1).abs().powf(2.0)).sqrt()
+//!     }
+//! }
+//!
+//! fn main() -> Result<(), Box<EvalAltResult>> {
+//!     let mut engine = Engine::new();
+//!     let m = rhai::exported_module!(advanced_math);
+//!     let mut r = StaticModuleResolver::new();
+//!     r.insert("Math::Advanced".to_string(), m);
+//!     engine.set_module_resolver(Some(r));
+//!
+//!     assert_eq!(engine.eval::<FLOAT>(
+//!         r#"import "Math::Advanced" as math;
+//!            let m = math::MYSTIC_NUMBER;
+//!            let x = math::euclidean_distance(0.0, 1.0, 0.0, m);
+//!            x"#)?, 41.0);
+//!     Ok(())
+//! }
+//! ```
+//!
+//! # Exporting a Function to Rhai
+//!
+//! ```
+//! use rhai::{EvalAltResult, FLOAT, Module, RegisterFn};
+//! use rhai::plugin::*;
+//! use rhai::module_resolvers::*;
+//!
+//! #[rhai::export_fn]
+//! pub fn distance_function(x1: FLOAT, y1: FLOAT, x2: FLOAT, y2: FLOAT) -> FLOAT {
+//!     ((y2 - y1).abs().powf(2.0) + (x2 -x1).abs().powf(2.0)).sqrt()
+//! }
+//!
+//! fn main() -> Result<(), Box<EvalAltResult>> {
+//!
+//!     let mut engine = Engine::new();
+//!     engine.register_fn("get_mystic_number", || { 42 as FLOAT });
+//!     let mut m = Module::new();
+//!     rhai::register_exported_fn!(m, "euclidean_distance", distance_function);
+//!     let mut r = StaticModuleResolver::new();
+//!     r.insert("Math::Advanced".to_string(), m);
+//!     engine.set_module_resolver(Some(r));
+//!
+//!     assert_eq!(engine.eval::<FLOAT>(
+//!         r#"import "Math::Advanced" as math;
+//!            let m = get_mystic_number();
+//!            let x = math::euclidean_distance(0.0, 1.0, 0.0, m);
+//!            x"#)?, 41.0);
+//!     Ok(())
+//! }
+//! ```
+//!
+
+use quote::{quote, quote_spanned};
+use syn::{parse::Parser, parse_macro_input, spanned::Spanned};
+
+mod function;
+mod module;
+mod rhai_module;
+
+#[proc_macro_attribute]
+pub fn export_fn(_args: proc_macro::TokenStream,
+                input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let mut output = proc_macro2::TokenStream::from(input.clone());
+    let function_def = parse_macro_input!(input as function::ExportedFn);
+    output.extend(function_def.generate());
+    proc_macro::TokenStream::from(output)
+}
+
+#[proc_macro_attribute]
+pub fn export_module(_args: proc_macro::TokenStream,
+              input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let module_def = parse_macro_input!(input as module::Module);
+    let tokens = module_def.generate();
+    proc_macro::TokenStream::from(tokens)
+}
+
+#[proc_macro]
+pub fn exported_module(module_path: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let module_path = parse_macro_input!(module_path as syn::Path);
+    let tokens = quote::quote! {
+        #module_path::rhai_module__generate()
+    };
+    proc_macro::TokenStream::from(tokens)
+}
+
+#[proc_macro]
+pub fn register_exported_fn(args: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let parser = syn::punctuated::Punctuated::<syn::Expr, syn::Token![,]>::parse_separated_nonempty;
+    let args = parser.parse(args).unwrap();
+    let arg_span = args.span();
+    let items: Vec<syn::Expr> = args.into_iter().collect();
+    if items.len() != 3 {
+        return proc_macro::TokenStream::from(
+            syn::Error::new(arg_span, "this macro requires three arguments")
+                .to_compile_error());
+    }
+    let rhai_module = &items[0];
+    let export_name = match &items[1] {
+        syn::Expr::Lit(litstr) => quote_spanned!(items[1].span()=>
+                                                 #litstr.to_string()),
+        expr => quote! { #expr },
+    };
+    let rust_modpath = if let syn::Expr::Path(ref path) = &items[2] {
+        &path.path
+    } else {
+        return proc_macro::TokenStream::from(
+            syn::Error::new(items[2].span(), "third argument must be a function name")
+                .to_compile_error());
+    };
+    let gen_mod_path: syn::punctuated::Punctuated<syn::PathSegment, _> = {
+        let mut g = rust_modpath.clone().segments;
+        g.pop();
+        let ident = syn::Ident::new(&format!("rhai_fn__{}",
+                                            rust_modpath.segments.last().unwrap().ident),
+                                   items[2].span());
+        g.push_value(syn::PathSegment { ident, arguments: syn::PathArguments::None });
+        g
+    };
+    let tokens = quote! {
+        #rhai_module.set_fn(#export_name, rhai::FnAccess::Public,
+                            #gen_mod_path::Token().input_types().as_ref(),
+                            CallableFunction::from_plugin(#gen_mod_path::Token()));
+
+    };
+    proc_macro::TokenStream::from(tokens)
+}