Satisfy clippy.

codegen/src/lib.rs

@@ -126,7 +126,10 @@ 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 mut output = quote! {
+        #[allow(clippy::needless_pass_by_value)]
+    };
+    output.extend(proc_macro2::TokenStream::from(input.clone()));
 
     let parsed_params = match crate::attrs::outer_item_attributes(args.into(), "export_fn") {
         Ok(args) => args,

codegen/src/module.rs

@@ -300,6 +300,7 @@ impl Module {
             // Regenerate the module with the new content added.
             Ok(quote! {
                 #(#mod_attrs)*
+                #[allow(clippy::needless_pass_by_value)]
                 #mod_vis mod #mod_name {
                     #(#orig_content)*
                     #(#inner_modules)*
@@ -310,6 +311,7 @@ impl Module {
             // Regenerate the original module as-is.
             Ok(quote! {
                 #(#mod_attrs)*
+                #[allow(clippy::needless_pass_by_value)]
                 #mod_vis mod #mod_name {
                     #(#orig_content)*
                 }

codegen/src/rhai_module.rs

@@ -328,7 +328,7 @@ pub fn check_rename_collisions(fns: &[ExportedFn]) -> Result<(), syn::Error> {
 
             for (name, fn_name) in names {
                 let current_span = item_fn.params().span.unwrap();
-                let key = make_key(&name, item_fn);
+                let key = make_key(name, item_fn);
                 if let Some(other_span) = renames.insert(key, current_span) {
                     let mut err = syn::Error::new(
                         current_span,

codegen/src/test/module.rs

@@ -320,6 +320,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod empty {
                 #[allow(unused_imports)]
                 use super::*;
@@ -354,6 +355,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn get_mystic_number() -> INT {
                     42
@@ -432,6 +434,7 @@ mod generate_tests {
              */
             /// Another line!
             /// Final line!
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 /// This is a doc-comment.
                 /// Another line.
@@ -502,6 +505,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_global_fn {
                 pub fn add_one_to(x: INT) -> INT {
                     x + 1
@@ -561,6 +565,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn add_one_to(x: INT) -> INT {
                     x + 1
@@ -626,6 +631,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod two_fns {
                 pub fn add_one_to(x: INT) -> INT {
                     x + 1
@@ -714,6 +720,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn add_together(x: INT, y: INT) -> INT {
                     x + y
@@ -775,6 +782,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn add_together(x: INT, y: INT) -> INT {
                     x + y
@@ -848,6 +856,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_constant {
                 #[derive(Debug, Clone)]
                 pub struct Foo(pub INT);
@@ -915,6 +924,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_constant {
                 pub const MYSTIC_NUMBER: INT = 42;
                 #[allow(unused_imports)]
@@ -950,6 +960,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_constant {
                 pub use rhai::INT;
                 pub const MYSTIC_NUMBER: INT = 42;
@@ -987,6 +998,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 fn get_mystic_number() -> INT {
                     42
@@ -1025,6 +1037,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn get_mystic_number() -> INT {
                     42
@@ -1066,10 +1079,12 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn get_mystic_number() -> INT {
                     42
                 }
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod inner_secrets {
                     pub const SECRET_NUMBER: INT = 86;
                 }
@@ -1125,6 +1140,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_constant {
                 const MYSTIC_NUMBER: INT = 42;
                 #[allow(unused_imports)]
@@ -1160,6 +1176,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod str_fn {
                 pub fn print_out_to(x: &str) {
                     x + 1
@@ -1219,6 +1236,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod str_fn {
                 pub fn print_out_to(x: String) {
                     x + 1
@@ -1279,6 +1297,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod ref_fn {
                 pub fn foo(x: &mut FLOAT, y: INT) -> FLOAT {
                     *x + y as FLOAT
@@ -1339,6 +1358,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod ref_fn {
                 pub fn increment(x: &mut FLOAT) {
                     *x += 1.0 as FLOAT;
@@ -1400,7 +1420,9 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod it_is {
                     pub fn increment(x: &mut FLOAT) {
                         *x += 1.0 as FLOAT;
@@ -1483,9 +1505,10 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 #[cfg(not(feature = "no_float"))]
-
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod it_is {
                     pub fn increment(x: &mut FLOAT) {
                         *x += 1.0 as FLOAT;
@@ -1572,6 +1595,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn int_foo(x: &mut u64) -> u64 {
                     (*x) * (*x)
@@ -1632,6 +1656,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn int_foo(x: &mut u64) -> u64 {
                     (*x) * (*x)
@@ -1695,6 +1720,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn int_foo(x: &mut u64, y: u64) {
                     *x = y * y
@@ -1756,6 +1782,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_fn {
                 pub fn int_foo(x: &mut u64, y: u64) {
                     *x = y * y
@@ -1820,6 +1847,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_index_fn {
                 pub fn get_by_index(x: &mut MyCollection, i: u64) -> FLOAT {
                     x.get(i)
@@ -1883,6 +1911,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_index_fn {
                 #[cfg(hello)]
                 #[some_other_attr]
@@ -1950,6 +1979,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_index_fn {
                 pub fn get_by_index(x: &mut MyCollection, i: u64) -> FLOAT {
                     x.get(i)
@@ -2014,6 +2044,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_index_fn {
                 pub fn set_by_index(x: &mut MyCollection, i: u64, item: FLOAT) {
                     x.entry(i).set(item)
@@ -2076,6 +2107,7 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_index_fn {
                 pub fn set_by_index(x: &mut MyCollection, i: u64, item: FLOAT) {
                     x.entry(i).set(item)
@@ -2140,7 +2172,9 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod one_constant {
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod it_is {
                     pub const MYSTIC_NUMBER: INT = 42;
                     #[allow(unused_imports)]
@@ -2201,7 +2235,9 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod two_constants {
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod first_is {
                     pub const MYSTIC_NUMBER: INT = 42;
                     #[allow(unused_imports)]
@@ -2221,6 +2257,7 @@ mod generate_tests {
                         if flatten {} else {}
                     }
                 }
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod second_is {
                     #[cfg(hello)]
                     pub const SPECIAL_CPU_NUMBER: INT = 68000;
@@ -2303,12 +2340,16 @@ mod generate_tests {
         };
 
         let expected_tokens = quote! {
+            #[allow(clippy::needless_pass_by_value)]
             pub mod heap_root {
                 pub const VALUE: INT = 100;
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod left {
                     pub const VALUE: INT = 19;
+                    #[allow(clippy::needless_pass_by_value)]
                     pub mod left {
                         pub const VALUE: INT = 17;
+                        #[allow(clippy::needless_pass_by_value)]
                         pub mod left {
                             pub const VALUE: INT = 2;
                             #[allow(unused_imports)]
@@ -2328,6 +2369,7 @@ mod generate_tests {
                                 if flatten {} else {}
                             }
                         }
+                        #[allow(clippy::needless_pass_by_value)]
                         pub mod right {
                             pub const VALUE: INT = 7;
                             #[allow(unused_imports)]
@@ -2371,6 +2413,7 @@ mod generate_tests {
                             }
                         }
                     }
+                    #[allow(clippy::needless_pass_by_value)]
                     pub mod right {
                         pub const VALUE: INT = 3;
                         #[allow(unused_imports)]
@@ -2414,8 +2457,10 @@ mod generate_tests {
                         }
                     }
                 }
+                #[allow(clippy::needless_pass_by_value)]
                 pub mod right {
                     pub const VALUE: INT = 36;
+                    #[allow(clippy::needless_pass_by_value)]
                     pub mod left {
                         pub const VALUE: INT = 25;
                         #[allow(unused_imports)]
@@ -2435,6 +2480,7 @@ mod generate_tests {
                             if flatten {} else {}
                         }
                     }
+                    #[allow(clippy::needless_pass_by_value)]
                     pub mod right {
                         pub const VALUE: INT = 1;
                         #[allow(unused_imports)]

src/api/call_fn.rs

@@ -273,7 +273,7 @@ impl Engine {
         if self.is_debugger_registered() {
             global.debugger_mut().status = crate::eval::DebuggerStatus::Terminate;
             let node = &crate::ast::Stmt::Noop(Position::NONE);
-            self.run_debugger(global, caches, scope, this_ptr.as_deref_mut(), node)?;
+            self.run_debugger(global, caches, scope, this_ptr, node)?;
         }
 
         #[cfg(not(feature = "no_module"))]

src/api/files.rs

@@ -107,7 +107,7 @@ impl Engine {
     #[inline]
     pub fn compile_file_with_scope(&self, scope: &Scope, path: PathBuf) -> RhaiResultOf<AST> {
         Self::read_file(&path).and_then(|contents| {
-            let mut ast = self.compile_with_scope(scope, &contents)?;
+            let mut ast = self.compile_with_scope(scope, contents)?;
             ast.set_source(path.to_string_lossy().as_ref());
             Ok(ast)
         })

src/api/json.rs

@@ -162,7 +162,7 @@ pub fn format_map_as_json(map: &Map) -> String {
             result.push(',');
         }
 
-        write!(result, "{:?}", key).unwrap();
+        write!(result, "{key:?}").unwrap();
         result.push(':');
 
         if let Some(val) = value.read_lock::<Map>() {
@@ -170,7 +170,7 @@ pub fn format_map_as_json(map: &Map) -> String {
         } else if value.is_unit() {
             result.push_str("null");
         } else {
-            write!(result, "{:?}", value).unwrap();
+            write!(result, "{value:?}").unwrap();
         }
     }
 

src/api/mod.rs

@@ -207,13 +207,11 @@ impl Engine {
 
     /// Get the default value of the custom state for each evaluation run.
     #[inline(always)]
-    #[must_use]
     pub const fn default_tag(&self) -> &Dynamic {
         &self.def_tag
     }
     /// Get a mutable reference to the default value of the custom state for each evaluation run.
     #[inline(always)]
-    #[must_use]
     pub fn default_tag_mut(&mut self) -> &mut Dynamic {
         &mut self.def_tag
     }

src/ast/expr.rs

@@ -117,7 +117,7 @@ impl fmt::Debug for FnCallHashes {
             return if script == self.native {
                 fmt::Debug::fmt(&self.native, f)
             } else {
-                write!(f, "({}, {})", script, self.native)
+                write!(f, "({script}, {})", self.native)
             };
         }
 

src/ast/stmt.rs

@@ -71,16 +71,16 @@ impl OpAssignment {
     ///
     /// Panics if the token is not an op-assignment operator.
     #[must_use]
-    pub fn new_op_assignment_from_token(op: Token, pos: Position) -> Self {
+    pub fn new_op_assignment_from_token(op_assign: Token, pos: Position) -> Self {
-        let op_raw = op
+        let op = op_assign
             .get_base_op_from_assignment()
             .expect("op-assignment operator");
 
         Self {
-            hash_op_assign: calc_fn_hash(None, op.literal_syntax(), 2),
+            hash_op_assign: calc_fn_hash(None, op_assign.literal_syntax(), 2),
-            hash_op: calc_fn_hash(None, op_raw.literal_syntax(), 2),
+            hash_op: calc_fn_hash(None, op.literal_syntax(), 2),
-            op_assign: op.clone(),
+            op_assign,
-            op: op_raw,
+            op,
             pos,
         }
     }

src/eval/chaining.rs

@@ -254,12 +254,13 @@ impl Engine {
                 })?;
 
                 let bit_value = (*value & (1 << bit)) != 0;
+                #[allow(clippy::cast_possible_truncation)]
+                let bit = bit as u8;
 
                 Ok(Target::Bit {
                     source: target,
                     value: bit_value.into(),
-                    #[allow(clippy::cast_possible_truncation)]
+                    bit,
-                    bit: bit as u8,
                 })
             }
 

src/eval/debugger.rs

@@ -385,13 +385,11 @@ impl Debugger {
     }
     /// Get the custom state.
     #[inline(always)]
-    #[must_use]
     pub const fn state(&self) -> &Dynamic {
         &self.state
     }
     /// Get a mutable reference to the custom state.
     #[inline(always)]
-    #[must_use]
     pub fn state_mut(&mut self) -> &mut Dynamic {
         &mut self.state
     }

src/eval/eval_context.rs

@@ -72,13 +72,11 @@ impl<'a, 's, 'ps, 'g, 'c, 't> EvalContext<'a, 's, 'ps, 'g, 'c, 't> {
     }
     /// Custom state kept in a [`Dynamic`].
     #[inline(always)]
-    #[must_use]
     pub const fn tag(&self) -> &Dynamic {
         &self.global.tag
     }
     /// Mutable reference to the custom state kept in a [`Dynamic`].
     #[inline(always)]
-    #[must_use]
     pub fn tag_mut(&mut self) -> &mut Dynamic {
         &mut self.global.tag
     }

src/eval/global_state.rs

@@ -317,6 +317,7 @@ impl GlobalRuntimeState {
     ///
     /// Panics if the debugging interface is not set.
     #[cfg(feature = "debugging")]
+    #[must_use]
     pub fn debugger(&self) -> &super::Debugger {
         self.debugger.as_ref().unwrap()
     }
@@ -326,6 +327,7 @@ impl GlobalRuntimeState {
     ///
     /// Panics if the debugging interface is not set.
     #[cfg(feature = "debugging")]
+    #[must_use]
     pub fn debugger_mut(&mut self) -> &mut super::Debugger {
         self.debugger.as_deref_mut().unwrap()
     }

src/eval/target.rs

@@ -235,7 +235,6 @@ impl<'a> Target<'a> {
     /// Get the source [`Dynamic`] of the [`Target`].
     #[allow(dead_code)]
     #[inline]
-    #[must_use]
     pub fn source(&self) -> &Dynamic {
         match self {
             Self::RefMut(r) => r,
@@ -399,7 +398,6 @@ impl Deref for Target<'_> {
 
 impl AsRef<Dynamic> for Target<'_> {
     #[inline(always)]
-    #[must_use]
     fn as_ref(&self) -> &Dynamic {
         self
     }
@@ -407,7 +405,6 @@ impl AsRef<Dynamic> for Target<'_> {
 
 impl Borrow<Dynamic> for Target<'_> {
     #[inline(always)]
-    #[must_use]
     fn borrow(&self) -> &Dynamic {
         self
     }
@@ -432,7 +429,6 @@ impl DerefMut for Target<'_> {
 
 impl AsMut<Dynamic> for Target<'_> {
     #[inline(always)]
-    #[must_use]
     fn as_mut(&mut self) -> &mut Dynamic {
         self
     }

src/func/builtin.rs

@@ -71,11 +71,13 @@ fn is_numeric(type_id: TypeId) -> bool {
 
 /// A function that returns `true`.
 #[inline(always)]
+#[allow(clippy::unnecessary_wraps)]
 fn const_true_fn(_: Option<NativeCallContext>, _: &mut [&mut Dynamic]) -> RhaiResult {
     Ok(Dynamic::TRUE)
 }
 /// A function that returns `false`.
 #[inline(always)]
+#[allow(clippy::unnecessary_wraps)]
 fn const_false_fn(_: Option<NativeCallContext>, _: &mut [&mut Dynamic]) -> RhaiResult {
     Ok(Dynamic::FALSE)
 }

src/func/call.rs

@@ -182,7 +182,7 @@ impl Engine {
         match cache.map.entry(hash) {
             Entry::Occupied(entry) => entry.into_mut().as_ref(),
             Entry::Vacant(entry) => {
-                let num_args = args.as_deref().map_or(0, |a| a.len());
+                let num_args = args.as_deref().map_or(0, FnCallArgs::len);
                 let mut max_bitmask = 0; // One above maximum bitmask based on number of parameters.
                                          // Set later when a specific matching function is not found.
                 let mut bitmask = 1usize; // Bitmask of which parameter to replace with `Dynamic`
@@ -1167,12 +1167,12 @@ impl Engine {
                     .as_int()
                     .map_err(|typ| self.make_type_mismatch_err::<crate::INT>(typ, arg_pos))?;
 
-                return Ok(if !(0..=crate::MAX_USIZE_INT).contains(&num_params) {
+                return Ok(if (0..=crate::MAX_USIZE_INT).contains(&num_params) {
-                    false
+                    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
-                } else {
-                    #[allow(clippy::cast_sign_loss)]
                     let hash_script = calc_fn_hash(None, &fn_name, num_params as usize);
                     self.has_script_fn(global, caches, hash_script)
+                } else {
+                    false
                 }
                 .into());
             }
@@ -1588,7 +1588,7 @@ impl Engine {
                 .0
                 .flatten();
 
-            return value.as_bool().and_then(|r| Ok((!r).into())).or_else(|_| {
+            return value.as_bool().map(|r| (!r).into()).or_else(|_| {
                 let operand = &mut [&mut value];
                 self.exec_fn_call(
                     global, caches, None, name, op_token, *hashes, operand, false, false, pos,

src/func/native.rs

@@ -201,7 +201,7 @@ impl<'a> NativeCallContext<'a> {
     pub fn store_data(&self) -> NativeCallContextStore {
         NativeCallContextStore {
             fn_name: self.fn_name.to_string(),
-            source: self.source.map(|s| s.to_string()),
+            source: self.source.map(ToString::to_string),
             global: self.global.clone(),
             pos: self.pos,
         }

src/func/register.rs

@@ -39,7 +39,6 @@ pub struct Mut<T>(T);
 
 /// Dereference into [`DynamicWriteLock`]
 #[inline(always)]
-#[must_use]
 pub fn by_ref<T: Variant + Clone>(data: &mut Dynamic) -> DynamicWriteLock<T> {
     // Directly cast the &mut Dynamic into DynamicWriteLock to access the underlying data.
     data.write_lock::<T>().expect("checked")

src/func/script.rs

@@ -134,7 +134,6 @@ impl Engine {
                     fn_def.name.to_string(),
                     #[cfg(not(feature = "no_module"))]
                     _environ
-                        .as_deref()
                         .and_then(|environ| environ.lib.id())
                         .unwrap_or_else(|| global.source().unwrap_or(""))
                         .to_string(),

src/lib.rs

@@ -65,7 +65,7 @@
 // #![warn(clippy::all)]
 // #![warn(clippy::pedantic)]
 // #![warn(clippy::nursery)]
-// #![warn(clippy::cargo)]
+#![warn(clippy::cargo)]
 // #![warn(clippy::undocumented_unsafe_blocks)]
 #![allow(clippy::unit_arg)]
 #![allow(clippy::missing_errors_doc)]
@@ -78,6 +78,13 @@
 #![allow(clippy::box_collection)]
 #![allow(clippy::too_many_arguments)]
 #![allow(clippy::upper_case_acronyms)]
+#![allow(clippy::match_same_arms)]
+// The lints below can be turned off to reduce signal/noise ratio
+// #![allow(clippy::too_many_lines)]
+// #![allow(clippy::let_underscore_drop)]
+// #![allow(clippy::absurd_extreme_comparisons)]
+// #![allow(clippy::unnecessary_cast)]
+// #![allow(clippy::wildcard_imports)]
 
 #[cfg(feature = "no_std")]
 extern crate alloc;

src/module/mod.rs

@@ -1962,7 +1962,7 @@ impl Module {
     #[inline]
     #[allow(dead_code)]
     pub(crate) fn iter_fn(&self) -> impl Iterator<Item = &FuncInfo> {
-        self.functions.iter().flat_map(|m| m.values())
+        self.functions.iter().flat_map(StraightHashMap::values)
     }
 
     /// Get an iterator over all script-defined functions in the [`Module`].
@@ -2187,9 +2187,11 @@ impl Module {
                 let f = module.functions.as_mut().unwrap().get_mut(&hash).unwrap();
 
                 // Encapsulate AST environment
-                match &mut f.func {
+                if let CallableFunction::Script {
-                    CallableFunction::Script { environ: e, .. } => *e = Some(environ.clone()),
+                    environ: ref mut e, ..
-                    _ => (),
+                } = f.func
+                {
+                    *e = Some(environ.clone())
                 }
             });
 

src/optimizer.rs

@@ -932,6 +932,7 @@ fn optimize_expr(expr: &mut Expr, state: &mut OptimizerState, _chaining: bool) {
         }
         // lhs[rhs]
         #[cfg(not(feature = "no_index"))]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         Expr::Index(x, ..) if !_chaining => match (&mut x.lhs, &mut x.rhs) {
             // array[int]
             (Expr::Array(a, pos), Expr::IntegerConstant(i, ..)) if *i >= 0 && *i <= crate::MAX_USIZE_INT && (*i as usize) < a.len() && a.iter().all(Expr::is_pure) => {
@@ -1339,7 +1340,11 @@ impl Engine {
         let lib: crate::Shared<_> = {
             let mut module = crate::Module::new();
 
-            if optimization_level != OptimizationLevel::None {
+            if optimization_level == OptimizationLevel::None {
+                for fn_def in functions {
+                    module.set_script_fn(fn_def);
+                }
+            } else {
                 // We only need the script library's signatures for optimization purposes
                 let mut lib2 = crate::Module::new();
 
@@ -1365,10 +1370,6 @@ impl Engine {
 
                     *fn_def.body = self.optimize_top_level(body, scope, lib2, optimization_level);
 
-                    module.set_script_fn(fn_def);
-                }
-            } else {
-                for fn_def in functions {
                     module.set_script_fn(fn_def);
                 }
             }

src/packages/arithmetic.rs

@@ -276,6 +276,7 @@ gen_signed_functions!(signed_num_128 => i128);
 #[export_module]
 mod f32_functions {
     #[cfg(not(feature = "f32_float"))]
+    #[allow(clippy::cast_precision_loss)]
     pub mod basic_arithmetic {
         #[rhai_fn(name = "+")]
         pub fn add(x: f32, y: f32) -> f32 {
@@ -381,6 +382,7 @@ mod f32_functions {
                 "Number raised to too large an index: {x} ** {y}"
             )))
         } else {
+            #[allow(clippy::cast_possible_truncation)]
             Ok(x.powi(y as i32))
         }
     }

src/packages/array_basic.rs

@@ -220,14 +220,18 @@ pub mod array_functions {
         len: INT,
         item: Dynamic,
     ) -> RhaiResultOf<()> {
-        let len = len.min(MAX_USIZE_INT);
+        if len <= 0 {
+            return Ok(());
+        }
 
-        if len <= 0 || (len as usize) <= array.len() {
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+        let len = len.min(MAX_USIZE_INT) as usize;
+
+        if len <= array.len() {
             return Ok(());
         }
 
         let _ctx = ctx;
-        let len = len as usize;
 
         // Check if array will be over max size limit
         #[cfg(not(feature = "unchecked"))]
@@ -373,11 +377,16 @@ pub mod array_functions {
     /// print(x);       // prints "[1, 2, 3]"
     /// ```
     pub fn truncate(array: &mut Array, len: INT) {
+        if len <= 0 {
+            array.clear();
+            return;
+        }
         if !array.is_empty() {
-            let len = len.min(MAX_USIZE_INT);
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+            let len = len.min(MAX_USIZE_INT) as usize;
 
             if len > 0 {
-                array.truncate(len as usize);
+                array.truncate(len);
             } else {
                 array.clear();
             }
@@ -402,13 +411,18 @@ pub mod array_functions {
     /// print(x);       // prints "[3, 4, 5]"
     /// ```
     pub fn chop(array: &mut Array, len: INT) {
+        if len <= 0 {
+            array.clear();
+            return;
+        }
         if !array.is_empty() {
-            let len = len.min(MAX_USIZE_INT);
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+            let len = len.min(MAX_USIZE_INT) as usize;
 
             if len <= 0 {
                 array.clear();
-            } else if (len as usize) < array.len() {
+            } else if len < array.len() {
-                array.drain(0..array.len() - len as usize);
+                array.drain(0..array.len() - len);
             }
         }
     }
@@ -1178,7 +1192,7 @@ pub mod array_functions {
     /// ```
     pub fn dedup(ctx: NativeCallContext, array: &mut Array) {
         let comparer = FnPtr::new_unchecked(OP_EQUALS, StaticVec::new_const());
-        dedup_by_comparer(ctx, array, comparer)
+        dedup_by_comparer(ctx, array, comparer);
     }
     /// Remove duplicated _consecutive_ elements from the array that return `true` when applied the
     /// `comparer` function.

src/packages/bit_field.rs

@@ -132,6 +132,7 @@ mod bit_field_functions {
             ERR::ErrorBitFieldBounds(INT_BITS, start, Position::NONE).into()
         })?;
 
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let bits = if bit + bits as usize > INT_BITS {
             INT_BITS - bit
         } else {
@@ -143,6 +144,7 @@ mod bit_field_functions {
         }
 
         // 2^bits - 1
+        #[allow(clippy::cast_possible_truncation)]
         let mask = ((2 as UNSIGNED_INT).pow(bits as u32) - 1) as INT;
 
         Ok(((value & (mask << bit)) >> bit) & mask)
@@ -218,6 +220,7 @@ mod bit_field_functions {
             ERR::ErrorBitFieldBounds(INT_BITS, bit, Position::NONE).into()
         })?;
 
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let bits = if bit + bits as usize > INT_BITS {
             INT_BITS - bit
         } else {
@@ -230,6 +233,7 @@ mod bit_field_functions {
         }
 
         // 2^bits - 1
+        #[allow(clippy::cast_possible_truncation)]
         let mask = ((2 as UNSIGNED_INT).pow(bits as u32) - 1) as INT;
 
         *value &= !(mask << bit);

src/packages/blob_basic.rs

@@ -75,7 +75,8 @@ pub mod blob_functions {
         len: INT,
         value: INT,
     ) -> RhaiResultOf<Blob> {
-        let len = len.min(MAX_USIZE_INT).max(0) as usize;
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+        let len = len.clamp(0, MAX_USIZE_INT) as usize;
         let _ctx = ctx;
 
         // Check if blob will be over max size limit
@@ -83,6 +84,7 @@ pub mod blob_functions {
         _ctx.engine().throw_on_size((len, 0, 0))?;
 
         let mut blob = Blob::new();
+        #[allow(clippy::cast_sign_loss)]
         blob.resize(len, (value & 0x0000_00ff) as u8);
         Ok(blob)
     }
@@ -155,6 +157,7 @@ pub mod blob_functions {
     /// ```
     #[rhai_fn(name = "contains")]
     pub fn contains(blob: &mut Blob, value: INT) -> bool {
+        #[allow(clippy::cast_sign_loss)]
         blob.contains(&((value & 0x0000_00ff) as u8))
     }
     /// Get the byte value at the `index` position in the BLOB.
@@ -221,6 +224,7 @@ pub mod blob_functions {
 
         let (index, ..) = calc_offset_len(blob.len(), index, 0);
 
+        #[allow(clippy::cast_sign_loss)]
         if index < blob.len() {
             blob[index] = (value & 0x0000_00ff) as u8;
         }
@@ -240,6 +244,7 @@ pub mod blob_functions {
     /// ```
     #[rhai_fn(name = "push", name = "append")]
     pub fn push(blob: &mut Blob, value: INT) {
+        #[allow(clippy::cast_sign_loss)]
         blob.push((value & 0x0000_00ff) as u8);
     }
     /// Add another BLOB to the end of the BLOB.
@@ -315,6 +320,7 @@ pub mod blob_functions {
     /// print(b);       // prints "[4242184242]"
     /// ```
     pub fn insert(blob: &mut Blob, index: INT, value: INT) {
+        #[allow(clippy::cast_sign_loss)]
         let value = (value & 0x0000_00ff) as u8;
 
         if blob.is_empty() {
@@ -354,8 +360,10 @@ pub mod blob_functions {
         if len <= 0 {
             return Ok(());
         }
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let len = len.min(MAX_USIZE_INT) as usize;
 
+        #[allow(clippy::cast_sign_loss)]
         let value = (value & 0x0000_00ff) as u8;
         let _ctx = ctx;
 
@@ -470,11 +478,16 @@ pub mod blob_functions {
     /// print(b);           // prints "[010203]"
     /// ```
     pub fn truncate(blob: &mut Blob, len: INT) {
+        if len <= 0 {
+            blob.clear();
+            return;
+        }
         if !blob.is_empty() {
-            let len = len.min(MAX_USIZE_INT);
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+            let len = len.min(MAX_USIZE_INT) as usize;
 
             if len > 0 {
-                blob.truncate(len as usize);
+                blob.truncate(len);
             } else {
                 blob.clear();
             }
@@ -500,6 +513,7 @@ pub mod blob_functions {
     ///
     /// print(b);           // prints "[030405]"
     /// ```
+    #[allow(clippy::cast_sign_loss, clippy::needless_pass_by_value)]
     pub fn chop(blob: &mut Blob, len: INT) {
         if !blob.is_empty() {
             if len <= 0 {

src/packages/iter_basic.rs

@@ -22,6 +22,7 @@ use rust_decimal::Decimal;
 
 #[cfg(not(feature = "unchecked"))]
 #[inline(always)]
+#[allow(clippy::needless_pass_by_value)]
 fn std_add<T>(x: T, y: T) -> Option<T>
 where
     T: num_traits::CheckedAdd<Output = T>,
@@ -30,6 +31,7 @@ where
 }
 #[inline(always)]
 #[allow(dead_code)]
+#[allow(clippy::unnecessary_wraps, clippy::needless_pass_by_value)]
 fn regular_add<T>(x: T, y: T) -> Option<T>
 where
     T: std::ops::Add<Output = T>,
@@ -123,6 +125,7 @@ impl<T: Copy + PartialOrd> FusedIterator for StepRange<T> {}
 pub struct BitRange(INT, usize);
 
 impl BitRange {
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     pub fn new(value: INT, from: INT, len: INT) -> RhaiResultOf<Self> {
         let from = calc_index(INT_BITS, from, true, || {
             ERR::ErrorBitFieldBounds(INT_BITS, from, Position::NONE).into()
@@ -174,6 +177,7 @@ impl ExactSizeIterator for BitRange {
 pub struct CharsStream(Vec<char>, usize);
 
 impl CharsStream {
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     pub fn new(string: &str, from: INT, len: INT) -> Self {
         if len <= 0 || from > MAX_USIZE_INT {
             return Self(Vec::new(), 0);

src/packages/lang_core.rs

@@ -153,8 +153,9 @@ mod reflection_functions {
     /// Return an array of object maps containing metadata of all script-defined functions
     /// matching the specified name and arity (number of parameters).
     #[rhai_fn(name = "get_fn_metadata_list")]
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     pub fn get_fn_metadata2(ctx: NativeCallContext, name: &str, params: INT) -> Array {
-        if params < 0 || params > crate::MAX_USIZE_INT {
+        if !(0..=crate::MAX_USIZE_INT).contains(&params) {
             Array::new()
         } else {
             collect_fn_metadata(ctx, |_, _, n, p, _| p == (params as usize) && n == name)

src/packages/math_basic.rs

@@ -477,7 +477,7 @@ mod decimal_functions {
             }
         }
 
-        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         Ok(x.round_dp(digits as u32))
     }
     /// Round the decimal number to the specified number of `digits` after the decimal point and return it.
@@ -495,7 +495,7 @@ mod decimal_functions {
             }
         }
 
-        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         Ok(x.round_dp_with_strategy(digits as u32, RoundingStrategy::AwayFromZero))
     }
     /// Round the decimal number to the specified number of `digits` after the decimal point and return it.
@@ -513,7 +513,7 @@ mod decimal_functions {
             }
         }
 
-        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         Ok(x.round_dp_with_strategy(digits as u32, RoundingStrategy::ToZero))
     }
     /// Round the decimal number to the specified number of `digits` after the decimal point and return it.
@@ -531,7 +531,7 @@ mod decimal_functions {
             }
         }
 
-        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         Ok(x.round_dp_with_strategy(digits as u32, RoundingStrategy::MidpointAwayFromZero))
     }
     /// Round the decimal number to the specified number of `digits` after the decimal point and return it.
@@ -549,33 +549,34 @@ mod decimal_functions {
             }
         }
 
-        #[allow(clippy::cast_sign_loss)]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         Ok(x.round_dp_with_strategy(digits as u32, RoundingStrategy::MidpointTowardZero))
     }
     /// Convert the decimal number into an integer.
     #[rhai_fn(return_raw)]
     pub fn to_int(x: Decimal) -> RhaiResultOf<INT> {
-        let n = x.to_i64().and_then(|n| {
+        x.to_i64()
-            #[cfg(feature = "only_i32")]
+            .and_then(|n| {
-            return if n > (INT::MAX as i64) || n < (INT::MIN as i64) {
+                #[cfg(feature = "only_i32")]
-                None
+                return if n > (INT::MAX as i64) || n < (INT::MIN as i64) {
-            } else {
+                    None
-                Some(n as i32)
+                } else {
-            };
+                    Some(n as i32)
+                };
 
-            #[cfg(not(feature = "only_i32"))]
+                #[cfg(not(feature = "only_i32"))]
-            return Some(n);
+                return Some(n);
-        });
+            })
-
+            .map_or_else(
-        n.map_or_else(
+                || {
-            || {
+                    Err(ERR::ErrorArithmetic(
-                Err(
+                        format!("Integer overflow: to_int({x})"),
-                    ERR::ErrorArithmetic(format!("Integer overflow: to_int({x})"), Position::NONE)
+                        Position::NONE,
-                        .into(),
+                    )
-                )
+                    .into())
-            },
+                },
-            Ok,
+                Ok,
-        )
+            )
     }
     /// Return the integral part of the decimal number.
     #[rhai_fn(name = "int", get = "int")]

src/packages/string_more.rs

@@ -95,11 +95,11 @@ mod string_functions {
 
     #[rhai_fn(name = "+=")]
     pub fn add_assign_append_str(string1: &mut ImmutableString, string2: ImmutableString) {
-        *string1 += string2
+        *string1 += string2;
     }
     #[rhai_fn(name = "+=", pure)]
     pub fn add_assign_append_char(string: &mut ImmutableString, character: char) {
-        *string += character
+        *string += character;
     }
     #[rhai_fn(name = "+=")]
     pub fn add_assign_append_unit(string: &mut ImmutableString, item: ()) {
@@ -246,9 +246,9 @@ mod string_functions {
     pub fn clear(string: &mut ImmutableString) {
         if !string.is_empty() {
             if let Some(s) = string.get_mut() {
-                s.clear()
+                s.clear();
             } else {
-                *string = ImmutableString::new()
+                *string = ImmutableString::new();
             }
         }
     }
@@ -272,7 +272,7 @@ mod string_functions {
     /// ```
     pub fn truncate(string: &mut ImmutableString, len: INT) {
         if len > 0 {
-            #[allow(clippy::cast_sign_loss)]
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             let len = len.min(MAX_USIZE_INT) as usize;
             let chars: StaticVec<_> = string.chars().collect();
             let copy = string.make_mut();
@@ -355,6 +355,7 @@ mod string_functions {
         if string.is_empty() || len <= 0 {
             return ctx.engine().const_empty_string();
         }
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let len = len.min(MAX_USIZE_INT) as usize;
 
         let mut chars = StaticVec::<char>::with_capacity(len);
@@ -598,6 +599,7 @@ mod string_functions {
             return -1;
         }
 
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let start = if start < 0 {
             let abs_start = start.unsigned_abs();
 
@@ -608,6 +610,7 @@ mod string_functions {
             let abs_start = abs_start as usize;
             let chars: Vec<_> = string.chars().collect();
             let num_chars = chars.len();
+
             if abs_start > num_chars {
                 0
             } else {
@@ -680,6 +683,7 @@ mod string_functions {
             return -1;
         }
 
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let start = if start < 0 {
             let abs_start = start.unsigned_abs();
 
@@ -690,6 +694,7 @@ mod string_functions {
             let abs_start = abs_start as usize;
             let chars = string.chars().collect::<Vec<_>>();
             let num_chars = chars.len();
+
             if abs_start > num_chars {
                 0
             } else {
@@ -763,9 +768,12 @@ mod string_functions {
                 return Dynamic::UNIT;
             }
 
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+            let index = index as usize;
+
             string
                 .chars()
-                .nth(index as usize)
+                .nth(index)
                 .map_or_else(|| Dynamic::UNIT, Into::into)
         } else {
             // Count from end if negative
@@ -775,10 +783,13 @@ mod string_functions {
                 return Dynamic::UNIT;
             }
 
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+            let abs_index = abs_index as usize;
+
             string
                 .chars()
                 .rev()
-                .nth((abs_index as usize) - 1)
+                .nth(abs_index - 1)
                 .map_or_else(|| Dynamic::UNIT, Into::into)
         }
     }
@@ -811,6 +822,7 @@ mod string_functions {
                 return;
             }
 
+            #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
             let index = index as usize;
 
             *string = string
@@ -825,6 +837,7 @@ mod string_functions {
                 return;
             }
 
+            #[allow(clippy::cast_possible_truncation)]
             let abs_index = abs_index as usize;
             let string_len = string.chars().count();
 
@@ -894,13 +907,14 @@ mod string_functions {
     ///
     /// print(text.sub_string(-8, 3));  // prints ", w"
     /// ```
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
     pub fn sub_string(
         ctx: NativeCallContext,
         string: &str,
         start: INT,
         len: INT,
     ) -> ImmutableString {
-        if string.is_empty() {
+        if string.is_empty() || len <= 0 {
             return ctx.engine().const_empty_string();
         }
 
@@ -915,8 +929,11 @@ mod string_functions {
                 return ctx.engine().const_empty_string();
             }
 
+            #[allow(clippy::cast_possible_truncation)]
             let abs_start = abs_start as usize;
+
             chars.extend(string.chars());
+
             if abs_start > chars.len() {
                 0
             } else {
@@ -932,10 +949,12 @@ mod string_functions {
             chars.extend(string.chars());
         }
 
-        let len = if offset + len as usize > chars.len() {
+        let len = len.min(MAX_USIZE_INT) as usize;
+
+        let len = if offset + len > chars.len() {
             chars.len() - offset
         } else {
-            len as usize
+            len
         };
 
         chars
@@ -988,10 +1007,10 @@ mod string_functions {
     /// print(text);        // prints "llo, w"
     /// ```
     #[rhai_fn(name = "crop")]
-    pub fn crop_range(string: &mut ImmutableString, range: ExclusiveRange) {
+    pub fn crop_range(ctx: NativeCallContext, string: &mut ImmutableString, range: ExclusiveRange) {
         let start = INT::max(range.start, 0);
         let end = INT::max(range.end, start);
-        crop(string, start, end - start);
+        crop(ctx, string, start, end - start);
     }
     /// Remove all characters from the string except those within an inclusive `range`.
     ///
@@ -1005,10 +1024,14 @@ mod string_functions {
     /// print(text);        // prints "llo, wo"
     /// ```
     #[rhai_fn(name = "crop")]
-    pub fn crop_inclusive_range(string: &mut ImmutableString, range: InclusiveRange) {
+    pub fn crop_inclusive_range(
+        ctx: NativeCallContext,
+        string: &mut ImmutableString,
+        range: InclusiveRange,
+    ) {
         let start = INT::max(*range.start(), 0);
         let end = INT::max(*range.end(), start);
-        crop(string, start, end - start + 1);
+        crop(ctx, string, start, end - start + 1);
     }
 
     /// Remove all characters from the string except those within a range.
@@ -1033,10 +1056,15 @@ mod string_functions {
     /// print(text);        // prints ", w"
     /// ```
     #[rhai_fn(name = "crop")]
-    pub fn crop(string: &mut ImmutableString, start: INT, len: INT) {
+    #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
+    pub fn crop(ctx: NativeCallContext, string: &mut ImmutableString, start: INT, len: INT) {
         if string.is_empty() {
             return;
         }
+        if len <= 0 {
+            *string = ctx.engine().const_empty_string();
+            return;
+        }
 
         let mut chars = StaticVec::with_capacity(string.len());
 
@@ -1051,7 +1079,9 @@ mod string_functions {
             }
 
             let abs_start = abs_start as usize;
+
             chars.extend(string.chars());
+
             if abs_start > chars.len() {
                 0
             } else {
@@ -1068,10 +1098,12 @@ mod string_functions {
             chars.extend(string.chars());
         }
 
-        let len = if offset + len as usize > chars.len() {
+        let len = len.min(MAX_USIZE_INT) as usize;
+
+        let len = if offset + len > chars.len() {
             chars.len() - offset
         } else {
-            len as usize
+            len
         };
 
         let copy = string.make_mut();
@@ -1098,8 +1130,12 @@ mod string_functions {
     /// print(text);            // prints "ld!"
     /// ```
     #[rhai_fn(name = "crop")]
-    pub fn crop_string_starting_from(string: &mut ImmutableString, start: INT) {
+    pub fn crop_string_starting_from(
-        crop(string, start, string.len() as INT);
+        ctx: NativeCallContext,
+        string: &mut ImmutableString,
+        start: INT,
+    ) {
+        crop(ctx, string, start, string.len() as INT);
     }
 
     /// Replace all occurrences of the specified sub-string in the string with another string.
@@ -1219,6 +1255,7 @@ mod string_functions {
         if len <= 0 {
             return Ok(());
         }
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let len = len.min(MAX_USIZE_INT) as usize;
         let _ctx = ctx;
 
@@ -1275,6 +1312,7 @@ mod string_functions {
         if len <= 0 {
             return Ok(());
         }
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         let len = len.min(MAX_USIZE_INT) as usize;
         let _ctx = ctx;
 
@@ -1339,6 +1377,7 @@ mod string_functions {
         /// print(text.split(-99));     // prints ["", "hello, world!"]
         /// ```
         #[rhai_fn(name = "split")]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         pub fn split_at(ctx: NativeCallContext, string: &mut ImmutableString, index: INT) -> Array {
             if index <= 0 {
                 let abs_index = index.unsigned_abs();
@@ -1349,9 +1388,9 @@ mod string_functions {
                         string.as_str().into(),
                     ];
                 }
-
                 let abs_index = abs_index as usize;
                 let num_chars = string.chars().count();
+
                 if abs_index > num_chars {
                     vec![
                         ctx.engine().const_empty_string().into(),
@@ -1432,7 +1471,11 @@ mod string_functions {
         /// print(text.split("ll", 2));     // prints ["he", "o, world! hello, foo!"]
         /// ```
         #[rhai_fn(name = "split")]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         pub fn splitn(string: &str, delimiter: &str, segments: INT) -> Array {
+            if segments < 1 {
+                return [string.into()].into();
+            }
             let segments = segments.min(MAX_USIZE_INT) as usize;
             let pieces: usize = if segments < 1 { 1 } else { segments };
             string.splitn(pieces, delimiter).map(Into::into).collect()
@@ -1463,7 +1506,11 @@ mod string_functions {
         /// print(text.split('l', 3));      // prints ["he", "", "o, world! hello, foo!"]
         /// ```
         #[rhai_fn(name = "split")]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         pub fn splitn_char(string: &str, delimiter: char, segments: INT) -> Array {
+            if segments < 1 {
+                return [string.into()].into();
+            }
             let segments = segments.min(MAX_USIZE_INT) as usize;
             let pieces: usize = if segments < 1 { 1 } else { segments };
             string.splitn(pieces, delimiter).map(Into::into).collect()
@@ -1495,7 +1542,11 @@ mod string_functions {
         /// print(text.split_rev("ll", 2));     // prints ["o, foo!", "hello, world! he"]
         /// ```
         #[rhai_fn(name = "split_rev")]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         pub fn rsplitn(string: &str, delimiter: &str, segments: INT) -> Array {
+            if segments < 1 {
+                return [string.into()].into();
+            }
             let segments = segments.min(MAX_USIZE_INT) as usize;
             let pieces: usize = if segments < 1 { 1 } else { segments };
             string.rsplitn(pieces, delimiter).map(Into::into).collect()
@@ -1527,7 +1578,11 @@ mod string_functions {
         /// print(text.split('l', 3));      // prints ["o, foo!", "", "hello, world! he"
         /// ```
         #[rhai_fn(name = "split_rev")]
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         pub fn rsplitn_char(string: &str, delimiter: char, segments: INT) -> Array {
+            if segments < 1 {
+                return [string.into()].into();
+            }
             let segments = segments.min(MAX_USIZE_INT) as usize;
             let pieces: usize = if segments < 1 { 1 } else { segments };
             string.rsplitn(pieces, delimiter).map(Into::into).collect()

src/packages/time_basic.rs

@@ -114,11 +114,12 @@ mod time_functions {
 
     #[cfg(not(feature = "no_float"))]
     pub mod float_functions {
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         fn add_impl(timestamp: Instant, seconds: FLOAT) -> RhaiResultOf<Instant> {
             if seconds < 0.0 {
                 subtract_impl(timestamp, -seconds)
             } else if cfg!(not(feature = "unchecked")) {
-                if seconds > (INT::MAX as FLOAT) {
+                if seconds > (INT::MAX as FLOAT).min(u64::MAX as FLOAT) {
                     Err(make_arithmetic_err(format!(
                         "Integer overflow for timestamp add: {seconds}"
                     )))
@@ -135,20 +136,21 @@ mod time_functions {
                 Ok(timestamp + Duration::from_millis((seconds * 1000.0) as u64))
             }
         }
+        #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
         fn subtract_impl(timestamp: Instant, seconds: FLOAT) -> RhaiResultOf<Instant> {
             if seconds < 0.0 {
                 add_impl(timestamp, -seconds)
             } else if cfg!(not(feature = "unchecked")) {
-                if seconds > (INT::MAX as FLOAT) {
+                if seconds > (INT::MAX as FLOAT).min(u64::MAX as FLOAT) {
                     Err(make_arithmetic_err(format!(
-                        "Integer overflow for timestamp add: {seconds}"
+                        "Integer overflow for timestamp subtract: {seconds}"
                     )))
                 } else {
                     timestamp
                         .checked_sub(Duration::from_millis((seconds * 1000.0) as u64))
                         .ok_or_else(|| {
                             make_arithmetic_err(format!(
-                                "Timestamp overflow when adding {seconds} second(s)"
+                                "Timestamp overflow when subtracting {seconds} second(s)"
                             ))
                         })
                 }
@@ -182,6 +184,7 @@ mod time_functions {
     }
 
     fn add_impl(timestamp: Instant, seconds: INT) -> RhaiResultOf<Instant> {
+        #[allow(clippy::cast_sign_loss)]
         if seconds < 0 {
             subtract_impl(timestamp, -seconds)
         } else if cfg!(not(feature = "unchecked")) {
@@ -197,6 +200,7 @@ mod time_functions {
         }
     }
     fn subtract_impl(timestamp: Instant, seconds: INT) -> RhaiResultOf<Instant> {
+        #[allow(clippy::cast_sign_loss)]
         if seconds < 0 {
             add_impl(timestamp, -seconds)
         } else if cfg!(not(feature = "unchecked")) {
@@ -204,7 +208,7 @@ mod time_functions {
                 .checked_sub(Duration::from_secs(seconds as u64))
                 .ok_or_else(|| {
                     make_arithmetic_err(format!(
-                        "Timestamp overflow when adding {seconds} second(s)"
+                        "Timestamp overflow when subtracting {seconds} second(s)"
                     ))
                 })
         } else {

src/parser.rs

@@ -26,6 +26,7 @@ use bitflags::bitflags;
 use std::prelude::v1::*;
 use std::{
     collections::BTreeMap,
+    convert::TryFrom,
     fmt,
     hash::{Hash, Hasher},
     num::{NonZeroU8, NonZeroUsize},
@@ -147,7 +148,7 @@ impl<'e, 's> ParseState<'e, 's> {
             .stack
             .as_deref()
             .into_iter()
-            .flat_map(|s| s.iter_rev_raw())
+            .flat_map(Scope::iter_rev_raw)
             .enumerate()
             .find(|&(.., (n, ..))| {
                 if n == SCOPE_SEARCH_BARRIER_MARKER {
@@ -363,7 +364,7 @@ pub fn make_anonymous_fn(hash: u64) -> Identifier {
     use std::fmt::Write;
 
     let mut buf = Identifier::new_const();
-    write!(&mut buf, "{}{:016x}", crate::engine::FN_ANONYMOUS, hash).unwrap();
+    write!(&mut buf, "{}{hash:016x}", crate::engine::FN_ANONYMOUS).unwrap();
     buf
 }
 
@@ -1198,14 +1199,14 @@ impl Engine {
             };
 
             let (action_expr, need_comma) =
-                if !settings.has_flag(ParseSettingFlags::DISALLOW_STATEMENTS_IN_BLOCKS) {
+                if settings.has_flag(ParseSettingFlags::DISALLOW_STATEMENTS_IN_BLOCKS) {
+                    (self.parse_expr(input, state, lib, settings)?, true)
+                } else {
                     let stmt = self.parse_stmt(input, state, lib, settings)?;
                     let need_comma = !stmt.is_self_terminated();
 
                     let stmt_block: StmtBlock = stmt.into();
                     (Expr::Stmt(stmt_block.into()), need_comma)
-                } else {
-                    (self.parse_expr(input, state, lib, settings)?, true)
                 };
             let has_condition = !matches!(condition, Expr::BoolConstant(true, ..));
 
@@ -1293,8 +1294,8 @@ impl Engine {
         let cases = SwitchCasesCollection {
             expressions,
             cases,
-            def_case,
             ranges,
+            def_case,
         };
 
         Ok(Stmt::Switch((item, cases).into(), settings.pos))
@@ -1636,13 +1637,9 @@ impl Engine {
                             );
                         }
 
-                        let short_index = index.and_then(|x| {
+                        let short_index = index
-                            if x.get() <= u8::MAX as usize {
+                            .and_then(|x| u8::try_from(x.get()).ok())
-                                NonZeroU8::new(x.get() as u8)
+                            .and_then(NonZeroU8::new);
-                            } else {
-                                None
-                            }
-                        });
                         let name = state.get_interned_string(*s);
                         Expr::Variable((index, ns, 0, name).into(), short_index, settings.pos)
                     }
@@ -2023,16 +2020,16 @@ impl Engine {
             }
         }
 
-        let op_info = if op != NO_TOKEN {
+        let op_info = if op == NO_TOKEN {
-            OpAssignment::new_op_assignment_from_token(op, op_pos)
-        } else {
             OpAssignment::new_assignment(op_pos)
+        } else {
+            OpAssignment::new_op_assignment_from_token(op, op_pos)
         };
 
         match lhs {
             // const_expr = rhs
             ref expr if expr.is_constant() => {
-                Err(PERR::AssignmentToConstant("".into()).into_err(lhs.start_position()))
+                Err(PERR::AssignmentToConstant(String::new()).into_err(lhs.start_position()))
             }
             // var (non-indexed) = rhs
             Expr::Variable(ref x, None, _) if x.0.is_none() => {
@@ -2384,7 +2381,7 @@ impl Engine {
                         let not_base = FnCallExpr {
                             namespace: Namespace::NONE,
                             name: state.get_interned_string(op),
-                            hashes: FnCallHashes::from_native(calc_fn_hash(None, op, 1).into()),
+                            hashes: FnCallHashes::from_native(calc_fn_hash(None, op, 1)),
                             args,
                             op_token: Token::Bang,
                             capture_parent_scope: false,
@@ -3661,7 +3658,7 @@ impl Engine {
                 Some(n) if !is_func && n.get() <= u8::MAX as usize => NonZeroU8::new(n.get() as u8),
                 _ => None,
             };
-            Expr::Variable((index, Default::default(), 0, name).into(), idx, pos)
+            Expr::Variable((index, Namespace::default(), 0, name).into(), idx, pos)
         }));
 
         let expr = FnCallExpr {

src/serde/serialize.rs

@@ -98,6 +98,7 @@ impl Serialize for Scope<'_> {
             pub is_constant: bool,
         }
 
+        #[allow(clippy::trivially_copy_pass_by_ref)]
         fn is_false(value: &bool) -> bool {
             !value
         }

src/tokenizer.rs

@@ -21,12 +21,15 @@ use std::{
 #[derive(Debug, Clone, Eq, PartialEq, Default, Hash)]
 pub struct TokenizerControlBlock {
     /// Is the current tokenizer position within an interpolated text string?
+    ///
     /// This flag allows switching the tokenizer back to _text_ parsing after an interpolation stream.
     pub is_within_text: bool,
     /// Global comments.
     #[cfg(feature = "metadata")]
     pub global_comments: String,
     /// Whitespace-compressed version of the script (if any).
+    ///
+    /// Set to `Some` in order to collect a compressed script.
     pub compressed: Option<String>,
 }
 
@@ -882,7 +885,9 @@ pub struct TokenizeState {
     pub include_comments: bool,
     /// Is the current tokenizer position within the text stream of an interpolated string?
     pub is_within_text_terminated_by: Option<char>,
-    /// Last token
+    /// Textual syntax of the current token, if any.
+    ///
+    /// Set to `Some` to begin tracking this information.
     pub last_token: Option<SmartString>,
 }
 
@@ -961,10 +966,10 @@ pub fn parse_string_literal(
     let mut skip_whitespace_until = 0;
 
     state.is_within_text_terminated_by = Some(termination_char);
-    state.last_token.as_mut().map(|last| {
+    if let Some(ref mut last) = state.last_token {
         last.clear();
         last.push(termination_char);
-    });
+    }
 
     loop {
         assert!(
@@ -983,7 +988,7 @@ pub fn parse_string_literal(
                 break;
             }
             None if allow_line_continuation && !escape.is_empty() => {
-                assert_eq!(escape, "\\", "unexpected escape {} at end of line", escape);
+                assert_eq!(escape, "\\", "unexpected escape {escape} at end of line");
                 pos.advance();
                 break;
             }
@@ -994,7 +999,9 @@ pub fn parse_string_literal(
             }
         };
 
-        state.last_token.as_mut().map(|last| last.push(next_char));
+        if let Some(ref mut last) = state.last_token {
+            last.push(next_char);
+        }
 
         // String interpolation?
         if allow_interpolation
@@ -1015,10 +1022,9 @@ pub fn parse_string_literal(
             // Double wrapper
             if stream.peek_next().map_or(false, |c| c == termination_char) {
                 eat_next(stream, pos);
-                state
+                if let Some(ref mut last) = state.last_token {
-                    .last_token
+                    last.push(termination_char);
-                    .as_mut()
+                }
-                    .map(|last| last.push(termination_char));
             } else {
                 state.is_within_text_terminated_by = None;
                 break;
@@ -1075,9 +1081,11 @@ pub fn parse_string_literal(
                         .get_next()
                         .ok_or_else(|| (LERR::MalformedEscapeSequence(seq.to_string()), *pos))?;
 
-                    state.last_token.as_mut().map(|last| last.push(c));
-                    seq.push(c);
                     pos.advance();
+                    seq.push(c);
+                    if let Some(ref mut last) = state.last_token {
+                        last.push(c);
+                    }
 
                     out_val *= 16;
                     out_val += c
@@ -1106,7 +1114,7 @@ pub fn parse_string_literal(
 
             // Line continuation
             '\n' if allow_line_continuation && !escape.is_empty() => {
-                assert_eq!(escape, "\\", "unexpected escape {} at end of line", escape);
+                assert_eq!(escape, "\\", "unexpected escape {escape} at end of line");
                 escape.clear();
                 pos.new_line();
 
@@ -1256,7 +1264,7 @@ fn get_next_token_inner(
     state: &mut TokenizeState,
     pos: &mut Position,
 ) -> Option<(Token, Position)> {
-    state.last_token.as_mut().map(|last| last.clear());
+    state.last_token.as_mut().map(SmartString::clear);
 
     // Still inside a comment?
     if state.comment_level > 0 {
@@ -1338,7 +1346,7 @@ fn get_next_token_inner(
                                     pos.advance();
                                 }
                                 // _ - cannot follow a decimal point
-                                '_' => {
+                                NUMBER_SEPARATOR => {
                                     stream.unget(next_char);
                                     break;
                                 }
@@ -1416,7 +1424,9 @@ fn get_next_token_inner(
                     negated_pos
                 });
 
-                state.last_token.as_mut().map(|last| *last = result.clone());
+                if let Some(ref mut last) = state.last_token {
+                    *last = result.clone();
+                }
 
                 // Parse number
                 let token = radix_base.map_or_else(
@@ -1471,17 +1481,11 @@ fn get_next_token_inner(
             // letter or underscore ...
             #[cfg(not(feature = "unicode-xid-ident"))]
             ('a'..='z' | '_' | 'A'..='Z', ..) => {
-                return Some(
+                return Some(parse_identifier_token(stream, state, pos, start_pos, c));
-                    parse_identifier_token(stream, state, pos, start_pos, c)
-                        .unwrap_or_else(|err| (Token::LexError(err.into()), start_pos)),
-                );
             }
             #[cfg(feature = "unicode-xid-ident")]
             (ch, ..) if unicode_xid::UnicodeXID::is_xid_start(ch) || ch == '_' => {
-                return Some(
+                return Some(parse_identifier_token(stream, state, pos, start_pos, c));
-                    parse_identifier_token(stream, state, pos, start_pos, c)
-                        .unwrap_or_else(|err| (Token::LexError(err.into()), start_pos)),
-                );
             }
 
             // " - string literal
@@ -1966,40 +1970,42 @@ fn parse_identifier_token(
     pos: &mut Position,
     start_pos: Position,
     first_char: char,
-) -> Result<(Token, Position), LexError> {
+) -> (Token, Position) {
     let mut identifier = SmartString::new_const();
     identifier.push(first_char);
-    state.last_token.as_mut().map(|last| {
+    if let Some(ref mut last) = state.last_token {
         last.clear();
         last.push(first_char);
-    });
+    }
 
     while let Some(next_char) = stream.peek_next() {
         match next_char {
             x if is_id_continue(x) => {
                 eat_next(stream, pos);
                 identifier.push(x);
-                state.last_token.as_mut().map(|last| last.push(x));
+                if let Some(ref mut last) = state.last_token {
+                    last.push(x);
+                }
             }
             _ => break,
         }
     }
 
     if let Some(token) = Token::lookup_symbol_from_syntax(&identifier) {
-        return Ok((token, start_pos));
+        return (token, start_pos);
     }
     if Token::is_reserved_keyword(&identifier) {
-        return Ok((Token::Reserved(Box::new(identifier)), start_pos));
+        return (Token::Reserved(Box::new(identifier)), start_pos);
     }
 
     if !is_valid_identifier(&identifier) {
-        return Ok((
+        return (
             Token::LexError(LERR::MalformedIdentifier(identifier.to_string()).into()),
             start_pos,
-        ));
+        );
     }
 
-    Ok((Token::Identifier(identifier.into()), start_pos))
+    (Token::Identifier(identifier.into()), start_pos)
 }
 
 /// Is a keyword allowed as a function?
@@ -2256,9 +2262,10 @@ impl<'a> Iterator for TokenIterator<'a> {
         };
 
         // Run the mapper, if any
-        let token = match self.token_mapper {
+        let token = if let Some(func) = self.token_mapper {
-            Some(map_func) => map_func(token, pos, &self.state),
+            func(token, pos, &self.state)
-            None => token,
+        } else {
+            token
         };
 
         // Collect the compressed script, if needed
@@ -2285,21 +2292,19 @@ impl<'a> Iterator for TokenIterator<'a> {
                         buf = last_token.clone();
                     }
 
-                    if !buf.is_empty() {
+                    if !buf.is_empty() && !compressed.is_empty() {
-                        if !compressed.is_empty() {
+                        let cur = buf.chars().next().unwrap();
+
+                        if cur == '_' || is_id_first_alphabetic(cur) || is_id_continue(cur) {
                             let prev = compressed.chars().last().unwrap();
-                            let cur = buf.chars().next().unwrap();
+
-                            if (prev == '_' || is_id_first_alphabetic(prev) || is_id_continue(prev))
+                            if prev == '_' || is_id_first_alphabetic(prev) || is_id_continue(prev) {
-                                && (cur == '_'
-                                    || is_id_first_alphabetic(cur)
-                                    || is_id_continue(cur))
-                            {
                                 compressed.push(' ');
                             }
                         }
-
-                        compressed.push_str(&buf);
                     }
+
+                    compressed.push_str(&buf);
                 }
             }
         }

src/types/dynamic.rs

@@ -2055,6 +2055,7 @@ impl Dynamic {
     ///
     /// Shared values are _NOT_ scanned.
     #[inline]
+    #[allow(clippy::only_used_in_recursion)]
     pub fn deep_scan(&mut self, mut filter: impl FnMut(&mut Self)) {
         fn scan_inner(value: &mut Dynamic, filter: &mut impl FnMut(&mut Dynamic)) {
             match &mut value.0 {

src/types/fn_ptr.rs

@@ -37,11 +37,11 @@ impl Hash for FnPtr {
         self.curry.hash(state);
 
         // Hash the shared [`EncapsulatedEnviron`] by hashing its shared pointer.
-        self.environ.as_ref().map(|e| Shared::as_ptr(e)).hash(state);
+        self.environ.as_ref().map(Shared::as_ptr).hash(state);
 
         // Hash the linked [`ScriptFnDef`][crate::ast::ScriptFnDef] by hashing its shared pointer.
         #[cfg(not(feature = "no_function"))]
-        self.fn_def.as_ref().map(|f| Shared::as_ptr(f)).hash(state);
+        self.fn_def.as_ref().map(Shared::as_ptr).hash(state);
     }
 }
 
@@ -124,7 +124,6 @@ impl FnPtr {
     }
     /// Get the curried arguments.
     #[inline(always)]
-    #[must_use]
     pub fn curry(&self) -> &[Dynamic] {
         self.curry.as_ref()
     }
@@ -304,15 +303,14 @@ impl FnPtr {
                 global.level += 1;
 
                 let caches = &mut crate::eval::Caches::new();
-                let mut this_ptr = this_ptr;
 
                 return context.engine().call_script_fn(
                     global,
                     caches,
                     &mut crate::Scope::new(),
-                    this_ptr.as_deref_mut(),
+                    this_ptr,
                     self.encapsulated_environ(),
-                    &fn_def,
+                    fn_def,
                     args,
                     true,
                     context.position(),
@@ -412,23 +410,23 @@ impl FnPtr {
         #[cfg(not(feature = "no_function"))]
         if let Some(arity) = self.fn_def().map(|f| f.params.len()) {
             if arity == N {
-                return self.call_raw(&ctx, None, items);
+                return self.call_raw(ctx, None, items);
             }
             if arity == N + E {
                 let mut items2 = FnArgsVec::with_capacity(items.len() + extras.len());
                 items2.extend(IntoIterator::into_iter(items));
                 items2.extend(IntoIterator::into_iter(extras));
-                return self.call_raw(&ctx, this_ptr, items2);
+                return self.call_raw(ctx, this_ptr, items2);
             }
         }
 
-        self.call_raw(&ctx, this_ptr.as_deref_mut(), items.clone())
+        self.call_raw(ctx, this_ptr.as_deref_mut(), items.clone())
             .or_else(|err| match *err {
                 ERR::ErrorFunctionNotFound(sig, ..) if sig.starts_with(self.fn_name()) => {
                     let mut items2 = FnArgsVec::with_capacity(items.len() + extras.len());
                     items2.extend(IntoIterator::into_iter(items));
                     items2.extend(IntoIterator::into_iter(extras));
-                    self.call_raw(&ctx, this_ptr, items2)
+                    self.call_raw(ctx, this_ptr, items2)
                 }
                 _ => Err(err),
             })

src/types/parse_error.rs

@@ -220,7 +220,7 @@ impl fmt::Display for ParseErrorType {
             Self::ModuleUndefined(s) => write!(f, "Undefined module: {s}"),
 
             Self::MismatchedType(r, a) => write!(f, "Expecting {r}, not {a}"),
-            Self::ExprExpected(s) => write!(f, "Expecting {} expression", s),
+            Self::ExprExpected(s) => write!(f, "Expecting {s} expression"),
             Self::MissingToken(token, s) => write!(f, "Expecting '{token}' {s}"),
 
             Self::MissingSymbol(s) if s.is_empty() => f.write_str("Expecting a symbol"),

src/types/position.rs

@@ -78,9 +78,7 @@ impl Position {
         assert!(!self.is_none(), "cannot advance Position::none");
 
         // Advance up to maximum position
-        if self.pos < u16::MAX {
+        self.pos = self.pos.saturating_add(1);
-            self.pos += 1;
-        }
     }
     /// Go backwards by one character position.
     ///
@@ -136,7 +134,7 @@ impl Position {
     #[inline]
     pub(crate) fn debug_print(self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if !self.is_none() {
-            write!(_f, " @ {:?}", self)?;
+            write!(_f, " @ {self:?}")?;
         }
         Ok(())
     }
@@ -166,12 +164,10 @@ impl fmt::Debug for Position {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if self.is_none() {
             f.write_str("none")
+        } else if self.is_beginning_of_line() {
+            write!(f, "{}", self.line)
         } else {
-            if self.is_beginning_of_line() {
+            write!(f, "{}:{}", self.line, self.pos)
-                write!(f, "{}", self.line)
-            } else {
-                write!(f, "{}:{}", self.line, self.pos)
-            }
         }
     }
 }
@@ -261,10 +257,10 @@ impl fmt::Display for Span {
 
         match (self.start(), self.end()) {
             (Position::NONE, Position::NONE) => write!(_f, "{:?}", Position::NONE),
-            (Position::NONE, end) => write!(_f, "..{:?}", end),
+            (Position::NONE, end) => write!(_f, "..{end:?}"),
-            (start, Position::NONE) => write!(_f, "{:?}", start),
+            (start, Position::NONE) => write!(_f, "{start:?}"),
             (start, end) if start.line() != end.line() => {
-                write!(_f, "{:?}-{:?}", start, end)
+                write!(_f, "{start:?}-{end:?}")
             }
             (start, end) => write!(
                 _f,

src/types/scope.rs

@@ -696,7 +696,6 @@ impl Scope<'_> {
     ///
     /// Panics if the index is out of bounds.
     #[inline]
-    #[must_use]
     pub(crate) fn get_mut_by_index(&mut self, index: usize) -> &mut Dynamic {
         self.values.get_mut(index).unwrap()
     }