Use &Token for op.

src/api/deprecated.rs

@@ -1133,7 +1133,7 @@ pub mod deprecated_array_functions {
         array: &mut Array,
         comparer: &str,
     ) -> RhaiResultOf<()> {
-        sort(ctx, array, FnPtr::new(comparer)?)
+        Ok(sort(ctx, array, FnPtr::new(comparer)?))
     }
     /// Remove all elements in the array that returns `true` when applied a function named by `filter`
     /// and return them as a new array.

src/eval/stmt.rs

@@ -141,7 +141,7 @@ impl Engine {
 
             if self.fast_operators() {
                 if let Some((func, need_context)) =
-                    get_builtin_op_assignment_fn(op_assign.clone(), args[0], args[1])
+                    get_builtin_op_assignment_fn(op_assign, args[0], args[1])
                 {
                     // Built-in found
                     auto_restore! { let orig_level = global.level; global.level += 1 }
@@ -157,7 +157,7 @@ impl Engine {
                 }
             }
 
-            let token = Some(op_assign.clone());
+            let token = Some(op_assign);
             let op_assign = op_assign.literal_syntax();
 
             match self.exec_native_fn_call(global, caches, op_assign, token, hash, args, true, *pos)
@@ -166,7 +166,7 @@ impl Engine {
                 Err(err) if matches!(*err, ERR::ErrorFunctionNotFound(ref f, ..) if f.starts_with(op_assign)) =>
                 {
                     // Expand to `var = var op rhs`
-                    let token = Some(op.clone());
+                    let token = Some(op);
                     let op = op.literal_syntax();
 
                     *args[0] = self

src/func/builtin.rs

@@ -86,7 +86,7 @@ fn const_false_fn(_: Option<NativeCallContext>, _: &mut [&mut Dynamic]) -> RhaiR
 ///
 /// The return function will be registered as a _method_, so the first parameter cannot be consumed.
 #[must_use]
-pub fn get_builtin_binary_op_fn(op: Token, x: &Dynamic, y: &Dynamic) -> Option<FnBuiltin> {
+pub fn get_builtin_binary_op_fn(op: &Token, x: &Dynamic, y: &Dynamic) -> Option<FnBuiltin> {
     let type1 = x.type_id();
     let type2 = y.type_id();
 
@@ -621,7 +621,7 @@ pub fn get_builtin_binary_op_fn(op: Token, x: &Dynamic, y: &Dynamic) -> Option<F
 ///
 /// The return function is registered as a _method_, so the first parameter cannot be consumed.
 #[must_use]
-pub fn get_builtin_op_assignment_fn(op: Token, x: &Dynamic, y: &Dynamic) -> Option<FnBuiltin> {
+pub fn get_builtin_op_assignment_fn(op: &Token, x: &Dynamic, y: &Dynamic) -> Option<FnBuiltin> {
     let type1 = x.type_id();
     let type2 = y.type_id();
 

src/func/call.rs

@@ -164,7 +164,7 @@ impl Engine {
         _global: &GlobalRuntimeState,
         caches: &'s mut Caches,
         local_entry: &'s mut Option<FnResolutionCacheEntry>,
-        op_token: Option<Token>,
+        op_token: Option<&Token>,
         hash_base: u64,
         args: Option<&mut FnCallArgs>,
         allow_dynamic: bool,
@@ -345,7 +345,7 @@ impl Engine {
         global: &mut GlobalRuntimeState,
         caches: &mut Caches,
         name: &str,
-        op_token: Option<Token>,
+        op_token: Option<&Token>,
         hash: u64,
         args: &mut FnCallArgs,
         is_ref_mut: bool,
@@ -567,7 +567,7 @@ impl Engine {
         caches: &mut Caches,
         _scope: Option<&mut Scope>,
         fn_name: &str,
-        op_token: Option<Token>,
+        op_token: Option<&Token>,
         hashes: FnCallHashes,
         mut _args: &mut FnCallArgs,
         is_ref_mut: bool,
@@ -1000,7 +1000,7 @@ impl Engine {
         scope: &mut Scope,
         mut this_ptr: Option<&mut Dynamic>,
         fn_name: &str,
-        op_token: Option<Token>,
+        op_token: Option<&Token>,
         first_arg: Option<&Expr>,
         args_expr: &[Expr],
         hashes: FnCallHashes,
@@ -1564,10 +1564,10 @@ impl Engine {
             ..
         } = expr;
 
-        let op_token = op_token.clone();
+        let op_token = op_token.as_ref();
 
         // Short-circuit native unary operator call if under Fast Operators mode
-        if op_token == Some(Token::Bang) && self.fast_operators() && args.len() == 1 {
+        if op_token == Some(&Token::Bang) && self.fast_operators() && args.len() == 1 {
             let mut value = self
                 .get_arg_value(global, caches, scope, this_ptr.as_deref_mut(), &args[0])?
                 .0
@@ -1597,7 +1597,7 @@ impl Engine {
             let operands = &mut [&mut lhs, &mut rhs];
 
             if let Some((func, need_context)) =
-                get_builtin_binary_op_fn(op_token.clone().unwrap(), operands[0], operands[1])
+                get_builtin_binary_op_fn(op_token.as_ref().unwrap(), operands[0], operands[1])
             {
                 // Built-in found
                 auto_restore! { let orig_level = global.level; global.level += 1 }

src/func/native.rs

@@ -446,7 +446,7 @@ impl<'a> NativeCallContext<'a> {
                     global,
                     caches,
                     fn_name,
-                    op_token,
+                    op_token.as_ref(),
                     calc_fn_hash(None, fn_name, args_len),
                     args,
                     is_ref_mut,
@@ -473,7 +473,7 @@ impl<'a> NativeCallContext<'a> {
                 caches,
                 None,
                 fn_name,
-                op_token,
+                op_token.as_ref(),
                 hash,
                 args,
                 is_ref_mut,

src/optimizer.rs

@@ -147,7 +147,7 @@ impl<'a> OptimizerState<'a> {
     pub fn call_fn_with_constant_arguments(
         &mut self,
         fn_name: &str,
-        op_token: Option<Token>,
+        op_token: Option<&Token>,
         arg_values: &mut [Dynamic],
     ) -> Option<Dynamic> {
         self.engine
@@ -1138,7 +1138,7 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
                 }
                 // Overloaded operators can override built-in.
                 _ if x.args.len() == 2 && x.op_token.is_some() && (state.engine.fast_operators() || !state.engine.has_native_fn_override(x.hashes.native(), &arg_types)) => {
-                    if let Some(result) = get_builtin_binary_op_fn(x.op_token.clone().unwrap(), &arg_values[0], &arg_values[1])
+                    if let Some(result) = get_builtin_binary_op_fn(x.op_token.as_ref().unwrap(), &arg_values[0], &arg_values[1])
                         .and_then(|(f, ctx)| {
                             let context = if ctx {
                                 Some((state.engine, x.name.as_str(), None, &state.global, *pos).into())
@@ -1193,7 +1193,7 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
                     KEYWORD_TYPE_OF if arg_values.len() == 1 => Some(state.engine.map_type_name(arg_values[0].type_name()).into()),
                     #[cfg(not(feature = "no_closure"))]
                     crate::engine::KEYWORD_IS_SHARED if arg_values.len() == 1 => Some(Dynamic::FALSE),
-                    _ => state.call_fn_with_constant_arguments(&x.name, x.op_token.clone(), arg_values)
+                    _ => state.call_fn_with_constant_arguments(&x.name, x.op_token.as_ref(), arg_values)
                 };
 
                 if let Some(r) = result {