fix(linter): no-unused-vars: allow updates in for loop test/update (#14766)

- Fixes #14765

Allows update expressions when they are within a for-loop update/test.

Author: camchenry

crates/oxc_linter/src/rules/eslint/no_unused_vars/tests/oxc.rs

@@ -1287,16 +1287,24 @@ fn test_ts_in_assignment() {
 
 #[test]
 fn test_loops() {
-    let pass: Vec<&str> = vec![];
+    let pass: Vec<&str> = vec![
+        "for (let len = 10; len-- > 0;) {}",
+        "for (let len = 10; len < 0; len++) {}",
+        "for (let len = 10; len;) {}",
+        "for (let len = 10;; len++) {}",
+        "for (let len = 10; len < 0; len += 1) {}",
+        "for (const _unused of []) {}",
+    ];
 
-    let fail: Vec<&str> = vec![];
+    let fail: Vec<&str> = vec!["for (let len = 10;;) {}"];
     let fix = vec![
         ("for (const unused of arr) {}", "for (const _unused of arr) {}"),
         ("for (const unused in arr) {}", "for (const _unused in arr) {}"),
         (
             "for (const foo of arr) { console.log(foo); const unused = 1; }",
             "for (const foo of arr) { console.log(foo);  }",
         ),
+        ("for (let len = 10;;) {}", "for (;;) {}"),
     ];
 
     Tester::new(NoUnusedVars::NAME, NoUnusedVars::PLUGIN, pass, fail).expect_fix(fix).test();

crates/oxc_linter/src/rules/eslint/no_unused_vars/usage.rs

@@ -424,9 +424,12 @@ impl<'a> Symbol<'_, 'a> {
                 // When symbol is being assigned a new value, we flag the reference
                 // as only affecting itself until proven otherwise.
                 AstKind::UpdateExpression(UpdateExpression { argument, .. }) => {
-                    // `a.b++` or `a[b] + 1` are not reassignment of `a`
-                    if !argument.is_member_expression() {
-                        is_used_by_others = false;
+                    // `for (let x = 0; x++; ) {}` is valid usage, as the loop body running is a side-effect
+                    if !self.is_in_for_loop_test_or_update(node.id(), ref_span) {
+                        // `a.b++` or `a[b] + 1` are not reassignment of `a`
+                        if !argument.is_member_expression() {
+                            is_used_by_others = false;
+                        }
                     }
                 }
                 // RHS usage when LHS != reference's symbol is definitely used by
@@ -543,6 +546,27 @@ impl<'a> Symbol<'_, 'a> {
         !is_used_by_others
     }
 
+    /// Check if a [`AstNode`] is within the test or update section of a for loop.
+    fn is_in_for_loop_test_or_update(&self, node_id: NodeId, node_span: Span) -> bool {
+        for parent in self.iter_relevant_parents_of(node_id).map(AstNode::kind) {
+            match parent {
+                AstKind::ForStatement(for_stmt) => {
+                    return for_stmt
+                        .test
+                        .as_ref()
+                        .is_some_and(|test| test.span().contains_inclusive(node_span))
+                        || for_stmt
+                            .update
+                            .as_ref()
+                            .is_some_and(|update| update.span().contains_inclusive(node_span));
+                }
+                x if x.is_statement() => return false,
+                _ => {}
+            }
+        }
+        false
+    }
+
     /// Check if a [`AstNode`] is within a return statement or implicit return.
     fn is_in_return_statement(&self, node_id: NodeId) -> bool {
         for parent in self.iter_relevant_parents_of(node_id).map(AstNode::kind) {