eslint-plugin-sonarjs 4.0.2 → 4.1.0

package/cjs/S5906/rule.js

@@ -0,0 +1,365 @@
+"use strict";
+/*
+ * 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/S5906/javascript
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const semver_1 = require("semver");
+const assertions_js_1 = require("../helpers/assertions.js");
+const ast_js_1 = require("../helpers/ast.js");
+const dependencies_js_1 = require("../helpers/dependency-manifests/dependencies.js");
+const module_js_1 = require("../helpers/module.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const assertion_suggestions_js_1 = require("./assertion-suggestions.js");
+const assertion_utils_js_1 = require("./assertion-utils.js");
+const cypress_suggestions_js_1 = require("./cypress-suggestions.js");
+const expect_chain_js_1 = require("./expect-chain.js");
+const meta = __importStar(require("./generated-meta.js"));
+const playwright_suggestions_js_1 = require("./playwright-suggestions.js");
+const messages = {
+    preferSpecificAssertion: 'Prefer a more specific assertion instead of this generic one, e.g. "{{assertion}}".',
+    quickfix: 'Replace with {{assertion}}.',
+};
+const PLAYWRIGHT_MODULES = ['@playwright/test'];
+const MAX_ASSERT_ARGUMENTS_WITH_MESSAGE = 3;
+const CHAI_EQUALITY_MATCHERS = new Set(['equal', 'equals', 'eq', 'eql', 'eqls']);
+const JASMINE_SIZE_DEPENDENCIES = ['jasmine-core', 'jasmine'];
+const JASMINE_TO_HAVE_SIZE_MIN_VERSION = '3.6.0';
+exports.rule = {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, { messages, hasSuggestions: true }),
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const hasPlaywright = (0, module_js_1.importsOrDependsOnModule)(context, PLAYWRIGHT_MODULES, PLAYWRIGHT_MODULES);
+        const jasmineSupportsToHaveSize = supportsJasmineToHaveSize(context);
+        const playwrightLocators = new Set();
+        function report(node, suggestion) {
+            const replacementText = suggestion.replacement;
+            const suggest = replacementText
+                ? [
+                    {
+                        messageId: 'quickfix',
+                        data: { assertion: suggestion.assertion },
+                        fix: (fixer) => fixer.replaceText(node, replacementText),
+                    },
+                ]
+                : undefined;
+            context.report({
+                node: node.callee,
+                messageId: 'preferSpecificAssertion',
+                data: { assertion: suggestion.assertion },
+                ...(suggest ? { suggest } : {}),
+            });
+        }
+        return {
+            ...(hasPlaywright ? (0, assertion_utils_js_1.trackPlaywrightLocators)(context, playwrightLocators) : {}),
+            CallExpression(node) {
+                if (node.type !== 'CallExpression') {
+                    return;
+                }
+                if (hasPlaywright) {
+                    const playwrightSuggestion = (0, playwright_suggestions_js_1.getPlaywrightLocatorSuggestion)(context, node, sourceCode, playwrightLocators);
+                    if (playwrightSuggestion) {
+                        report(node, playwrightSuggestion);
+                        return;
+                    }
+                }
+                const assertion = (0, assertions_js_1.extractTestAssertion)(context, node);
+                if (assertion?.kind !== 'comparison') {
+                    return;
+                }
+                const suggestion = getSuggestion(context, assertion.style, node, sourceCode, jasmineSupportsToHaveSize);
+                if (suggestion) {
+                    report(node, suggestion);
+                }
+            },
+        };
+    },
+};
+function getSuggestion(context, style, node, sourceCode, jasmineSupportsToHaveSize) {
+    switch (style) {
+        case 'jest-like':
+        case 'playwright':
+            return getExpectLikeSuggestion(node, sourceCode, 'jest');
+        case 'jasmine':
+            return getExpectLikeSuggestion(node, sourceCode, 'jasmine', jasmineSupportsToHaveSize);
+        case 'chai-bdd':
+            return getChaiBddSuggestion(node, sourceCode);
+        case 'chai-assert':
+            return getChaiAssertSuggestion(context, node, sourceCode);
+        case 'cypress':
+            return (0, cypress_suggestions_js_1.getCypressSuggestion)(node, sourceCode);
+        default:
+            return null;
+    }
+}
+function getExpectLikeSuggestion(node, sourceCode, family, jasmineSupportsToHaveSize = true) {
+    if (!(0, ast_js_1.isMethodCall)(node) ||
+        !['toBe', 'toEqual', 'toStrictEqual'].includes(node.callee.property.name)) {
+        return null;
+    }
+    const chain = (0, expect_chain_js_1.getExpectChain)(node.callee.object);
+    if (!chain || node.arguments.length !== 1) {
+        return null;
+    }
+    const { actual, negated } = chain;
+    const expected = node.arguments[0];
+    const actualText = sourceCode.getText(actual);
+    const expectedText = sourceCode.getText(expected);
+    const prefix = `expect(${actualText})${negated ? '.not' : ''}`;
+    if ((0, assertion_utils_js_1.isNullLiteral)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`${prefix}.toBeNull()`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isUndefinedExpression)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(negated ? `expect(${actualText}).toBeDefined()` : `${prefix}.toBeUndefined()`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isNaNExpression)(expected)) {
+        if (family === 'jasmine' && node.callee.property.name === 'toBe') {
+            return null;
+        }
+        return (0, assertion_utils_js_1.replacement)(`${prefix}.toBeNaN()`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isLengthAccess)(actual)) {
+        if (family === 'jasmine' && !jasmineSupportsToHaveSize) {
+            return null;
+        }
+        const lengthMatcher = family === 'jasmine' ? 'toHaveSize' : 'toHaveLength';
+        return (0, assertion_utils_js_1.replacement)(`expect(${sourceCode.getText(actual.object)}).${negated ? 'not.' : ''}${lengthMatcher}(${expectedText})`, node, sourceCode);
+    }
+    const booleanExpected = (0, assertion_utils_js_1.getBooleanValue)(expected);
+    if (booleanExpected === undefined) {
+        return null;
+    }
+    return (0, assertion_suggestions_js_1.getBooleanExpressionSuggestion)(actual, booleanExpected !== negated, family, sourceCode, node);
+}
+function supportsJasmineToHaveSize(context) {
+    const dependencies = (0, dependencies_js_1.getDependenciesSanitizePaths)(context);
+    for (const dependency of JASMINE_SIZE_DEPENDENCIES) {
+        const versionSignal = dependencies.get(dependency);
+        if (!versionSignal || versionSignal === 'latest' || versionSignal === '*') {
+            continue;
+        }
+        try {
+            const version = (0, semver_1.minVersion)(versionSignal);
+            return version !== null && version.compare(JASMINE_TO_HAVE_SIZE_MIN_VERSION) >= 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+function getChaiBddSuggestion(node, sourceCode) {
+    return getChaiExpectSuggestion(node, sourceCode) ?? getChaiShouldSuggestion(node, sourceCode);
+}
+function getChaiExpectSuggestion(node, sourceCode) {
+    if (!(0, ast_js_1.isMethodCall)(node) ||
+        !CHAI_EQUALITY_MATCHERS.has(node.callee.property.name) ||
+        node.arguments.length !== 1) {
+        return null;
+    }
+    const chain = getChaiExpectChain(node.callee.object, sourceCode);
+    if (!chain) {
+        return null;
+    }
+    return getChaiValueSuggestion(chain.actual, node.arguments[0], chain.negated, node, sourceCode, chain.messageArguments);
+}
+function getChaiShouldSuggestion(node, sourceCode) {
+    if (!(0, ast_js_1.isMethodCall)(node) ||
+        !CHAI_EQUALITY_MATCHERS.has(node.callee.property.name) ||
+        node.arguments.length !== 1) {
+        return null;
+    }
+    const chain = getShouldChain(node.callee.object);
+    if (!chain) {
+        return null;
+    }
+    return getChaiShouldValueSuggestion(chain.actual, node.arguments[0], chain.negated, node, sourceCode);
+}
+function getChaiAssertSuggestion(context, node, sourceCode) {
+    const method = getAssertMethod(context, node);
+    if (!method ||
+        node.arguments.length < 2 ||
+        node.arguments.length > MAX_ASSERT_ARGUMENTS_WITH_MESSAGE) {
+        return null;
+    }
+    const [actual, expected] = node.arguments;
+    const negated = method.startsWith('not');
+    const assertObject = getAssertObject(context, node);
+    if (!assertObject) {
+        return null;
+    }
+    const assertText = sourceCode.getText(assertObject);
+    if (!['strictEqual', 'notStrictEqual'].includes(method)) {
+        return null;
+    }
+    const actualText = sourceCode.getText(actual);
+    const trailingArgs = messageArgument(node, sourceCode);
+    if ((0, assertion_utils_js_1.isNullLiteral)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`${assertText}.${negated ? 'isNotNull' : 'isNull'}(${actualText}${trailingArgs})`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isUndefinedExpression)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`${assertText}.${negated ? 'isDefined' : 'isUndefined'}(${actualText}${trailingArgs})`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isLengthAccess)(actual) && !negated) {
+        return (0, assertion_utils_js_1.replacement)(`${assertText}.lengthOf(${sourceCode.getText(actual.object)}, ${sourceCode.getText(expected)}${trailingArgs})`, node, sourceCode);
+    }
+    const booleanExpected = (0, assertion_utils_js_1.getBooleanValue)(expected);
+    if (booleanExpected === undefined) {
+        return null;
+    }
+    return (0, assertion_suggestions_js_1.getBooleanExpressionSuggestion)(actual, booleanExpected !== negated, 'assert', sourceCode, node, assertText, trailingArgs);
+}
+function getChaiValueSuggestion(actual, expected, negated, node, sourceCode, messageArguments = '') {
+    const actualText = sourceCode.getText(actual);
+    if ((0, assertion_utils_js_1.isNullLiteral)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`expect(${actualText}${messageArguments}).to${negated ? '.not' : ''}.be.null`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isUndefinedExpression)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`expect(${actualText}${messageArguments}).to${negated ? '.not' : ''}.be.undefined`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isLengthAccess)(actual)) {
+        return (0, assertion_utils_js_1.replacement)(`expect(${sourceCode.getText(actual.object)}${messageArguments}).to${negated ? '.not' : ''}.have.lengthOf(${sourceCode.getText(expected)})`, node, sourceCode);
+    }
+    const booleanExpected = (0, assertion_utils_js_1.getBooleanValue)(expected);
+    if (booleanExpected === undefined) {
+        return null;
+    }
+    return (0, assertion_suggestions_js_1.getBooleanExpressionSuggestion)(actual, booleanExpected !== negated, 'chai', sourceCode, node, 'expect', messageArguments);
+}
+function getChaiShouldValueSuggestion(actual, expected, negated, node, sourceCode) {
+    const actualText = sourceCode.getText(actual);
+    if ((0, assertion_utils_js_1.isNullLiteral)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`${(0, assertion_suggestions_js_1.chaiShouldReceiver)(actualText, actual)}.should${negated ? '.not' : ''}.be.null`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isUndefinedExpression)(expected)) {
+        return (0, assertion_utils_js_1.replacement)(`${(0, assertion_suggestions_js_1.chaiShouldReceiver)(actualText, actual)}.should${negated ? '.not' : ''}.be.undefined`, node, sourceCode);
+    }
+    if ((0, assertion_utils_js_1.isLengthAccess)(actual)) {
+        const receiver = (0, assertion_suggestions_js_1.chaiShouldReceiver)(sourceCode.getText(actual.object), actual.object);
+        return (0, assertion_utils_js_1.replacement)(`${receiver}.should${negated ? '.not' : ''}.have.lengthOf(${sourceCode.getText(expected)})`, node, sourceCode);
+    }
+    const booleanExpected = (0, assertion_utils_js_1.getBooleanValue)(expected);
+    if (booleanExpected === undefined) {
+        return null;
+    }
+    return (0, assertion_suggestions_js_1.getBooleanExpressionSuggestion)(actual, booleanExpected !== negated, 'chai-should', sourceCode, node);
+}
+function getChaiExpectChain(node, sourceCode) {
+    let current = node;
+    let negated = false;
+    while (current.type === 'MemberExpression' &&
+        !current.computed &&
+        current.property.type === 'Identifier') {
+        if (current.property.name === 'not') {
+            negated = !negated;
+        }
+        current = current.object;
+    }
+    const [actual, ...messageArguments] = current.type === 'CallExpression' ? current.arguments : [];
+    if (current.type !== 'CallExpression' || !(0, ast_js_1.isIdentifier)(current.callee, 'expect') || !actual) {
+        return null;
+    }
+    return {
+        actual,
+        negated,
+        messageArguments: messageArguments
+            .map(argument => `, ${sourceCode.getText(argument)}`)
+            .join(''),
+    };
+}
+function getShouldChain(node) {
+    let current = node;
+    let negated = false;
+    while (current.type === 'MemberExpression' &&
+        !current.computed &&
+        current.property.type === 'Identifier') {
+        if (current.property.name === 'not') {
+            negated = !negated;
+        }
+        if (current.property.name === 'should') {
+            return { actual: current.object, negated };
+        }
+        current = current.object;
+    }
+    return null;
+}
+function getAssertMethod(context, node) {
+    if (node.callee.type === 'MemberExpression' &&
+        !node.callee.computed &&
+        node.callee.property.type === 'Identifier') {
+        const object = node.callee.object;
+        if ((0, ast_js_1.isIdentifier)(object, 'assert') ||
+            (object.type === 'MemberExpression' && (0, ast_js_1.isIdentifier)(object.property, 'assert'))) {
+            return node.callee.property.name;
+        }
+        const fqn = (0, module_js_1.getFullyQualifiedName)(context, node.callee);
+        if (fqn?.startsWith('chai.assert.')) {
+            return node.callee.property.name;
+        }
+    }
+    return null;
+}
+function getAssertObject(context, node) {
+    if (node.callee.type !== 'MemberExpression' ||
+        node.callee.computed ||
+        node.callee.property.type !== 'Identifier') {
+        return null;
+    }
+    const object = node.callee.object;
+    if ((0, ast_js_1.isIdentifier)(object, 'assert') ||
+        (object.type === 'MemberExpression' && (0, ast_js_1.isIdentifier)(object.property, 'assert')) ||
+        (0, module_js_1.getFullyQualifiedName)(context, node.callee)?.startsWith('chai.assert.')) {
+        return object;
+    }
+    return null;
+}
+function messageArgument(node, sourceCode) {
+    return node.arguments[2] ? `, ${sourceCode.getText(node.arguments[2])}` : '';
+}

package/cjs/S5914/generated-meta.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ * 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/S5914/javascript
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.skipOnGeneratedSource = exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
+__exportStar(require("./meta.js"), exports);
+exports.meta = {
+    type: 'suggestion',
+    docs: {
+        description: 'Assertions should not fail or succeed unconditionally',
+        recommended: true,
+        url: 'https://sonarsource.github.io/rspec/#/rspec/S5914/javascript',
+        requiresTypeChecking: false,
+    },
+    fixable: undefined,
+    deprecated: false,
+    defaultOptions: [],
+};
+exports.sonarKey = 'S5914';
+exports.scope = 'Tests';
+exports.languages = ['js', 'ts'];
+exports.requiredDependency = [];
+exports.skipOnGeneratedSource = false;

package/cjs/{S4817 → S5914}/index.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rule = void 0;
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * 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

package/cjs/{S4787 → S5914}/meta.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.eslintId = exports.implementation = void 0;
 /*
  * SonarQube JavaScript Plugin
- * Copyright (C) 2011-2025 SonarSource Sàrl
+ * Copyright (C) SonarSource Sàrl
  * mailto:info AT sonarsource DOT com
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ * 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
@@ -18,4 +18,4 @@ exports.eslintId = exports.implementation = void 0;
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
 exports.implementation = 'original';
-exports.eslintId = 'encryption';
+exports.eslintId = 'no-trivial-assertions';

package/cjs/S5914/rule.js

@@ -0,0 +1,213 @@
+"use strict";
+/*
+ * 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/S5914/javascript
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const assertions_js_1 = require("../helpers/assertions.js");
+const ast_js_1 = require("../helpers/ast.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const meta = __importStar(require("./generated-meta.js"));
+const messages = {
+    issue: 'Replace this assertion; it always succeeds or fails.',
+    // hint targeted at identity comparisons against a freshly-created value: a deep equality matcher is almost always what was meant
+    freshIdentity: 'Use a deep equality matcher; freshly-created values are never identical to other values.',
+    // hint for predicate assertions on a freshly-created value, where the truthiness/nullishness is statically known
+    freshPredicate: 'Replace this assertion; the value is freshly created here, so the result is independent of the code under test.',
+};
+exports.rule = {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, { messages }),
+    create(context) {
+        function checkAssertion(node) {
+            const assertion = (0, assertions_js_1.extractTestAssertion)(context, node);
+            const trivial = assertion ? getTrivialAssertion(context, assertion) : null;
+            if (trivial) {
+                context.report({ node: trivial.reportNode, messageId: trivial.messageId });
+            }
+        }
+        return {
+            CallExpression(node) {
+                checkAssertion(node);
+            },
+            MemberExpression(node) {
+                checkAssertion(node);
+            },
+        };
+    },
+};
+/**
+ * Classifies the assertion as trivial (always succeeds or always fails) and picks the most
+ * informative message for the underlying cause.
+ * @returns the node to report and the corresponding message id, or null if the assertion is not trivial.
+ */
+function getTrivialAssertion(context, assertion) {
+    switch (assertion.kind) {
+        case 'predicate':
+            if (isConstantPrimitiveValue(context, assertion.actual)) {
+                return { reportNode: assertion.actual, messageId: 'issue' };
+            }
+            if (isFreshReferenceExpression(assertion.actual)) {
+                return { reportNode: assertion.actual, messageId: 'freshPredicate' };
+            }
+            return null;
+        case 'comparison':
+            if (assertion.comparison === 'strict') {
+                // a freshly-created value on either side makes strict equality trivially fail
+                // (or trivially succeed when negated). Loose equality is excluded because object-to-primitive
+                // coercion can make comparisons like `[] == false` pass.
+                if (isFreshReferenceExpression(assertion.actual)) {
+                    return { reportNode: assertion.actual, messageId: 'freshIdentity' };
+                }
+                if (isFreshReferenceExpression(assertion.expected)) {
+                    return { reportNode: assertion.expected, messageId: 'freshIdentity' };
+                }
+            }
+            // both sides are constant (syntactically or via a resolved binding): for strict or loose
+            // equality the comparison result is statically determined. Deep equality is intentionally
+            // skipped via an explicit whitelist to avoid widening this rule when assertion helper
+            // comparison kinds evolve.
+            if ((assertion.comparison === 'strict' || assertion.comparison === 'loose') &&
+                isConstantPrimitiveValue(context, assertion.actual) &&
+                isConstantPrimitiveValue(context, assertion.expected)) {
+                return { reportNode: assertion.actual, messageId: 'issue' };
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+const UNARY_OPERATORS_PRESERVING_CONSTNESS = new Set([
+    '!',
+    '+',
+    '-',
+    'typeof',
+]);
+function isConstantPrimitiveValue(context, node, visited) {
+    // resolve `const` bindings through their initializer so that identifiers bound to a constant
+    // primitive are treated as constants too. `visited` guards against mutually-recursive const
+    // references like `const a = b; const b = a;` (TDZ at runtime).
+    if (node.type === 'Identifier' && node.name !== 'undefined') {
+        visited ??= new Set();
+        const resolved = resolveConstBinding(context, node, visited);
+        if (resolved) {
+            return isConstantPrimitiveValue(context, resolved, visited);
+        }
+    }
+    switch (node.type) {
+        case 'Literal':
+            return (node.value === null ||
+                typeof node.value === 'boolean' ||
+                typeof node.value === 'string' ||
+                typeof node.value === 'number' ||
+                ('bigint' in node && typeof node.bigint === 'string'));
+        case 'Identifier':
+            if (node.name === 'undefined') {
+                const variable = (0, ast_js_1.getVariableFromName)(context, 'undefined', node);
+                // global `undefined` has no user definitions; a shadowed binding does
+                return !variable || variable.defs.length === 0;
+            }
+            return false;
+        case 'TemplateLiteral':
+            return node.expressions.length === 0;
+        case 'UnaryExpression':
+            // `void X` is always undefined regardless of X; the other operators preserve constness
+            return (node.operator === 'void' ||
+                (UNARY_OPERATORS_PRESERVING_CONSTNESS.has(node.operator) &&
+                    isConstantPrimitiveValue(context, node.argument, visited)));
+        case 'BinaryExpression':
+        case 'LogicalExpression':
+            return (isConstantPrimitiveValue(context, node.left, visited) &&
+                isConstantPrimitiveValue(context, node.right, visited));
+        default:
+            return false;
+    }
+}
+/**
+ * Returns the initializer of `node` if it refers to a `const` binding declared with a plain identifier
+ * pattern (no destructuring) and that binding has not been visited already, otherwise undefined.
+ * Restricting to `const` ensures the binding's value is statically equal to the initializer at every read.
+ * The variable is added to `visited` so mutually-recursive references cannot loop forever.
+ */
+function resolveConstBinding(context, node, visited) {
+    const variable = (0, ast_js_1.getVariableFromName)(context, node.name, node);
+    if (!variable || visited.has(variable) || variable.defs.length !== 1) {
+        return undefined;
+    }
+    const def = variable.defs[0];
+    if (def.type !== 'Variable' || def.parent?.type !== 'VariableDeclaration') {
+        return undefined;
+    }
+    if (def.parent.kind !== 'const' || def.node.id.type !== 'Identifier') {
+        return undefined;
+    }
+    visited.add(variable);
+    return def.node.init;
+}
+/**
+ * These expression types create a new reference on each evaluation, so they are always different from any other value
+ */
+const FRESH_REFERENCE_EXPRESSIONS = new Set([
+    'ArrayExpression',
+    'ObjectExpression',
+    'FunctionExpression',
+    'ArrowFunctionExpression',
+    'ClassExpression',
+    'NewExpression',
+]);
+/**
+ * Checks if the given node is an expression that creates a new reference on each evaluation, and thus is always different from any other value.
+ */
+function isFreshReferenceExpression(node) {
+    // regex literals create a fresh RegExp object on each evaluation
+    if (node.type === 'Literal' && 'regex' in node) {
+        return true;
+    }
+    return FRESH_REFERENCE_EXPRESSIONS.has(node.type);
+}