Reduce duplicated generics code.

src/engine_api.rs

@@ -1338,6 +1338,7 @@ impl Engine {
     /// # }
     /// ```
     #[cfg(not(feature = "no_object"))]
+    #[inline(always)]
     pub fn parse_json(
         &self,
         json: impl AsRef<str>,
@@ -1345,10 +1346,12 @@ impl Engine {
     ) -> Result<Map, Box<EvalAltResult>> {
         use crate::token::Token;
 
-        let json = json.as_ref();
+        fn parse_json_inner(
+            engine: &Engine,
+            json: &str,
+            has_null: bool,
+        ) -> Result<Map, Box<EvalAltResult>> {
             let mut scope = Default::default();
-
-        // Trims the JSON string and add a '#' in front
             let json_text = json.trim_start();
             let scripts = if json_text.starts_with(Token::MapStart.literal_syntax()) {
                 [json_text, ""]
@@ -1362,8 +1365,7 @@ impl Engine {
                 .into_err(Position::new(1, (json.len() - json_text.len() + 1) as u16))
                 .into());
             };
-
-        let (stream, tokenizer_control) = self.lex_raw(
+            let (stream, tokenizer_control) = engine.lex_raw(
                 &scripts,
                 Some(if has_null {
                     |token| match token {
@@ -1375,22 +1377,20 @@ impl Engine {
                     |t| t
                 }),
             );
-
-        let mut state = ParseState::new(self, tokenizer_control);
-
-        let ast = self.parse_global_expr(
+            let mut state = ParseState::new(engine, tokenizer_control);
+            let ast = engine.parse_global_expr(
                 &mut stream.peekable(),
                 &mut state,
                 &scope,
                 OptimizationLevel::None,
             )?;
-
-        // Handle null - map to ()
             if has_null {
                 scope.push_constant("null", ());
             }
+            engine.eval_ast_with_scope(&mut scope, &ast)
+        }
 
-        self.eval_ast_with_scope(&mut scope, &ast)
+        parse_json_inner(self, json.as_ref(), has_null)
     }
     /// Compile a string containing an expression into an [`AST`],
     /// which can be used later for evaluation.

src/fn_native.rs

@@ -192,15 +192,19 @@ impl<'a> NativeCallContext<'a> {
     ///
     /// If `is_method` is [`true`], the first argument is assumed to be passed
     /// by reference and is not consumed.
-    #[inline]
+    #[inline(always)]
     pub fn call_fn_dynamic_raw(
         &self,
         fn_name: impl AsRef<str>,
         is_method_call: bool,
         args: &mut [&mut Dynamic],
     ) -> RhaiResult {
-        let fn_name = fn_name.as_ref();
-
+        fn call_fn_dynamic_inner(
+            context: &NativeCallContext,
+            is_method_call: bool,
+            fn_name: &str,
+            args: &mut [&mut Dynamic],
+        ) -> Result<Dynamic, Box<EvalAltResult>> {
             let hash = if is_method_call {
                 FnCallHashes::from_script_and_native(
                     calc_fn_hash(fn_name, args.len() - 1),
@@ -209,12 +213,12 @@ impl<'a> NativeCallContext<'a> {
             } else {
                 FnCallHashes::from_script(calc_fn_hash(fn_name, args.len()))
             };
-
-        self.engine()
+            context
+                .engine()
                 .exec_fn_call(
-                &mut self.mods.cloned().unwrap_or_default(),
+                    &mut context.mods.cloned().unwrap_or_default(),
                     &mut Default::default(),
-                self.lib,
+                    context.lib,
                     fn_name,
                     hash,
                     args,
@@ -226,6 +230,9 @@ impl<'a> NativeCallContext<'a> {
                 )
                 .map(|(r, _)| r)
         }
+
+        call_fn_dynamic_inner(self, is_method_call, fn_name.as_ref(), args)
+    }
 }
 
 /// Consume a [`Shared`] resource and return a mutable reference to the wrapped value.