eslint-plugin-sonarjs 4.0.3 → 4.1.0

package/cjs/S8786/meta.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslintId = exports.implementation = void 0;
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+// https://sonarsource.github.io/rspec/#/rspec/S8786/javascript
+exports.implementation = 'original';
+exports.eslintId = 'super-linear-regex';

package/cjs/{S4818 → S8786}/rule.js

@@ -15,7 +15,7 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-// https://sonarsource.github.io/rspec/#/rspec/S4818/javascript
+// https://sonarsource.github.io/rspec/#/rspec/S8786/javascript
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -51,25 +51,29 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
+const scslre_1 = require("scslre");
 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, generate_meta_js_1.generateMeta)(meta, {
-        messages: {
-            safeSocket: 'Make sure that sockets are used safely here.',
+const rule_template_js_1 = require("../helpers/regex/rule-template.js");
+const message = `Simplify this regular expression to reduce its runtime, as it has super-linear performance due to backtracking.`;
+exports.rule = (0, rule_template_js_1.createRegExpRule)(context => {
+    return {
+        onRegExpLiteralEnter: (node) => {
+            let reports;
+            try {
+                ({ reports } = (0, scslre_1.analyse)(node));
+            }
+            catch {
+                return;
+            }
+            const hasExponential = reports.some(r => r.exponential);
+            const hasNonExponential = reports.some(r => !r.exponential);
+            if (hasNonExponential && !hasExponential) {
+                context.report({
+                    message,
+                    node: context.node,
+                });
+            }
         },
-    }),
-    create(context) {
-        return {
-            NewExpression: (node) => checkCallExpression(node, context, 'net.Socket'),
-            CallExpression: (node) => checkCallExpression(node, context, 'net.createConnection', 'net.connect'),
-        };
-    },
-};
-function checkCallExpression(callExpr, context, ...sensitiveFqns) {
-    const callFqn = (0, module_js_1.getFullyQualifiedName)(context, callExpr);
-    if (callFqn !== null && sensitiveFqns.includes(callFqn)) {
-        context.report({ messageId: 'safeSocket', node: callExpr.callee });
-    }
-}
+    };
+}, (0, generate_meta_js_1.generateMeta)(meta));

package/cjs/S881/generated-meta.js

@@ -31,7 +31,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
+exports.skipOnGeneratedSource = exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
 __exportStar(require("./meta.js"), exports);
 exports.meta = {
     type: 'suggestion',
@@ -49,3 +49,4 @@ exports.sonarKey = 'S881';
 exports.scope = 'Main';
 exports.languages = ['js', 'ts'];
 exports.requiredDependency = [];
+exports.skipOnGeneratedSource = false;

package/cjs/S888/generated-meta.js

@@ -31,7 +31,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
+exports.skipOnGeneratedSource = exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
 __exportStar(require("./meta.js"), exports);
 exports.meta = {
     type: 'suggestion',
@@ -49,3 +49,4 @@ exports.sonarKey = 'S888';
 exports.scope = 'Main';
 exports.languages = ['js', 'ts'];
 exports.requiredDependency = [];
+exports.skipOnGeneratedSource = false;

package/cjs/S930/generated-meta.js

@@ -31,7 +31,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
+exports.skipOnGeneratedSource = exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
 __exportStar(require("./meta.js"), exports);
 exports.meta = {
     type: 'problem',
@@ -49,3 +49,4 @@ exports.sonarKey = 'S930';
 exports.scope = 'Main';
 exports.languages = ['js'];
 exports.requiredDependency = [];
+exports.skipOnGeneratedSource = false;

package/cjs/helpers/assertions-chai-common.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChaiPropertyPredicate = getChaiPropertyPredicate;
+exports.getArgumentAtIndex = getArgumentAtIndex;
+function getChaiPropertyPredicate(name) {
+    switch (name) {
+        case 'true':
+        case 'ok':
+            return { predicate: 'truthy', negated: false };
+        case 'false':
+            return { predicate: 'falsy', negated: false };
+        case 'null':
+            return { predicate: 'null', negated: false };
+        case 'undefined':
+            return { predicate: 'undefined', negated: false };
+        case 'exist':
+        case 'exists':
+            return { predicate: 'defined', negated: false };
+        default:
+            return null;
+    }
+}
+function getArgumentAtIndex(node, index) {
+    const argument = node.arguments[index];
+    if (!argument || argument.type === 'SpreadElement') {
+        return null;
+    }
+    return argument;
+}

package/cjs/helpers/assertions-chai.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractChaiAssertion = extractChaiAssertion;
+const ast_js_1 = require("./ast.js");
+const assertions_chai_common_js_1 = require("./assertions-chai-common.js");
+const module_js_1 = require("./module.js");
+function extractChaiAssertion(context, node, allowGlobal) {
+    // chai supports three assertion styles:
+    // assert-style (`assert.strictEqual(value, value)`)
+    // expect-style (`expect(value).toBeTruthy()`)
+    // should-style (`value.should.be.truthy`)
+    if (node.type === 'CallExpression') {
+        return (extractChaiAssertAssertion(context, node, allowGlobal) ??
+            extractChaiExpectCallAssertion(context, node, allowGlobal) ??
+            extractChaiShouldCallAssertion(node));
+    }
+    if (node.type === 'MemberExpression') {
+        return (extractChaiExpectPropertyAssertion(context, node, allowGlobal) ??
+            extractChaiShouldPropertyAssertion(node));
+    }
+    return null;
+}
+/**
+ * Covers Chai's assert style assertions like `assert.strictEqual(value, value)` or `assert.ok(value)`
+ */
+function extractChaiAssertAssertion(context, node, allowGlobal) {
+    const assertCall = getChaiAssertCall(context, node, allowGlobal);
+    if (!assertCall) {
+        return null;
+    }
+    const predicate = getChaiAssertPredicate(assertCall.method);
+    if (predicate) {
+        const actual = (0, assertions_chai_common_js_1.getArgumentAtIndex)(node, 0);
+        if (!actual) {
+            return null;
+        }
+        return {
+            style: 'chai-assert',
+            kind: 'predicate',
+            predicate: predicate.predicate,
+            actual,
+            negated: predicate.negated,
+            node,
+            reportNode: actual,
+        };
+    }
+    const actual = (0, assertions_chai_common_js_1.getArgumentAtIndex)(node, 0);
+    const expected = (0, assertions_chai_common_js_1.getArgumentAtIndex)(node, 1);
+    if (!actual || !expected) {
+        return null;
+    }
+    return {
+        style: 'chai-assert',
+        kind: 'comparison',
+        comparison: getChaiAssertComparison(assertCall.method),
+        actual,
+        expected,
+        negated: assertCall.method.startsWith('not'),
+        node,
+        reportNode: assertCall.reportNode,
+    };
+}
+function getChaiAssertComparison(method) {
+    switch (method) {
+        case 'equal':
+        case 'notEqual':
+            return 'loose';
+        case 'deepEqual':
+        case 'notDeepEqual':
+            return 'deep';
+        default:
+            return 'strict';
+    }
+}
+function getChaiAssertCall(context, node, allowGlobal) {
+    const fqnMethod = getChaiAssertMethodFromFqn((0, module_js_1.getFullyQualifiedName)(context, node.callee));
+    if (fqnMethod) {
+        return { method: fqnMethod, reportNode: node.callee };
+    }
+    if (allowGlobal &&
+        (0, ast_js_1.isIdentifier)(node.callee, 'assert') &&
+        isGlobalAssertReference(context, node)) {
+        return { method: 'assert', reportNode: node.callee };
+    }
+    if (allowGlobal &&
+        (0, ast_js_1.isMethodCall)(node) &&
+        (0, ast_js_1.isIdentifier)(node.callee.object, 'assert') &&
+        isGlobalAssertReference(context, node)) {
+        const method = getChaiAssertMethodFromName(node.callee.property.name);
+        if (method) {
+            return { method, reportNode: node.callee.property };
+        }
+    }
+    return null;
+}
+// Chai global `assert` should not steal calls from a locally-bound `assert`
+// such as `import assert from 'node:assert'`.
+function isGlobalAssertReference(context, node) {
+    const variable = (0, ast_js_1.getVariableFromName)(context, 'assert', node);
+    return !variable || variable.defs.length === 0;
+}
+function getChaiAssertMethodFromFqn(fqn) {
+    if (!fqn?.startsWith('chai.assert')) {
+        return null;
+    }
+    const [, , method] = fqn.split('.');
+    return getChaiAssertMethodFromName(method ?? 'assert');
+}
+function getChaiAssertMethodFromName(name) {
+    switch (name) {
+        case 'assert':
+        case 'ok':
+        case 'isOk':
+        case 'isNotOk':
+        case 'isTrue':
+        case 'isFalse':
+        case 'isNull':
+        case 'isNotNull':
+        case 'isUndefined':
+        case 'isDefined':
+        case 'exists':
+        case 'notExists':
+        case 'equal':
+        case 'notEqual':
+        case 'strictEqual':
+        case 'notStrictEqual':
+        case 'deepEqual':
+        case 'notDeepEqual':
+            return name;
+        default:
+            return null;
+    }
+}
+function getChaiAssertPredicate(method) {
+    switch (method) {
+        case 'assert':
+        case 'ok':
+        case 'isOk':
+        case 'isTrue':
+            return { predicate: 'truthy', negated: false };
+        case 'isNotOk':
+            return { predicate: 'truthy', negated: true };
+        case 'isFalse':
+            return { predicate: 'falsy', negated: false };
+        case 'isNull':
+            return { predicate: 'null', negated: false };
+        case 'isNotNull':
+            return { predicate: 'null', negated: true };
+        case 'isUndefined':
+            return { predicate: 'undefined', negated: false };
+        case 'isDefined':
+        case 'exists':
+            return { predicate: 'defined', negated: false };
+        case 'notExists':
+            return { predicate: 'defined', negated: true };
+        default:
+            return null;
+    }
+}
+/**
+ * Covers Chai's expect style assertions like `expect(value).toBeTruthy()` or `expect(value).toBeNull()`
+ */
+function extractChaiExpectCallAssertion(context, node, allowGlobal) {
+    if (!(0, ast_js_1.isMethodCall)(node)) {
+        return null;
+    }
+    const matcher = node.callee.property.name;
+    const comparison = getChaiComparison(matcher, node.callee.object);
+    if (!comparison) {
+        return null;
+    }
+    const chain = extractChaiExpectChain(context, node.callee.object, allowGlobal);
+    if (!chain) {
+        return null;
+    }
+    const expected = (0, assertions_chai_common_js_1.getArgumentAtIndex)(node, 0);
+    if (!expected) {
+        return null;
+    }
+    return {
+        style: 'chai-bdd',
+        kind: 'comparison',
+        comparison,
+        actual: chain.actual,
+        expected,
+        negated: chain.negated,
+        node,
+        reportNode: node.callee.property,
+    };
+}
+function extractChaiExpectPropertyAssertion(context, node, allowGlobal) {
+    if (node.computed || node.property.type !== 'Identifier') {
+        return null;
+    }
+    const predicate = (0, assertions_chai_common_js_1.getChaiPropertyPredicate)(node.property.name);
+    if (!predicate) {
+        return null;
+    }
+    const chain = extractChaiExpectChain(context, node.object, allowGlobal);
+    if (!chain) {
+        return null;
+    }
+    return {
+        style: 'chai-bdd',
+        kind: 'predicate',
+        predicate: predicate.predicate,
+        actual: chain.actual,
+        negated: chain.negated !== predicate.negated,
+        node,
+        reportNode: chain.actual,
+    };
+}
+function extractChaiExpectChain(context, node, allowGlobal) {
+    const chain = extractMemberChain(node);
+    if (!chain) {
+        return null;
+    }
+    const { base, properties } = chain;
+    // chai supports `expect(target [, message])`
+    if (base.type !== 'CallExpression' || base.arguments.length < 1) {
+        return null;
+    }
+    if (!isChaiExpectCall(context, base, allowGlobal)) {
+        return null;
+    }
+    const actual = (0, assertions_chai_common_js_1.getArgumentAtIndex)(base, 0);
+    if (!actual) {
+        return null;
+    }
+    return {
+        actual,
+        negated: properties.includes('not'),
+        properties,
+    };
+}
+function isChaiExpectCall(context, node, allowGlobal) {
+    return ((0, module_js_1.getFullyQualifiedName)(context, node.callee) === 'chai.expect' ||
+        (allowGlobal && (0, ast_js_1.isIdentifier)(node.callee, 'expect')));
+}
+// covers chai's should-style assertions like `value.should.be.truthy` or `value.should.be.null`
+function extractChaiShouldCallAssertion(node) {
+    if (!(0, ast_js_1.isMethodCall)(node)) {
+        return null;
+    }
+    const matcher = node.callee.property.name;
+    const comparison = getChaiComparison(matcher, node.callee.object);
+    if (!comparison) {
+        return null;
+    }
+    const chain = extractChaiShouldChain(node.callee.object);
+    if (!chain) {
+        return null;
+    }
+    const expected = (0, assertions_chai_common_js_1.getArgumentAtIndex)(node, 0);
+    if (!expected) {
+        return null;
+    }
+    return {
+        style: 'chai-bdd',
+        kind: 'comparison',
+        comparison,
+        actual: chain.actual,
+        expected,
+        negated: chain.negated,
+        node,
+        reportNode: node.callee.property,
+    };
+}
+function extractChaiShouldPropertyAssertion(node) {
+    if (node.computed || node.property.type !== 'Identifier') {
+        return null;
+    }
+    const predicate = (0, assertions_chai_common_js_1.getChaiPropertyPredicate)(node.property.name);
+    if (!predicate) {
+        return null;
+    }
+    const chain = extractChaiShouldChain(node.object);
+    if (!chain) {
+        return null;
+    }
+    return {
+        style: 'chai-bdd',
+        kind: 'predicate',
+        predicate: predicate.predicate,
+        actual: chain.actual,
+        negated: chain.negated !== predicate.negated,
+        node,
+        reportNode: chain.actual,
+    };
+}
+function extractChaiShouldChain(node) {
+    const properties = [];
+    let current = node;
+    while (current.type === 'MemberExpression' && !current.computed) {
+        if (current.property.type !== 'Identifier') {
+            return null;
+        }
+        if (current.property.name === 'should') {
+            return {
+                actual: current.object,
+                negated: properties.includes('not'),
+                properties,
+            };
+        }
+        properties.unshift(current.property.name);
+        current = current.object;
+    }
+    return null;
+}
+function extractMemberChain(node) {
+    const properties = [];
+    let current = node;
+    while (current.type === 'MemberExpression' && !current.computed) {
+        if (current.property.type !== 'Identifier') {
+            return null;
+        }
+        properties.unshift(current.property.name);
+        current = current.object;
+    }
+    return { base: current, properties };
+}
+function getChaiComparison(matcher, chainNode) {
+    if (matcher === 'eql' || matcher === 'eqls') {
+        return 'deep';
+    }
+    if (matcher === 'equal' || matcher === 'equals' || matcher === 'eq') {
+        const chain = extractMemberChain(chainNode);
+        return chain?.properties.includes('deep') ? 'deep' : 'strict';
+    }
+    return null;
+}

package/cjs/helpers/assertions-cypress.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCypressChainAssertion = extractCypressChainAssertion;
+const ast_js_1 = require("./ast.js");
+const assertions_chai_common_js_1 = require("./assertions-chai-common.js");
+/**
+ * Covers Cypress chain assertions like `cy.wrap(value).should('be.true')` or `cy.wrap(value).and('be.null')`.
+ * The predicate is a Chai assertion string (dot-separated, optional `not.` prefix).
+ */
+function extractCypressChainAssertion(node) {
+    if (node.type !== 'CallExpression' || !(0, ast_js_1.isMethodCall)(node)) {
+        return null;
+    }
+    if (!(0, ast_js_1.isIdentifier)(node.callee.property, 'should', 'and')) {
+        return null;
+    }
+    const predicateArg = node.arguments[0];
+    if (predicateArg?.type !== 'Literal' || typeof predicateArg.value !== 'string') {
+        return null;
+    }
+    const subject = extractCyWrapSubject(node.callee.object);
+    if (!subject) {
+        return null;
+    }
+    const comparison = parseCypressComparisonString(predicateArg.value);
+    if (comparison) {
+        const expected = (0, assertions_chai_common_js_1.getArgumentAtIndex)(node, 1);
+        if (!expected) {
+            return null;
+        }
+        return {
+            style: 'cypress',
+            kind: 'comparison',
+            comparison,
+            actual: subject,
+            expected,
+            negated: predicateArg.value.split('.').includes('not'),
+            node,
+            reportNode: node.callee.property,
+        };
+    }
+    const parsed = parseCypressPredicateString(predicateArg.value);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        style: 'cypress',
+        kind: 'predicate',
+        predicate: parsed.predicate,
+        actual: subject,
+        negated: parsed.negated,
+        node,
+        reportNode: subject,
+    };
+}
+function parseCypressComparisonString(predicate) {
+    const parts = predicate.split('.');
+    let idx = 0;
+    if (parts[idx] === 'not') {
+        idx++;
+    }
+    if (parts[idx] === 'deep' && parts[idx + 1] === 'equal') {
+        return 'deep';
+    }
+    if (parts[idx] === 'equal') {
+        return 'strict';
+    }
+    return null;
+}
+function extractCyWrapSubject(node) {
+    if (node.type === 'CallExpression' && (0, ast_js_1.isMethodCall)(node)) {
+        if ((0, ast_js_1.isIdentifier)(node.callee.object, 'cy') && (0, ast_js_1.isIdentifier)(node.callee.property, 'wrap')) {
+            const arg = node.arguments[0];
+            return arg && arg.type !== 'SpreadElement' ? arg : null;
+        }
+        return extractCyWrapSubject(node.callee.object);
+    }
+    if (node.type === 'MemberExpression' && !node.computed) {
+        return extractCyWrapSubject(node.object);
+    }
+    return null;
+}
+function parseCypressPredicateString(predicate) {
+    const parts = predicate.split('.');
+    let idx = 0;
+    const negated = parts[idx] === 'not';
+    if (negated) {
+        idx++;
+    }
+    if (parts[idx] === 'be') {
+        idx++;
+    }
+    const result = (0, assertions_chai_common_js_1.getChaiPropertyPredicate)(parts[idx]);
+    return result ? { predicate: result.predicate, negated } : null;
+}