eslint-plugin-sonarjs 4.0.0 → 4.0.2

package/cjs/S2187/rule.js

@@ -51,7 +51,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
 const meta = __importStar(require("./generated-meta.js"));
 const APIs = new Set([
     // Jasmine
@@ -114,7 +114,7 @@ const APIs = new Set([
     'ruleTester.run',
 ]);
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             missingTest: 'Add some tests to this file or delete it.',
         },

package/cjs/S2201/rule.js

@@ -55,7 +55,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 const typescript_1 = __importDefault(require("typescript"));
-const index_js_1 = require("../helpers/index.js");
+const ancestor_js_1 = require("../helpers/ancestor.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
 const meta = __importStar(require("./generated-meta.js"));
 const METHODS_WITHOUT_SIDE_EFFECTS = {
     array: new Set([
@@ -68,6 +71,8 @@ const METHODS_WITHOUT_SIDE_EFFECTS = {
         'entries',
         'filter',
         'findIndex',
+        'findLast',
+        'findLastIndex',
         'keys',
         'map',
         'values',
@@ -203,7 +208,7 @@ const METHODS_WITHOUT_SIDE_EFFECTS = {
     ]),
 };
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             useForEach: `Consider using "forEach" instead of "map" as its return value is not being used here.`,
             returnValueMustBeUsed: 'The return value of "{{methodName}}" must be used.',
@@ -211,7 +216,7 @@ exports.rule = {
     }),
     create(context) {
         const services = context.sourceCode.parserServices;
-        if (!(0, index_js_1.isRequiredParserServices)(services)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(services)) {
             return {};
         }
         return {
@@ -226,7 +231,8 @@ exports.rule = {
                             .getTypeChecker()
                             .getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(callee.object));
                         if (!hasSideEffect(methodName, objectType, services) &&
-                            !isReplaceWithCallback(methodName, call.arguments, services)) {
+                            !isReplaceWithCallback(methodName, call.arguments, services) &&
+                            !isFindWithAssignmentCallback(methodName, call.arguments, context.sourceCode.visitorKeys)) {
                             context.report(reportDescriptor(methodName, node));
                         }
                     }
@@ -241,12 +247,48 @@ const isFunctionTypeNode = (candidate) => {
 };
 function isReplaceWithCallback(methodName, callArguments, services) {
     if (methodName === 'replace' && callArguments.length > 1) {
-        const type = (0, index_js_1.getTypeFromTreeNode)(callArguments[1], services);
+        const type = (0, type_js_1.getTypeFromTreeNode)(callArguments[1], services);
         const typeNode = services.program.getTypeChecker().typeToTypeNode(type, undefined, undefined);
         return typeNode && isFunctionTypeNode(typeNode);
     }
     return false;
 }
+// Early-exit array methods currently in METHODS_WITHOUT_SIDE_EFFECTS['array']
+const EARLY_EXIT_ARRAY_METHODS = new Set(['find', 'findIndex', 'findLast', 'findLastIndex']);
+/**
+ * Returns true if the call is an early-exit array method whose first argument is an inline
+ * function containing an AssignmentExpression. Such callbacks intentionally assign to outer
+ * variables to exploit early-exit behavior, making the return value unused by design.
+ */
+function isFindWithAssignmentCallback(methodName, callArguments, visitorKeys) {
+    if (!EARLY_EXIT_ARRAY_METHODS.has(methodName) || callArguments.length === 0) {
+        return false;
+    }
+    const callback = callArguments[0];
+    if (callback.type !== 'ArrowFunctionExpression' && callback.type !== 'FunctionExpression') {
+        return false;
+    }
+    return containsAssignment(callback.body, visitorKeys);
+}
+const FUNCTION_BOUNDARIES = new Set([
+    'FunctionExpression',
+    'ArrowFunctionExpression',
+    'FunctionDeclaration',
+]);
+/**
+ * Recursively checks if an AST node contains an AssignmentExpression, using childrenOf for
+ * complete traversal. Stops at nested function boundaries so assignments in inner closures
+ * do not suppress the issue.
+ */
+function containsAssignment(node, visitorKeys) {
+    if (node.type === 'AssignmentExpression') {
+        return true;
+    }
+    if (FUNCTION_BOUNDARIES.has(node.type)) {
+        return false;
+    }
+    return (0, ancestor_js_1.childrenOf)(node, visitorKeys).some(child => containsAssignment(child, visitorKeys));
+}
 function reportDescriptor(methodName, node) {
     if (methodName === 'map') {
         return {

package/cjs/S2208/rule.js

@@ -51,10 +51,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             wildcardImport: 'Explicitly {{xPort}} the specific member needed.',
         },

package/cjs/S2234/rule.js

@@ -51,13 +51,17 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const ast_js_1 = require("../helpers/ast.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const location_js_1 = require("../helpers/location.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         const services = context.sourceCode.parserServices;
-        const canResolveType = (0, index_js_1.isRequiredParserServices)(services);
+        const canResolveType = (0, parser_services_js_1.isRequiredParserServices)(services);
         function checkArguments(functionCall) {
             // Extract argument names first (cheap operation)
             const argumentNames = functionCall.arguments.map(arg => {
@@ -77,6 +81,9 @@ exports.rule = {
                 return;
             }
             const { params: functionParameters, declaration: functionDeclaration } = resolvedFunction;
+            if (isCryptoCyclicRotation(functionCall, functionParameters)) {
+                return;
+            }
             for (let argumentIndex = 0; argumentIndex < argumentNames.length; argumentIndex++) {
                 const argumentName = argumentNames[argumentIndex];
                 if (argumentName) {
@@ -138,11 +145,11 @@ exports.rule = {
                 return resolveFromTSSignature(node);
             }
             let functionDeclaration = null;
-            if ((0, index_js_1.isFunctionNode)(node.callee)) {
+            if ((0, ast_js_1.isFunctionNode)(node.callee)) {
                 functionDeclaration = node.callee;
             }
             else if (node.callee.type === 'Identifier') {
-                functionDeclaration = (0, index_js_1.resolveFromFunctionReference)(context, node.callee);
+                functionDeclaration = (0, ast_js_1.resolveFromFunctionReference)(context, node.callee);
             }
             if (!functionDeclaration) {
                 return null;
@@ -153,7 +160,7 @@ exports.rule = {
             };
         }
         function resolveFromTSSignature(node) {
-            const signature = (0, index_js_1.getSignatureFromCallee)(node, services);
+            const signature = (0, type_js_1.getSignatureFromCallee)(node, services);
             if (signature?.declaration) {
                 return {
                     params: signature.parameters.map(param => param.name),
@@ -176,14 +183,14 @@ exports.rule = {
         }
         function haveCompatibleTypes(arg1, arg2) {
             if (canResolveType) {
-                const type1 = normalizeType((0, index_js_1.getTypeAsString)(arg1, services));
-                const type2 = normalizeType((0, index_js_1.getTypeAsString)(arg2, services));
+                const type1 = normalizeType((0, type_js_1.getTypeAsString)(arg1, services));
+                const type2 = normalizeType((0, type_js_1.getTypeAsString)(arg2, services));
                 return type1 === type2;
             }
             return true;
         }
         function raiseIssue(arg1, arg2, functionDeclaration, node) {
-            (0, index_js_1.report)(context, {
+            (0, location_js_1.report)(context, {
                 message: `Arguments '${arg1}' and '${arg2}' have the same names but not the same order as the function parameters.`,
                 loc: getParametersClauseLocation(node.arguments),
             }, getSecondaryLocations(functionDeclaration));
@@ -198,9 +205,49 @@ exports.rule = {
         };
     },
 };
+const CRYPTO_FUNCTION_PATTERN = /^(md[45]_?)?(ff|gg|hh|ii)$/i;
+const CRYPTO_STATE_PARAM_COUNT = 4;
+function isCryptoCyclicRotation(functionCall, functionParameters) {
+    const callee = functionCall.callee;
+    let calleeName = null;
+    if (callee.type === 'Identifier') {
+        calleeName = callee.name;
+    }
+    else if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
+        calleeName = callee.property.name;
+    }
+    if (!calleeName || !CRYPTO_FUNCTION_PATTERN.test(calleeName)) {
+        return false;
+    }
+    if (functionParameters.length < CRYPTO_STATE_PARAM_COUNT ||
+        functionCall.arguments.length < CRYPTO_STATE_PARAM_COUNT) {
+        return false;
+    }
+    // First 4 arguments must all be identifiers
+    const argNames = [];
+    for (let i = 0; i < CRYPTO_STATE_PARAM_COUNT; i++) {
+        const arg = functionCall.arguments[i];
+        if (arg.type !== 'Identifier') {
+            return false;
+        }
+        argNames.push(arg.name);
+    }
+    // First 4 parameters must all be defined
+    const paramNames = functionParameters.slice(0, CRYPTO_STATE_PARAM_COUNT);
+    if (paramNames.includes(undefined)) {
+        return false;
+    }
+    // Check if args[0..3] are a cyclic rotation of params[0..3]
+    for (let k = 1; k <= CRYPTO_STATE_PARAM_COUNT - 1; k++) {
+        if (argNames.every((arg, i) => arg === paramNames[(i + k) % CRYPTO_STATE_PARAM_COUNT])) {
+            return true;
+        }
+    }
+    return false;
+}
 function extractFunctionParameters(functionDeclaration) {
     return functionDeclaration.params.map(param => {
-        const identifiers = (0, index_js_1.resolveIdentifiers)(param);
+        const identifiers = (0, ast_js_1.resolveIdentifiers)(param);
         if (identifiers.length === 1 && identifiers[0]) {
             return identifiers[0].name;
         }
@@ -210,7 +257,7 @@ function extractFunctionParameters(functionDeclaration) {
 function getSecondaryLocations(functionDeclaration) {
     if (functionDeclaration?.params && functionDeclaration.params.length > 0) {
         const { start, end } = getParametersClauseLocation(functionDeclaration.params);
-        return [(0, index_js_1.toSecondaryLocation)({ loc: { start, end } }, 'Formal parameters')];
+        return [(0, location_js_1.toSecondaryLocation)({ loc: { start, end } }, 'Formal parameters')];
     }
     return [];
 }

package/cjs/S2245/rule.js

@@ -51,10 +51,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const module_js_1 = require("../helpers/module.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             safeGenerator: 'Make sure that using this pseudorandom number generator is safe here.',
         },
@@ -62,7 +63,7 @@ exports.rule = {
     create(context) {
         return {
             CallExpression(node) {
-                const fqn = (0, index_js_1.getFullyQualifiedName)(context, node);
+                const fqn = (0, module_js_1.getFullyQualifiedName)(context, node);
                 if (fqn === 'Math.random') {
                     context.report({
                         messageId: 'safeGenerator',

package/cjs/S2251/rule.js

@@ -51,10 +51,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const location_js_1 = require("../helpers/location.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         return {
             ForStatement: (node) => {
@@ -67,10 +68,10 @@ exports.rule = {
                 const wrongDirection = getWrongDirection(test, loopIncrement);
                 if (wrongDirection !== 0 && wrongDirection === loopIncrement.direction) {
                     const movement = wrongDirection > 0 ? 'incremented' : 'decremented';
-                    (0, index_js_1.report)(context, {
+                    (0, location_js_1.report)(context, {
                         message: `"${loopIncrement.identifier.name}" is ${movement} and will never reach its stop condition.`,
                         node: forStatement.update,
-                    }, [(0, index_js_1.toSecondaryLocation)(test)]);
+                    }, [(0, location_js_1.toSecondaryLocation)(test)]);
                 }
             },
         };

package/cjs/S2255/rule.js

@@ -51,10 +51,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const ast_js_1 = require("../helpers/ast.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             safeCookie: 'Make sure that cookie is written safely here.',
         },
@@ -75,7 +76,7 @@ exports.rule = {
                 const { left } = node;
                 if (left.type === 'MemberExpression') {
                     const { object, property } = left;
-                    if ((0, index_js_1.isIdentifier)(object, 'document') && (0, index_js_1.isIdentifier)(property, 'cookie')) {
+                    if ((0, ast_js_1.isIdentifier)(object, 'document') && (0, ast_js_1.isIdentifier)(property, 'cookie')) {
                         context.report({
                             messageId: 'safeCookie',
                             node: left,
@@ -87,14 +88,14 @@ exports.rule = {
                 const { callee, arguments: args } = node;
                 if (callee.type === 'MemberExpression' &&
                     usingExpressFramework &&
-                    (0, index_js_1.isIdentifier)(callee.property, 'cookie', 'cookies')) {
+                    (0, ast_js_1.isIdentifier)(callee.property, 'cookie', 'cookies')) {
                     context.report({
                         messageId: 'safeCookie',
                         node,
                     });
                 }
                 if (callee.type === 'MemberExpression' &&
-                    (0, index_js_1.isIdentifier)(callee.property, 'setHeader') &&
+                    (0, ast_js_1.isIdentifier)(callee.property, 'setHeader') &&
                     isLiteral(args[0], 'Set-Cookie')) {
                     context.report({
                         messageId: 'safeCookie',

package/cjs/S2259/rule.js

@@ -51,7 +51,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const equivalence_js_1 = require("../helpers/equivalence.js");
+const ancestor_js_1 = require("../helpers/ancestor.js");
+const ast_js_1 = require("../helpers/ast.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const type_js_1 = require("../helpers/type.js");
 const meta = __importStar(require("./generated-meta.js"));
 var Null;
 (function (Null) {
@@ -60,19 +65,19 @@ var Null;
     Null[Null["unknown"] = 2] = "unknown";
 })(Null || (Null = {}));
 function isNull(n) {
-    return (0, index_js_1.isNullLiteral)(n) || (0, index_js_1.isUndefined)(n);
+    return (0, ast_js_1.isNullLiteral)(n) || (0, ast_js_1.isUndefined)(n);
 }
 const equalOperators = new Set(['==', '===']);
 const notEqualOperators = new Set(['!=', '!==']);
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             nullDereference: 'TypeError can be thrown as "{{symbol}}" might be null or undefined here.',
             shortCircuitError: 'TypeError can be thrown as expression might be null or undefined here.',
         },
     }),
     create(context) {
-        if (!(0, index_js_1.isRequiredParserServices)(context.sourceCode.parserServices)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(context.sourceCode.parserServices)) {
             return {};
         }
         const alreadyRaisedSymbols = new Set();
@@ -104,9 +109,9 @@ exports.rule = {
 function getNullState(expr, node, context) {
     const { left, right } = expr;
     if ((isNull(right) &&
-        (0, index_js_1.areEquivalent)(left, node, context.sourceCode)) ||
+        (0, equivalence_js_1.areEquivalent)(left, node, context.sourceCode)) ||
         (isNull(left) &&
-            (0, index_js_1.areEquivalent)(right, node, context.sourceCode))) {
+            (0, equivalence_js_1.areEquivalent)(right, node, context.sourceCode))) {
         if (notEqualOperators.has(expr.operator)) {
             return Null.discarded;
         }
@@ -131,7 +136,7 @@ function checkLogicalNullDereference(expr, node, context) {
 function isWrittenInInnerFunction(symbol, fn) {
     return symbol.references.some(ref => {
         if (ref.isWrite() && ref.identifier.hasOwnProperty('parent')) {
-            const enclosingFn = (0, index_js_1.findFirstMatchingAncestor)(ref.identifier, node => index_js_1.functionLike.has(node.type));
+            const enclosingFn = (0, ancestor_js_1.findFirstMatchingAncestor)(ref.identifier, node => ast_js_1.functionLike.has(node.type));
             return enclosingFn && enclosingFn !== fn;
         }
         return false;
@@ -148,10 +153,10 @@ function checkNullDereference(node, context, alreadyRaisedSymbols) {
     }
     const enclosingFunction = context.sourceCode
         .getAncestors(node)
-        .find(n => index_js_1.functionLike.has(n.type));
+        .find(n => ast_js_1.functionLike.has(n.type));
     if (!alreadyRaisedSymbols.has(symbol) &&
         !isWrittenInInnerFunction(symbol, enclosingFunction) &&
-        (0, index_js_1.isUndefinedOrNull)(node, context.sourceCode.parserServices)) {
+        (0, type_js_1.isUndefinedOrNull)(node, context.sourceCode.parserServices)) {
         alreadyRaisedSymbols.add(symbol);
         context.report({
             messageId: 'nullDereference',

package/cjs/S2301/rule.js

@@ -51,20 +51,25 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const type_js_1 = require("../helpers/type.js");
+const reaching_definitions_js_1 = require("../helpers/reaching-definitions.js");
+const ast_js_1 = require("../helpers/ast.js");
+const parser_services_js_1 = require("../helpers/parser-services.js");
+const location_js_1 = require("../helpers/location.js");
 const meta = __importStar(require("./generated-meta.js"));
 const message = 'Provide multiple methods instead of using "{{parameterName}}" to determine which action to take.';
 /**
  * A suspect test node is a test node that is the only child of a function body
  */
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta, {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
         messages: {
             message,
         },
     }),
     create: context => {
-        if (!(0, index_js_1.isRequiredParserServices)(context.sourceCode.parserServices)) {
+        if (!(0, parser_services_js_1.isRequiredParserServices)(context.sourceCode.parserServices)) {
             return {};
         }
         const suspectTestNodes = [];
@@ -77,7 +82,7 @@ exports.rule = {
             }
         };
         const isAChildOf = (identifier, node) => {
-            if ((0, index_js_1.hasParent)(identifier)) {
+            if ((0, ast_js_1.hasParent)(identifier)) {
                 if (identifier.parent === node) {
                     return true;
                 }
@@ -114,21 +119,21 @@ exports.rule = {
                 if (!isSuspect) {
                     return;
                 }
-                const variable = (0, index_js_1.getVariableFromIdentifier)(node, context.sourceCode.getScope(node));
+                const variable = (0, reaching_definitions_js_1.getVariableFromIdentifier)(node, context.sourceCode.getScope(node));
                 if (variable) {
                     const definition = variable.defs.at(-1);
                     if (definition?.type === 'Parameter') {
-                        const type = (0, index_js_1.getTypeFromTreeNode)(definition.name, context.sourceCode.parserServices);
+                        const type = (0, type_js_1.getTypeFromTreeNode)(definition.name, context.sourceCode.parserServices);
                         const definitionParent = definition.name.parent;
-                        if ((0, index_js_1.isBooleanType)(type) && definitionParent?.type !== 'Property') {
-                            (0, index_js_1.report)(context, {
+                        if ((0, type_js_1.isBooleanType)(type) && definitionParent?.type !== 'Property') {
+                            (0, location_js_1.report)(context, {
                                 message,
                                 loc: node.loc,
                                 data: {
                                     parameterName: variable.name,
                                 },
                             }, [
-                                (0, index_js_1.toSecondaryLocation)(definition.name, `Parameter "${variable.name}" was declared here`),
+                                (0, location_js_1.toSecondaryLocation)(definition.name, `Parameter "${variable.name}" was declared here`),
                             ]);
                         }
                     }

package/cjs/S2310/rule.js

@@ -51,10 +51,13 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
-const index_js_1 = require("../helpers/index.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const ancestor_js_1 = require("../helpers/ancestor.js");
+const ast_js_1 = require("../helpers/ast.js");
+const location_js_1 = require("../helpers/location.js");
 const meta = __importStar(require("./generated-meta.js"));
 exports.rule = {
-    meta: (0, index_js_1.generateMeta)(meta),
+    meta: (0, generate_meta_js_1.generateMeta)(meta),
     create(context) {
         function checkLoop(updateNode, extractCounters, loopBody) {
             const counters = [];
@@ -64,7 +67,7 @@ exports.rule = {
             }
         }
         function checkCounter(counter, block) {
-            const variable = (0, index_js_1.getVariableFromName)(context, counter.name, block);
+            const variable = (0, ast_js_1.getVariableFromName)(context, counter.name, block);
             if (!variable) {
                 return;
             }
@@ -73,16 +76,16 @@ exports.rule = {
                     if (isIntentionalSkipAhead(ref.identifier, block)) {
                         continue;
                     }
-                    (0, index_js_1.report)(context, {
+                    (0, location_js_1.report)(context, {
                         node: ref.identifier,
                         message: `Remove this assignment of "${counter.name}".`,
-                    }, [(0, index_js_1.toSecondaryLocation)(counter, 'Counter variable update')]);
+                    }, [(0, location_js_1.toSecondaryLocation)(counter, 'Counter variable update')]);
                 }
             }
         }
         return {
             'ForStatement > BlockStatement': (node) => {
-                const forLoop = (0, index_js_1.getParent)(context, node);
+                const forLoop = (0, ancestor_js_1.getParent)(context, node);
                 if (forLoop.update) {
                     checkLoop(forLoop.update, collectCountersFor, node);
                 }
@@ -113,28 +116,96 @@ function collectCountersFor(updateExpression, counters) {
 /**
  * Checks if a loop counter modification is an intentional skip-ahead pattern
  * (UpdateExpression or compound assignment) rather than a simple assignment.
+ * Simple assignments (=) are allowed when a splice() call using the same
+ * counter variable exists in the enclosing block (splice compensation pattern).
  * Modifications in nested for-loop update clauses are not considered skip-ahead.
  */
 function isIntentionalSkipAhead(id, outerLoopBody) {
     if (isInNestedForLoopUpdate(id, outerLoopBody)) {
         return false;
     }
-    const parent = (0, index_js_1.getNodeParent)(id);
+    const parent = (0, ancestor_js_1.getNodeParent)(id);
     if (parent?.type === 'UpdateExpression') {
         return true;
     }
     if (parent?.type === 'AssignmentExpression' && parent.operator !== '=') {
         return true;
     }
+    if (parent?.type === 'AssignmentExpression' && parent.operator === '=') {
+        const block = findEnclosingBlock(id);
+        if (block && blockContainsSpliceWithCounter(block, id.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Walks up the AST from the given node to find the nearest enclosing BlockStatement.
+ */
+function findEnclosingBlock(node) {
+    let current = (0, ancestor_js_1.getNodeParent)(node);
+    while (current) {
+        if (current.type === 'BlockStatement') {
+            return current;
+        }
+        current = (0, ancestor_js_1.getNodeParent)(current);
+    }
+    return undefined;
+}
+/**
+ * Checks whether a block contains a splice() call whose first argument
+ * is an Identifier matching the given counter variable name.
+ */
+function blockContainsSpliceWithCounter(block, counterName) {
+    return block.body.some(stmt => containsSpliceWithCounter(stmt, counterName));
+}
+/**
+ * Checks whether a statement contains a splice() call whose first argument
+ * references the given counter variable name. Only checks direct statements
+ * in the block — not ones nested inside conditional branches.
+ */
+function containsSpliceWithCounter(node, counterName) {
+    if (node.type === 'ExpressionStatement') {
+        return expressionContainsSplice(node.expression, counterName);
+    }
+    if (node.type === 'VariableDeclaration' &&
+        node.declarations.some(d => d.init?.type === 'CallExpression' && isSpliceCallWithCounter(d.init, counterName))) {
+        return true;
+    }
     return false;
 }
+/**
+ * Checks whether an expression is or contains a splice() call whose first argument
+ * matches the given counter variable name. Handles both direct splice calls
+ * and splice calls on the right side of assignments (e.g., removed = arr.splice(i, 1)).
+ */
+function expressionContainsSplice(expr, counterName) {
+    if (expr.type === 'CallExpression') {
+        return isSpliceCallWithCounter(expr, counterName);
+    }
+    return (expr.type === 'AssignmentExpression' &&
+        expr.right.type === 'CallExpression' &&
+        isSpliceCallWithCounter(expr.right, counterName));
+}
+/**
+ * Checks if a CallExpression is a .splice() call whose first argument
+ * is an Identifier matching the counter variable name.
+ */
+function isSpliceCallWithCounter(call, counterName) {
+    return (call.callee.type === 'MemberExpression' &&
+        call.callee.property.type === 'Identifier' &&
+        call.callee.property.name === 'splice' &&
+        call.arguments.length >= 1 &&
+        call.arguments[0].type === 'Identifier' &&
+        call.arguments[0].name === counterName);
+}
 function isUsedInsideBody(id, loopBody) {
     const bodyRange = loopBody.range;
     return id.range && bodyRange && id.range[0] > bodyRange[0] && id.range[1] < bodyRange[1];
 }
 function isInNestedForLoopUpdate(id, outerLoopBody) {
     let node = id;
-    let parent = (0, index_js_1.getNodeParent)(node);
+    let parent = (0, ancestor_js_1.getNodeParent)(node);
     while (parent) {
         // Stop if we've reached the outer loop body
         if (parent === outerLoopBody) {
@@ -151,7 +222,7 @@ function isInNestedForLoopUpdate(id, outerLoopBody) {
             }
         }
         node = parent;
-        parent = (0, index_js_1.getNodeParent)(node);
+        parent = (0, ancestor_js_1.getNodeParent)(node);
     }
     return false;
 }