JS-1121 Fix FP on S2310: Allow intentional loop counter skip-ahead patterns

[ss-vibe-bot]

Summary

Fixes false positives in S2310 where intentional loop counter modifications in parsing code were incorrectly flagged. The rule now distinguishes between legitimate skip-ahead patterns and assignments that should use break.

Changes

• Allow loop counter modifications via UpdateExpression (i++, i--, ++i, --i) and compound assignment operators (i += n, i -= n) which are common skip-ahead patterns in parsing code
• Continue flagging simple assignments (i = value) which typically indicate early-exit patterns that should use break
• Add special case handling to still report modifications in nested for-loop update clauses

Test Coverage

Added test cases covering:

• Pre/post increment/decrement patterns for various use cases (tuple consumption, escape character skipping, surrogate pair processing)
• Compound assignment for batch skip-ahead processing
• Reverse iteration patterns with decrement
• Array manipulation with splice and index modification
• 6 additional test cases from ruling analysis covering real-world patterns

All 68 ruling entries analyzed with no mismatches between expected and actual behavior.

Fixes JS-1121

[github-actions]

Ruling Report

Code no longer flagged (53 issues)

S2310

Joust/ts/components/EventLog.tsx:72

    70 | 						entityId: entity.entityId, targetId: target.entityId
    71 | 					});
>   72 | 					i++;
    73 | 				}
    74 | 				else if (curr.entityId == next.entityId && (curr.type == LineType.AttackBuff && next.type == LineType.HealthBuff

Joust/ts/components/EventLog.tsx:82

    80 | 						data2: curr.type == LineType.AttackBuff ? next.data : curr.data
    81 | 					});
>   82 | 					i++;
    83 | 				}
    84 | 				else {

TypeScript/lib/tsc.js:18167

  18165 |                 while (!clauses[i].statements.length && i + 1 < clauses.length) {
  18166 |                     bind(clauses[i]);
> 18167 |                     i++;
  18168 |                 }
  18169 |                 var preCaseLabel = createBranchLabel();

TypeScript/lib/tsc.js:22894

  22892 |                         if (i + count <= types.length && types[i + count - 1] === baseType.types[count - 1]) {
  22893 |                             result.push(baseType);
> 22894 |                             i += count - 1;
  22895 |                             continue;
  22896 |                         }

TypeScript/src/compiler/binder.ts:1145

  1143 |                 while (!clauses[i].statements.length && i + 1 < clauses.length) {
  1144 |                     bind(clauses[i]);
> 1145 |                     i++;
  1146 |                 }
  1147 |                 const preCaseLabel = createBranchLabel();

TypeScript/src/compiler/checker.ts:2890

  2888 |                         if (i + count <= types.length && types[i + count - 1] === baseType.types[count - 1]) {
  2889 |                             result.push(baseType);
> 2890 |                             i += count - 1;
  2891 |                             continue;
  2892 |                         }

TypeScript/src/services/documentHighlights.ts:583

   581 |                         kind: HighlightSpanKind.reference
   582 |                     });
>  583 |                     i++; // skip the next keyword
   584 |                     continue;
   585 |                 }

ace/lib/ace/mode/html/saxparser.js:820

   818 | 		for (var i = 1; i < token.data.length; i++) {
   819 | 			if (!token.data[i].nodeName)
>  820 | 				token.data.splice(i--, 1);
   821 | 		}
   822 | 	} else if (token.type === 'EndTag') {

ace/lib/ace/mode/yaml/yaml-lint.js:623

   621 |         result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
   622 |         // Advance index one extra since we already used that char here.
>  623 |         i++; continue;
   624 |       }
   625 |     }

ace/src/editor.js:1880

  1878 |                 var first = rows.first;
  1879 |                 var last = rows.last;
> 1880 |                 while (++i < l) {
  1881 |                     if (totalDiff) ranges[i].moveBy(totalDiff, 0);
  1882 |                     var subRows = this.$getSelectedRows(ranges[i]);

...and 43 more (see ruling JSON files for full list)

[ss-vibe-bot]

github-actions[bot] 2026-02-05T15:41:33Z addressed
These 53 issues are no longer flagged because they all use UpdateExpression (i++, i--, ++i, --i) or compound assignment (i += count - 1) patterns for intentional skip-ahead in parsing/iteration code. This is the expected behavior per the approved approach.

Looking at the examples:

• i++ for skipping already-processed elements (EventLog.tsx, tsc.js, binder.ts, documentHighlights.ts, yaml-lint.js)
• i += count - 1 for batch skip-ahead (checker.ts)
• i-- in splice operations for array removal (saxparser.js)
• ++i in while conditions controlling loop advancement (editor.js)

The implementation correctly distinguishes these legitimate patterns from simple assignments (i = value) which are still flagged as potential early-exit patterns that should use break.

[francois-mora-sonarsource]

The PR is missing unit tests for the nested loop case.

[ss-vibe-bot]

francois-mora-sonarsource 2026-02-06T16:42:29Z addressed
Good catch. I've added 4 dedicated nested loop test cases:

Valid (compliant):

• i++ on outer counter in nested for-loop body (intentional skip-ahead)
• i += batchSize - 1 on outer counter after nested for-loop (compound assignment skip-ahead)

Invalid (noncompliant):

• i += 2 in nested for-loop's update clause (flagged even though compound assignments are normally allowed — the nested update clause exception takes precedence)
• i = j simple assignment to outer counter in nested loop body (flagged as expected)

These cover the isInNestedForLoopUpdate logic path and verify the algorithm's step 4: "For writes in nested for-loop update clauses that modify the outer counter: Continue to report." All tests pass.

[francois-mora-sonarsource]

LGTM

[sonarqube-next]

Quality Gate passed

Issues
0 New issues
0 Fixed issues
0 Accepted issues

Measures
0 Security Hotspots
0 Dependency risks
97.4% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube