Simplify custom syntax.

src/engine.rs

@@ -18,7 +18,7 @@ use crate::utils::StaticVec;
 use crate::parser::FLOAT;
 
 #[cfg(feature = "internals")]
-use crate::syntax::CustomSyntax;
+use crate::syntax::{CustomSyntax, EvalContext};
 
 use crate::stdlib::{
     any::{type_name, TypeId},
@@ -1738,15 +1738,19 @@ impl Engine {
     #[deprecated(note = "this method is volatile and may change")]
     pub fn eval_expression_tree(
         &self,
+        context: &mut EvalContext,
         scope: &mut Scope,
-        mods: &mut Imports,
-        state: &mut State,
-        lib: &Module,
-        this_ptr: &mut Option<&mut Dynamic>,
         expr: &Expression,
-        level: usize,
     ) -> Result<Dynamic, Box<EvalAltResult>> {
-        self.eval_expr(scope, mods, state, lib, this_ptr, expr.expr(), level)
+        self.eval_expr(
+            scope,
+            context.mods,
+            context.state,
+            context.lib,
+            context.this_ptr,
+            expr.expr(),
+            context.level,
+        )
     }
 
     /// Evaluate an expression
@@ -2215,7 +2219,14 @@ impl Engine {
             Expr::Custom(x) => {
                 let func = (x.0).1.as_ref();
                 let ep: StaticVec<_> = (x.0).0.iter().map(|e| e.into()).collect();
-                func(self, scope, mods, state, lib, this_ptr, ep.as_ref(), level)
+                let mut context = EvalContext {
+                    mods,
+                    state,
+                    lib,
+                    this_ptr,
+                    level,
+                };
+                func(self, &mut context, scope, ep.as_ref())
             }
 
             _ => unreachable!(),

src/lib.rs

@@ -171,6 +171,10 @@ pub use parser::{CustomExpr, Expr, ReturnType, ScriptFnDef, Stmt};
 #[deprecated(note = "this type is volatile and may change")]
 pub use engine::{Expression, Imports, State as EvalState};
 
+#[cfg(feature = "internals")]
+#[deprecated(note = "this type is volatile and may change")]
+pub use syntax::EvalContext;
+
 #[cfg(feature = "internals")]
 #[deprecated(note = "this type is volatile and may change")]
 pub use module::ModuleRef;

src/syntax.rs

@@ -22,26 +22,13 @@ use crate::stdlib::{
 #[cfg(not(feature = "sync"))]
 pub type FnCustomSyntaxEval = dyn Fn(
     &Engine,
+    &mut EvalContext,
     &mut Scope,
-    &mut Imports,
-    &mut State,
-    &Module,
-    &mut Option<&mut Dynamic>,
     &[Expression],
-    usize,
 ) -> Result<Dynamic, Box<EvalAltResult>>;
 /// A general function trail object.
 #[cfg(feature = "sync")]
-pub type FnCustomSyntaxEval = dyn Fn(
-        &Engine,
-        &mut Scope,
-        &mut Imports,
-        &mut State,
-        &Module,
-        &mut Option<&mut Dynamic>,
-        &[Expression],
-        usize,
-    ) -> Result<Dynamic, Box<EvalAltResult>>
+pub type FnCustomSyntaxEval = dyn Fn(&Engine, &mut EvalContext, &mut Scope, &[Expression]) -> Result<Dynamic, Box<EvalAltResult>>
     + Send
     + Sync;
 
@@ -58,6 +45,14 @@ impl fmt::Debug for CustomSyntax {
     }
 }
 
+pub struct EvalContext<'a, 'b: 'a, 's, 'm, 't, 'd: 't> {
+    pub(crate) mods: &'a mut Imports<'b>,
+    pub(crate) state: &'s mut State,
+    pub(crate) lib: &'m Module,
+    pub(crate) this_ptr: &'t mut Option<&'d mut Dynamic>,
+    pub(crate) level: usize,
+}
+
 impl Engine {
     pub fn register_custom_syntax<S: AsRef<str> + ToString>(
         &mut self,
@@ -65,13 +60,9 @@ impl Engine {
         scope_delta: isize,
         func: impl Fn(
                 &Engine,
+                &mut EvalContext,
                 &mut Scope,
-                &mut Imports,
-                &mut State,
-                &Module,
-                &mut Option<&mut Dynamic>,
                 &[Expression],
-                usize,
             ) -> Result<Dynamic, Box<EvalAltResult>>
             + SendSync
             + 'static,