From 80ccd7551436827718c033474521dc811b70790f Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Thu, 22 Dec 2022 17:34:58 +0800 Subject: [PATCH] Satisfy clippy. --- codegen/src/lib.rs | 5 +- codegen/src/module.rs | 2 + codegen/src/rhai_module.rs | 2 +- codegen/src/test/module.rs | 48 ++++++++++++++++++- src/api/call_fn.rs | 2 +- src/api/files.rs | 2 +- src/api/json.rs | 4 +- src/api/mod.rs | 2 - src/ast/expr.rs | 2 +- src/ast/stmt.rs | 12 ++--- src/eval/chaining.rs | 5 +- src/eval/debugger.rs | 2 - src/eval/eval_context.rs | 2 - src/eval/global_state.rs | 2 + src/eval/target.rs | 4 -- src/func/builtin.rs | 2 + src/func/call.rs | 12 ++--- src/func/native.rs | 2 +- src/func/register.rs | 1 - src/func/script.rs | 1 - src/lib.rs | 9 +++- src/module/mod.rs | 10 ++-- src/optimizer.rs | 11 +++-- src/packages/arithmetic.rs | 2 + src/packages/array_basic.rs | 32 +++++++++---- src/packages/bit_field.rs | 4 ++ src/packages/blob_basic.rs | 20 ++++++-- src/packages/iter_basic.rs | 4 ++ src/packages/lang_core.rs | 3 +- src/packages/math_basic.rs | 51 ++++++++++---------- src/packages/string_more.rs | 95 +++++++++++++++++++++++++++++-------- src/packages/time_basic.rs | 14 ++++-- src/parser.rs | 35 +++++++------- src/serde/serialize.rs | 1 + src/tokenizer.rs | 95 +++++++++++++++++++------------------ src/types/dynamic.rs | 1 + src/types/fn_ptr.rs | 18 ++++--- src/types/parse_error.rs | 2 +- src/types/position.rs | 20 ++++---- src/types/scope.rs | 1 - 40 files changed, 346 insertions(+), 196 deletions(-) diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs index 22291c4f..aa4af270 100644 --- a/codegen/src/lib.rs +++ b/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, diff --git a/codegen/src/module.rs b/codegen/src/module.rs index ea577f5f..32ac8f3b 100644 --- a/codegen/src/module.rs +++ b/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)* } diff --git a/codegen/src/rhai_module.rs b/codegen/src/rhai_module.rs index 42b18d2b..e0060c50 100644 --- a/codegen/src/rhai_module.rs +++ b/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, diff --git a/codegen/src/test/module.rs b/codegen/src/test/module.rs index f333e23b..0f0bc9dd 100644 --- a/codegen/src/test/module.rs +++ b/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)] diff --git a/src/api/call_fn.rs b/src/api/call_fn.rs index 28f0a405..07ea0c99 100644 --- a/src/api/call_fn.rs +++ b/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"))] diff --git a/src/api/files.rs b/src/api/files.rs index b2a2ffd1..2025b412 100644 --- a/src/api/files.rs +++ b/src/api/files.rs @@ -107,7 +107,7 @@ impl Engine { #[inline] pub fn compile_file_with_scope(&self, scope: &Scope, path: PathBuf) -> RhaiResultOf { 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) }) diff --git a/src/api/json.rs b/src/api/json.rs index dd6d1f42..b62c1fb9 100644 --- a/src/api/json.rs +++ b/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::() { @@ -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(); } } diff --git a/src/api/mod.rs b/src/api/mod.rs index e59d7757..e9cc9c8a 100644 --- a/src/api/mod.rs +++ b/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 } diff --git a/src/ast/expr.rs b/src/ast/expr.rs index a8376bd6..36299d83 100644 --- a/src/ast/expr.rs +++ b/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) }; } diff --git a/src/ast/stmt.rs b/src/ast/stmt.rs index d3f11a46..8d13c1dd 100644 --- a/src/ast/stmt.rs +++ b/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 { - let op_raw = op + pub fn new_op_assignment_from_token(op_assign: Token, pos: Position) -> Self { + 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: calc_fn_hash(None, op_raw.literal_syntax(), 2), - op_assign: op.clone(), - op: op_raw, + hash_op_assign: calc_fn_hash(None, op_assign.literal_syntax(), 2), + hash_op: calc_fn_hash(None, op.literal_syntax(), 2), + op_assign, + op, pos, } } diff --git a/src/eval/chaining.rs b/src/eval/chaining.rs index c69ba77b..96095960 100644 --- a/src/eval/chaining.rs +++ b/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 as u8, + bit, }) } diff --git a/src/eval/debugger.rs b/src/eval/debugger.rs index e852e46e..1bc1a5a5 100644 --- a/src/eval/debugger.rs +++ b/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 } diff --git a/src/eval/eval_context.rs b/src/eval/eval_context.rs index 66c4539f..9f4350bc 100644 --- a/src/eval/eval_context.rs +++ b/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 } diff --git a/src/eval/global_state.rs b/src/eval/global_state.rs index 4cd202f5..69e08c5e 100644 --- a/src/eval/global_state.rs +++ b/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() } diff --git a/src/eval/target.rs b/src/eval/target.rs index e1980d1b..6679d614 100644 --- a/src/eval/target.rs +++ b/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 for Target<'_> { #[inline(always)] - #[must_use] fn as_ref(&self) -> &Dynamic { self } @@ -407,7 +405,6 @@ impl AsRef for Target<'_> { impl Borrow for Target<'_> { #[inline(always)] - #[must_use] fn borrow(&self) -> &Dynamic { self } @@ -432,7 +429,6 @@ impl DerefMut for Target<'_> { impl AsMut for Target<'_> { #[inline(always)] - #[must_use] fn as_mut(&mut self) -> &mut Dynamic { self } diff --git a/src/func/builtin.rs b/src/func/builtin.rs index ad15da11..d27a39e7 100644 --- a/src/func/builtin.rs +++ b/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, _: &mut [&mut Dynamic]) -> RhaiResult { Ok(Dynamic::TRUE) } /// A function that returns `false`. #[inline(always)] +#[allow(clippy::unnecessary_wraps)] fn const_false_fn(_: Option, _: &mut [&mut Dynamic]) -> RhaiResult { Ok(Dynamic::FALSE) } diff --git a/src/func/call.rs b/src/func/call.rs index 3724e2d6..42452d47 100644 --- a/src/func/call.rs +++ b/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::(typ, arg_pos))?; - return Ok(if !(0..=crate::MAX_USIZE_INT).contains(&num_params) { - false - } else { - #[allow(clippy::cast_sign_loss)] + return Ok(if (0..=crate::MAX_USIZE_INT).contains(&num_params) { + #[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)] 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, diff --git a/src/func/native.rs b/src/func/native.rs index ed4c5117..7f0aba59 100644 --- a/src/func/native.rs +++ b/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, } diff --git a/src/func/register.rs b/src/func/register.rs index ee309f47..de5d835c 100644 --- a/src/func/register.rs +++ b/src/func/register.rs @@ -39,7 +39,6 @@ pub struct Mut(T); /// Dereference into [`DynamicWriteLock`] #[inline(always)] -#[must_use] pub fn by_ref(data: &mut Dynamic) -> DynamicWriteLock { // Directly cast the &mut Dynamic into DynamicWriteLock to access the underlying data. data.write_lock::().expect("checked") diff --git a/src/func/script.rs b/src/func/script.rs index 06be7d54..b864b4e8 100644 --- a/src/func/script.rs +++ b/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(), diff --git a/src/lib.rs b/src/lib.rs index e7112050..f8ac7dbd 100644 --- a/src/lib.rs +++ b/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; diff --git a/src/module/mod.rs b/src/module/mod.rs index 082c4493..f0f3716a 100644 --- a/src/module/mod.rs +++ b/src/module/mod.rs @@ -1962,7 +1962,7 @@ impl Module { #[inline] #[allow(dead_code)] pub(crate) fn iter_fn(&self) -> impl Iterator { - 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 { - CallableFunction::Script { environ: e, .. } => *e = Some(environ.clone()), - _ => (), + if let CallableFunction::Script { + environ: ref mut e, .. + } = f.func + { + *e = Some(environ.clone()) } }); diff --git a/src/optimizer.rs b/src/optimizer.rs index 6bf6f280..9c421857 100644 --- a/src/optimizer.rs +++ b/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); } } diff --git a/src/packages/arithmetic.rs b/src/packages/arithmetic.rs index 771982b7..5d8b14e2 100644 --- a/src/packages/arithmetic.rs +++ b/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)) } } diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs index 501f2306..a5780fca 100644 --- a/src/packages/array_basic.rs +++ b/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() { - array.drain(0..array.len() - len as usize); + } else if len < array.len() { + 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. diff --git a/src/packages/bit_field.rs b/src/packages/bit_field.rs index 9da781cf..50d705a6 100644 --- a/src/packages/bit_field.rs +++ b/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); diff --git a/src/packages/blob_basic.rs b/src/packages/blob_basic.rs index 515cef06..430b89c0 100644 --- a/src/packages/blob_basic.rs +++ b/src/packages/blob_basic.rs @@ -75,7 +75,8 @@ pub mod blob_functions { len: INT, value: INT, ) -> RhaiResultOf { - 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 { diff --git a/src/packages/iter_basic.rs b/src/packages/iter_basic.rs index 9e4588c6..50dc7b63 100644 --- a/src/packages/iter_basic.rs +++ b/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(x: T, y: T) -> Option where T: num_traits::CheckedAdd, @@ -30,6 +31,7 @@ where } #[inline(always)] #[allow(dead_code)] +#[allow(clippy::unnecessary_wraps, clippy::needless_pass_by_value)] fn regular_add(x: T, y: T) -> Option where T: std::ops::Add, @@ -123,6 +125,7 @@ impl FusedIterator for StepRange {} 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 { 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, 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); diff --git a/src/packages/lang_core.rs b/src/packages/lang_core.rs index a19b0f72..6b55f2e1 100644 --- a/src/packages/lang_core.rs +++ b/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(¶ms) { Array::new() } else { collect_fn_metadata(ctx, |_, _, n, p, _| p == (params as usize) && n == name) diff --git a/src/packages/math_basic.rs b/src/packages/math_basic.rs index 4c54f570..25294e47 100644 --- a/src/packages/math_basic.rs +++ b/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 { - let n = x.to_i64().and_then(|n| { - #[cfg(feature = "only_i32")] - return if n > (INT::MAX as i64) || n < (INT::MIN as i64) { - None - } else { - Some(n as i32) - }; + x.to_i64() + .and_then(|n| { + #[cfg(feature = "only_i32")] + return if n > (INT::MAX as i64) || n < (INT::MIN as i64) { + None + } else { + Some(n as i32) + }; - #[cfg(not(feature = "only_i32"))] - return Some(n); - }); - - n.map_or_else( - || { - Err( - ERR::ErrorArithmetic(format!("Integer overflow: to_int({x})"), Position::NONE) - .into(), - ) - }, - Ok, - ) + #[cfg(not(feature = "only_i32"))] + return Some(n); + }) + .map_or_else( + || { + Err(ERR::ErrorArithmetic( + format!("Integer overflow: to_int({x})"), + Position::NONE, + ) + .into()) + }, + Ok, + ) } /// Return the integral part of the decimal number. #[rhai_fn(name = "int", get = "int")] diff --git a/src/packages/string_more.rs b/src/packages/string_more.rs index 70e95363..3819295d 100644 --- a/src/packages/string_more.rs +++ b/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::::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::>(); 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) { - crop(string, start, string.len() as INT); + pub fn crop_string_starting_from( + 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() diff --git a/src/packages/time_basic.rs b/src/packages/time_basic.rs index 2ea495c2..828c8d8a 100644 --- a/src/packages/time_basic.rs +++ b/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 { 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 { 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 { + #[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 { + #[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 { diff --git a/src/parser.rs b/src/parser.rs index 469c1ff5..046ce895 100644 --- a/src/parser.rs +++ b/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| { - if x.get() <= u8::MAX as usize { - NonZeroU8::new(x.get() as u8) - } else { - None - } - }); + let short_index = index + .and_then(|x| u8::try_from(x.get()).ok()) + .and_then(NonZeroU8::new); 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 { - OpAssignment::new_op_assignment_from_token(op, op_pos) - } else { + let op_info = if op == NO_TOKEN { 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 { diff --git a/src/serde/serialize.rs b/src/serde/serialize.rs index 34595826..580bb344 100644 --- a/src/serde/serialize.rs +++ b/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 } diff --git a/src/tokenizer.rs b/src/tokenizer.rs index dd9a5b6f..e180aedf 100644 --- a/src/tokenizer.rs +++ b/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, } @@ -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, - /// Last token + /// Textual syntax of the current token, if any. + /// + /// Set to `Some` to begin tracking this information. pub last_token: Option, } @@ -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 - .last_token - .as_mut() - .map(|last| last.push(termination_char)); + if let Some(ref mut last) = state.last_token { + 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( - parse_identifier_token(stream, state, pos, start_pos, c) - .unwrap_or_else(|err| (Token::LexError(err.into()), start_pos)), - ); + return Some(parse_identifier_token(stream, state, pos, start_pos, c)); } #[cfg(feature = "unicode-xid-ident")] (ch, ..) if unicode_xid::UnicodeXID::is_xid_start(ch) || ch == '_' => { - return Some( - parse_identifier_token(stream, state, pos, start_pos, c) - .unwrap_or_else(|err| (Token::LexError(err.into()), start_pos)), - ); + return Some(parse_identifier_token(stream, state, pos, start_pos, c)); } // " - 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 { - Some(map_func) => map_func(token, pos, &self.state), - None => token, + let token = if let Some(func) = self.token_mapper { + func(token, pos, &self.state) + } 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 !compressed.is_empty() { + if !buf.is_empty() && !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)) - && (cur == '_' - || is_id_first_alphabetic(cur) - || is_id_continue(cur)) - { + + if prev == '_' || is_id_first_alphabetic(prev) || is_id_continue(prev) { compressed.push(' '); } } - - compressed.push_str(&buf); } + + compressed.push_str(&buf); } } } diff --git a/src/types/dynamic.rs b/src/types/dynamic.rs index 57cd0440..49cafcf5 100644 --- a/src/types/dynamic.rs +++ b/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 { diff --git a/src/types/fn_ptr.rs b/src/types/fn_ptr.rs index c307c912..35098945 100644 --- a/src/types/fn_ptr.rs +++ b/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), }) diff --git a/src/types/parse_error.rs b/src/types/parse_error.rs index 6e29e96f..19156ef8 100644 --- a/src/types/parse_error.rs +++ b/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"), diff --git a/src/types/position.rs b/src/types/position.rs index 2deee226..8bdaaab4 100644 --- a/src/types/position.rs +++ b/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 += 1; - } + self.pos = self.pos.saturating_add(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) - } else { - write!(f, "{}:{}", self.line, self.pos) - } + 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), - (start, Position::NONE) => write!(_f, "{:?}", start), + (Position::NONE, end) => write!(_f, "..{end:?}"), + (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, diff --git a/src/types/scope.rs b/src/types/scope.rs index c6320861..712298fe 100644 --- a/src/types/scope.rs +++ b/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() }