fix new clippy warnings

y21 · y21 · commit bc875d6f041a · 2025-06-29T14:00:51.000+02:00
diff --git a/clippy.toml b/clippy.toml
@@ -1,3 +0,0 @@
-[[disallowed-methods]]
-path = "dash_vm::Vm::register"
-reason = "use LocalScope::register instead"
diff --git a/crates/dash_compiler/src/lib.rs b/crates/dash_compiler/src/lib.rs
@@ -644,12 +644,11 @@ impl Visitor<Result<(), Error>> for FunctionCompiler<'_> {
         // Typeof operator evaluates its operand differently if it's an identifier and there is no such local variable, so special case it here
         // `typeof x` does not throw an error if the variable does not exist,
         // `typeof x.a` does throw an error
-        if let TokenType::Typeof = operator {
-            if let ExprKind::Literal(LiteralExpr::Identifier(ident)) = expr.kind {
-                if ib.find_local(ident).is_none() {
-                    return ib.build_typeof_global_ident(span, ident);
-                }
-            }
+        if let TokenType::Typeof = operator
+            && let ExprKind::Literal(LiteralExpr::Identifier(ident)) = expr.kind
+            && ib.find_local(ident).is_none()
+        {
+            return ib.build_typeof_global_ident(span, ident);
         }
 
         // Delete operator works different from other unary operators
@@ -1586,12 +1585,12 @@ impl Visitor<Result<(), Error>> for FunctionCompiler<'_> {
 
             // Insert initializers
             // FIXME: they need to be inserted after every super() call not at the start of the constructor.
-            if let Some(members) = constructor_initializers {
-                if !members.is_empty() {
-                    let members = compile_class_members(ib, span, members)?;
-                    ib.build_this();
-                    ib.build_object_member_like_instruction(span, members, Instruction::AssignProperties)?;
-                }
+            if let Some(members) = constructor_initializers
+                && !members.is_empty()
+            {
+                let members = compile_class_members(ib, span, members)?;
+                ib.build_this();
+                ib.build_object_member_like_instruction(span, members, Instruction::AssignProperties)?;
             }
 
             let res = statements.into_iter().try_for_each(|stmt| ib.accept(stmt));
@@ -2468,7 +2467,6 @@ fn compile_destructuring_pattern(
                 .try_into()
                 .map_err(|_| Error::DestructureLimitExceeded(at))?;
 
-            #[expect(clippy::manual_flatten, reason = "pattern contains an inner Some()")]
             for field in fields.iter().rev() {
                 if let Some((_, Some(default))) = field {
                     ib.accept_expr(default.clone())?;
diff --git a/crates/dash_lexer/src/lib.rs b/crates/dash_lexer/src/lib.rs
@@ -358,14 +358,14 @@ impl<'a, 'interner> Lexer<'a, 'interner> {
                 continue;
             }
 
-            if cur == b'$' {
-                if let Some(b'{') = self.peek() {
-                    // String interpolation
-                    found_end = true;
-                    is_interpolated = true;
-                    self.template_literal_depths_stack.push(0);
-                    break;
-                }
+            if cur == b'$'
+                && let Some(b'{') = self.peek()
+            {
+                // String interpolation
+                found_end = true;
+                is_interpolated = true;
+                self.template_literal_depths_stack.push(0);
+                break;
             }
 
             if cur == b'\n' {
diff --git a/crates/dash_middle/src/lexer/token.rs b/crates/dash_middle/src/lexer/token.rs
@@ -486,7 +486,7 @@ impl TokenType {
                     TokenType::DUMMY_IDENTIFIER => write!(f, "<identifier>"),
                     TokenType::DUMMY_TEMPLATE_LITERAL => write!(f, "<template literal>"),
                     TokenType::DUMMY_STRING => write!(f, "<string>"),
-                    other => write!(f, "{}", other),
+                    other => write!(f, "{other}"),
                 }
             }
         }
diff --git a/crates/dash_node_impl/src/lib.rs b/crates/dash_node_impl/src/lib.rs
@@ -43,7 +43,7 @@ pub fn run_with_nodejs_mnemnoics(path: &str, opt: OptLevel, initial_gc_threshold
 
     tokio_rt.block_on(async move {
         if let Err(err) = run_inner_fallible(path, opt, initial_gc_threshold).await {
-            eprintln!("{}", err);
+            eprintln!("{err}");
         }
     });
 
diff --git a/crates/dash_optimizer/src/consteval.rs b/crates/dash_optimizer/src/consteval.rs
@@ -538,10 +538,10 @@ fn expr_has_side_effects(expr: &Expr) -> bool {
         ExprKind::Literal(LiteralExpr::Regex(..)) => false,
         ExprKind::Literal(LiteralExpr::String(..)) => false,
         ExprKind::Object(ObjectLiteral(object)) => object.iter().any(|(kind, expr)| {
-            if let ObjectMemberKind::Dynamic(dynamic) = kind {
-                if expr_has_side_effects(dynamic) {
-                    return true;
-                }
+            if let ObjectMemberKind::Dynamic(dynamic) = kind
+                && expr_has_side_effects(dynamic)
+            {
+                return true;
             };
             expr_has_side_effects(expr)
         }),
diff --git a/crates/dash_optimizer/src/type_infer.rs b/crates/dash_optimizer/src/type_infer.rs
@@ -528,37 +528,37 @@ impl<'s> TypeInferCtx<'s> {
         let right_type = self.visit(right);
 
         // Also propagate assignment to target
-        if let ExprKind::Literal(LiteralExpr::Identifier(ident)) = &left.kind {
-            if let Some(local) = self.find_local(*ident) {
-                let left_type = local.inferred_type();
-                let left_type_ref = left_type.borrow();
-
-                if left_type_ref.as_ref() == right_type.as_ref() {
-                    // Assign value is the same, no change.
-                } else {
-                    debug!(
-                        "variable {} changed type {:?} -> {:?}",
-                        ident, left_type_ref, right_type
-                    );
-
-                    match (left_type_ref.as_ref(), right_type.as_ref()) {
-                        (Some(left), Some(right)) => {
-                            let left = left.clone();
-                            let right = right.clone();
-                            drop(left_type_ref);
-                            update_ty(
-                                left_type,
-                                Some(CompileValueType::Either(Box::new(left), Box::new(right))),
-                            );
-                        }
-                        (_, Some(right)) => {
-                            drop(left_type_ref);
-                            update_ty(left_type, Some(CompileValueType::Maybe(Box::new(right.clone()))));
-                        }
-                        (_, _) => {
-                            drop(left_type_ref);
-                            update_ty(left_type, None);
-                        }
+        if let ExprKind::Literal(LiteralExpr::Identifier(ident)) = &left.kind
+            && let Some(local) = self.find_local(*ident)
+        {
+            let left_type = local.inferred_type();
+            let left_type_ref = left_type.borrow();
+
+            if left_type_ref.as_ref() == right_type.as_ref() {
+                // Assign value is the same, no change.
+            } else {
+                debug!(
+                    "variable {} changed type {:?} -> {:?}",
+                    ident, left_type_ref, right_type
+                );
+
+                match (left_type_ref.as_ref(), right_type.as_ref()) {
+                    (Some(left), Some(right)) => {
+                        let left = left.clone();
+                        let right = right.clone();
+                        drop(left_type_ref);
+                        update_ty(
+                            left_type,
+                            Some(CompileValueType::Either(Box::new(left), Box::new(right))),
+                        );
+                    }
+                    (_, Some(right)) => {
+                        drop(left_type_ref);
+                        update_ty(left_type, Some(CompileValueType::Maybe(Box::new(right.clone()))));
+                    }
+                    (_, _) => {
+                        drop(left_type_ref);
+                        update_ty(left_type, None);
                     }
                 }
             }
diff --git a/crates/dash_parser/src/stmt.rs b/crates/dash_parser/src/stmt.rs
@@ -45,12 +45,12 @@ impl Parser<'_, '_> {
             TokenType::Debugger => Some(StatementKind::Debugger),
             TokenType::Semicolon => Some(StatementKind::Empty),
             other => 'other: {
-                if let TokenType::Identifier(label) = other {
-                    if self.eat(TokenType::Colon, false).is_some() {
-                        // `foo: <statement that can be broken out of>`
-                        let stmt = self.parse_statement()?;
-                        break 'other Some(StatementKind::Labelled(label, Box::new(stmt)));
-                    }
+                if let TokenType::Identifier(label) = other
+                    && self.eat(TokenType::Colon, false).is_some()
+                {
+                    // `foo: <statement that can be broken out of>`
+                    let stmt = self.parse_statement()?;
+                    break 'other Some(StatementKind::Labelled(label, Box::new(stmt)));
                 }
 
                 // We've skipped the current character because of the statement cases that skip the current token
diff --git a/crates/dash_proc_macro/src/define_symbols.rs b/crates/dash_proc_macro/src/define_symbols.rs
@@ -22,7 +22,7 @@ pub fn define_symbols_impl(tt: TokenStream) -> TokenStream {
             let kind = match strukt.path.segments.last().unwrap().ident.to_string().as_ref() {
                 "Keywords" => Kind::Keyword,
                 "Symbols" => Kind::Symbol,
-                other => panic!("unknown struct: {}", other),
+                other => panic!("unknown struct: {other}"),
             };
 
             for field in strukt.fields {
@@ -50,10 +50,10 @@ pub fn define_symbols_impl(tt: TokenStream) -> TokenStream {
     let mut js_idents = HashSet::new();
     for (_, rust_sym, js_sym) in &symbols {
         if !rust_idents.insert(rust_sym) {
-            panic!("duplicate rust ident: {}", rust_sym);
+            panic!("duplicate rust ident: {rust_sym}");
         }
         if !js_idents.insert(js_sym) {
-            panic!("duplicate js ident: {}", js_sym);
+            panic!("duplicate js ident: {js_sym}");
         }
     }
 
diff --git a/crates/dash_regex/src/graph/eval.rs b/crates/dash_regex/src/graph/eval.rs
@@ -92,11 +92,11 @@ fn step(shared: &mut Shared<'_>, cx: Cx<'_>, node_id: NodeId, mut remaining: &[u
         NodeKind::RepetitionStart { min, max, inner } => 'arm: {
             let current_repetition_count = cx.current_repetition_count.get().unwrap();
 
-            if let Some(max) = max {
-                if current_repetition_count >= max {
-                    // We've done `max` number of iterations.
-                    break 'arm true;
-                }
+            if let Some(max) = max
+                && current_repetition_count >= max
+            {
+                // We've done `max` number of iterations.
+                break 'arm true;
             }
 
             if step(shared, cx.for_node(shared, inner, node_id, remaining), inner, remaining) {
diff --git a/crates/dash_vm/src/json/parser.rs b/crates/dash_vm/src/json/parser.rs
@@ -34,8 +34,8 @@ impl JsonParseError {
             Self::UnexpectedToken(token, position) => {
                 Cow::Owned(format!("Unexpected token {} at position {}", *token as char, *position))
             }
-            Self::Utf8Error(_, pos) => Cow::Owned(format!("Utf8 Error at position {}", pos)),
-            Self::ParseFloatError(_, pos) => Cow::Owned(format!("Failed to parse number at position {}", pos)),
+            Self::Utf8Error(_, pos) => Cow::Owned(format!("Utf8 Error at position {pos}")),
+            Self::ParseFloatError(_, pos) => Cow::Owned(format!("Failed to parse number at position {pos}")),
         }
     }
 }
diff --git a/crates/dash_vm/src/lib.rs b/crates/dash_vm/src/lib.rs
@@ -1428,7 +1428,7 @@ impl Vm {
         for (i, v) in self.stack.iter().enumerate() {
             print!("{i}: ");
             match v.unpack() {
-                ValueKind::Object(o) => println!("{:#?}", o),
+                ValueKind::Object(o) => println!("{o:#?}"),
                 ValueKind::External(o) => println!("[[external]]: {:#?}", o.inner(self)),
                 v => println!("{v:?}"),
             }
@@ -1471,10 +1471,10 @@ impl Vm {
 
         for promise_id in rejected_promises.iter() {
             let promise = promise_id.extract::<Promise>(&scope).unwrap();
-            if let PromiseState::Rejected { value, caught: false } = *promise.state().borrow() {
-                if let Some(callback) = scope.params.unhandled_task_exception_callback {
-                    callback(&mut scope, value, UncaughtExceptionSource::Promise);
-                }
+            if let PromiseState::Rejected { value, caught: false } = *promise.state().borrow()
+                && let Some(callback) = scope.params.unhandled_task_exception_callback
+            {
+                callback(&mut scope, value, UncaughtExceptionSource::Promise);
             }
         }
 
diff --git a/crates/dash_vm/src/value/array/mod.rs b/crates/dash_vm/src/value/array/mod.rs
@@ -73,10 +73,10 @@ impl ArrayInner {
     }
 
     fn transition_to_dense_if_no_holes(&mut self) {
-        if let ArrayInner::Table(table) = self {
-            if !table.has_holes() {
-                *self = Self::Dense(table.take_into_sorted_array());
-            }
+        if let ArrayInner::Table(table) = self
+            && !table.has_holes()
+        {
+            *self = Self::Dense(table.take_into_sorted_array());
         }
     }
 
@@ -216,12 +216,12 @@ impl Object for Array {
         let items = self.items.borrow();
 
         if let Some(index) = key.index() {
-            if index < MAX_LENGTH {
-                if let Some(element) = items.get(index) {
-                    match element {
-                        MaybeHoley::Some(v) => return Ok(Some(v)),
-                        MaybeHoley::Hole => return Ok(None),
-                    }
+            if index < MAX_LENGTH
+                && let Some(element) = items.get(index)
+            {
+                match element {
+                    MaybeHoley::Some(v) => return Ok(Some(v)),
+                    MaybeHoley::Hole => return Ok(None),
                 }
             }
         } else if let Some(sym::length) = key.to_js_string(sc) {
@@ -376,16 +376,15 @@ impl ArrayIterator {
 
 /// Equivalent to calling get_property, but specialized for arrays
 pub fn spec_array_get_property(scope: &mut LocalScope<'_>, target: &Value, index: usize) -> Result<Unrooted, Unrooted> {
-    if let Ok(index) = u32::try_from(index) {
-        if index < MAX_LENGTH {
-            if let Some(arr) = target.unpack().downcast_ref::<Array>(scope) {
-                let inner = arr.items.borrow();
-                return match inner.get(index) {
-                    Some(MaybeHoley::Some(value)) => value.get_or_apply(scope, This::default()),
-                    Some(MaybeHoley::Hole) | None => Ok(Value::undefined().into()),
-                };
-            }
-        }
+    if let Ok(index) = u32::try_from(index)
+        && index < MAX_LENGTH
+        && let Some(arr) = target.unpack().downcast_ref::<Array>(scope)
+    {
+        let inner = arr.items.borrow();
+        return match inner.get(index) {
+            Some(MaybeHoley::Some(value)) => value.get_or_apply(scope, This::default()),
+            Some(MaybeHoley::Hole) | None => Ok(Value::undefined().into()),
+        };
     }
 
     match target.get_property(index.to_key(scope), scope) {
@@ -405,11 +404,11 @@ pub fn spec_array_set_property(
     if let Some(arr) = target.unpack().downcast_ref::<Array>(scope) {
         let mut inner = arr.items.borrow_mut();
 
-        if let Ok(index) = u32::try_from(index) {
-            if index < MAX_LENGTH {
-                inner.set(index, value);
-                return Ok(());
-            }
+        if let Ok(index) = u32::try_from(index)
+            && index < MAX_LENGTH
+        {
+            inner.set(index, value);
+            return Ok(());
         }
     }
 
diff --git a/crates/dash_vm/src/value/function/mod.rs b/crates/dash_vm/src/value/function/mod.rs
@@ -255,17 +255,17 @@ impl Object for Function {
         scope: &mut LocalScope,
     ) -> Result<Unrooted, Unrooted> {
         let this = 'this: {
-            if let Some(user) = self.inner_user_function() {
-                if user.inner().has_extends_clause {
-                    // We don't immediately create an instance when instantiating a subclass.
-                    // The super() call desugaring will initialize `this`
+            if let Some(user) = self.inner_user_function()
+                && user.inner().has_extends_clause
+            {
+                // We don't immediately create an instance when instantiating a subclass.
+                // The super() call desugaring will initialize `this`
 
-                    let ValueKind::Object(super_constructor) = self.get_prototype(scope)?.unpack() else {
-                        throw!(scope, TypeError, "supertype constructor must be an object")
-                    };
+                let ValueKind::Object(super_constructor) = self.get_prototype(scope)?.unpack() else {
+                    throw!(scope, TypeError, "supertype constructor must be an object")
+                };
 
-                    break 'this This::before_super(super_constructor);
-                }
+                break 'this This::before_super(super_constructor);
             }
 
             this_for_new_target(scope, new_target)?
diff --git a/crates/dash_vm/src/value/object/mod.rs b/crates/dash_vm/src/value/object/mod.rs
@@ -619,10 +619,10 @@ impl ObjectId {
 
             if let Some(mut desc) = self.get_own_property_descriptor(key, sc).root_err(sc)? {
                 desc.descriptor.remove(PropertyDataDescriptor::CONFIGURABLE);
-                if let IntegrityLevel::Frozen = level {
-                    if let PropertyValueKind::Static(_) = desc.kind {
-                        desc.descriptor.remove(PropertyDataDescriptor::WRITABLE);
-                    }
+                if let IntegrityLevel::Frozen = level
+                    && let PropertyValueKind::Static(_) = desc.kind
+                {
+                    desc.descriptor.remove(PropertyDataDescriptor::WRITABLE);
                 }
                 self.set_property(key, desc, sc)?;
             }

Original file line number	Diff line number	Diff line change
`@@ -1,3 +0,0 @@`
`1`		`-[[disallowed-methods]]`
`2`		`-path = "dash_vm::Vm::register"`
`3`		`-reason = "use LocalScope::register instead"`
Original file line number	Diff line number	Diff line change
`@@ -486,7 +486,7 @@ impl TokenType {`
`486`	`486`	`TokenType::DUMMY_IDENTIFIER => write!(f, "<identifier>"),`
`487`	`487`	`TokenType::DUMMY_TEMPLATE_LITERAL => write!(f, "<template literal>"),`
`488`	`488`	`TokenType::DUMMY_STRING => write!(f, "<string>"),`
`489`		`- other => write!(f, "{}", other),`
	`489`	`+ other => write!(f, "{other}"),`
`490`	`490`	`}`
`491`	`491`	`}`
`492`	`492`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ pub fn run_with_nodejs_mnemnoics(path: &str, opt: OptLevel, initial_gc_threshold`
`43`	`43`
`44`	`44`	`tokio_rt.block_on(async move {`
`45`	`45`	`if let Err(err) = run_inner_fallible(path, opt, initial_gc_threshold).await {`
`46`		`- eprintln!("{}", err);`
	`46`	`+ eprintln!("{err}");`
`47`	`47`	`}`
`48`	`48`	`});`
`49`	`49`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ pub fn define_symbols_impl(tt: TokenStream) -> TokenStream {`
`22`	`22`	`let kind = match strukt.path.segments.last().unwrap().ident.to_string().as_ref() {`
`23`	`23`	`"Keywords" => Kind::Keyword,`
`24`	`24`	`"Symbols" => Kind::Symbol,`
`25`		`- other => panic!("unknown struct: {}", other),`
	`25`	`+ other => panic!("unknown struct: {other}"),`
`26`	`26`	`};`
`27`	`27`
`28`	`28`	`for field in strukt.fields {`
`@@ -50,10 +50,10 @@ pub fn define_symbols_impl(tt: TokenStream) -> TokenStream {`
`50`	`50`	`let mut js_idents = HashSet::new();`
`51`	`51`	`for (_, rust_sym, js_sym) in &symbols {`
`52`	`52`	`if !rust_idents.insert(rust_sym) {`
`53`		`- panic!("duplicate rust ident: {}", rust_sym);`
	`53`	`+ panic!("duplicate rust ident: {rust_sym}");`
`54`	`54`	`}`
`55`	`55`	`if !js_idents.insert(js_sym) {`
`56`		`- panic!("duplicate js ident: {}", js_sym);`
	`56`	`+ panic!("duplicate js ident: {js_sym}");`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`