eslint-plugin-sonarjs 4.0.3 → 4.1.0

package/cjs/S8754/rule.js

@@ -0,0 +1,289 @@
+"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/S8754/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 ast_js_1 = require("../helpers/ast.js");
+const ancestor_js_1 = require("../helpers/ancestor.js");
+const generate_meta_js_1 = require("../helpers/generate-meta.js");
+const location_js_1 = require("../helpers/location.js");
+const module_js_1 = require("../helpers/module.js");
+const mocha_style_test_frameworks_js_1 = require("../helpers/mocha-style-test-frameworks.js");
+const meta = __importStar(require("./generated-meta.js"));
+const PLAYWRIGHT_DISABLED_DESCRIBE_MODIFIERS = new Set(['skip', 'fixme']);
+const MESSAGE = 'Rename this test title to make it unique within the suite.';
+const MESSAGE_ID = 'renameDuplicateTitle';
+exports.rule = {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, {
+        messages: {
+            [MESSAGE_ID]: MESSAGE,
+        },
+    }),
+    create(context) {
+        if (!(0, module_js_1.importsOrDependsOnModule)(context, mocha_style_test_frameworks_js_1.SUPPORTED_TEST_FRAMEWORKS, mocha_style_test_frameworks_js_1.SUPPORTED_TEST_FRAMEWORKS)) {
+            return {};
+        }
+        let suiteStack = [createSuiteFrame()];
+        const pushedSuiteCalls = new Set();
+        const concreteSuiteCallbacks = new Set();
+        const helperExpansionPath = new Set();
+        let testNesting = 0;
+        let ignoredSuiteNesting = 0;
+        let functionNesting = 0;
+        let concreteSuiteCallbackNesting = 0;
+        return {
+            CallExpression(node) {
+                if (isIgnoredSuiteDeclaration(context, node)) {
+                    ignoredSuiteNesting++;
+                }
+                else if (isSuiteDeclaration(context, node)) {
+                    pushedSuiteCalls.add(node);
+                    const callback = getCallback(node);
+                    if (callback !== undefined) {
+                        concreteSuiteCallbacks.add(callback);
+                    }
+                    suiteStack.push(createSuiteFrame());
+                }
+                const currentSuiteFrame = suiteStack.at(-1);
+                if (currentSuiteFrame !== undefined &&
+                    ignoredSuiteNesting === 0 &&
+                    testNesting === 0 &&
+                    isInConcreteCollectionCallback(functionNesting, concreteSuiteCallbackNesting)) {
+                    if (isTestDeclaration(context, node)) {
+                        checkTestTitle(context, node, currentSuiteFrame);
+                    }
+                    else {
+                        checkHelperDefinedTests(context, node, currentSuiteFrame, helperExpansionPath);
+                    }
+                }
+                if (isConcreteTestDeclaration(context, node)) {
+                    testNesting++;
+                }
+            },
+            'CallExpression:exit'(node) {
+                if (isIgnoredSuiteDeclaration(context, node)) {
+                    ignoredSuiteNesting--;
+                }
+                if (isConcreteTestDeclaration(context, node)) {
+                    testNesting--;
+                }
+                if (pushedSuiteCalls.delete(node)) {
+                    suiteStack.pop();
+                }
+            },
+            ':function'(node) {
+                functionNesting++;
+                if (concreteSuiteCallbacks.has(node)) {
+                    concreteSuiteCallbackNesting++;
+                }
+            },
+            ':function:exit'(node) {
+                if (concreteSuiteCallbacks.delete(node)) {
+                    concreteSuiteCallbackNesting--;
+                }
+                functionNesting--;
+            },
+            'Program:exit'() {
+                suiteStack = [createSuiteFrame()];
+                pushedSuiteCalls.clear();
+                concreteSuiteCallbacks.clear();
+                helperExpansionPath.clear();
+                testNesting = 0;
+                ignoredSuiteNesting = 0;
+                functionNesting = 0;
+                concreteSuiteCallbackNesting = 0;
+            },
+        };
+    },
+};
+function createSuiteFrame() {
+    return { titles: new Map() };
+}
+function checkTestTitle(context, node, suiteFrame) {
+    const titleNode = node.arguments[0];
+    const title = titleNode && (0, mocha_style_test_frameworks_js_1.getStaticTitle)(titleNode);
+    if (title === undefined) {
+        return;
+    }
+    const originalTitleNode = suiteFrame.titles.get(title);
+    if (originalTitleNode) {
+        (0, location_js_1.report)(context, {
+            node: titleNode,
+            messageId: MESSAGE_ID,
+            message: MESSAGE,
+        }, [(0, location_js_1.toSecondaryLocation)(originalTitleNode, 'Original test title.')]);
+        return;
+    }
+    suiteFrame.titles.set(title, titleNode);
+}
+function checkHelperDefinedTests(context, node, suiteFrame, helperExpansionPath) {
+    const helper = getLocalHelperFunction(context, node);
+    if (helper === undefined || helperExpansionPath.has(helper)) {
+        return;
+    }
+    helperExpansionPath.add(helper);
+    checkHelperNode(context, helper.body, suiteFrame, helperExpansionPath);
+    helperExpansionPath.delete(helper);
+}
+function checkHelperNode(context, node, suiteFrame, helperExpansionPath) {
+    if (node.type === 'CallExpression') {
+        if (isIgnoredSuiteDeclaration(context, node)) {
+            return;
+        }
+        if (isSuiteDeclaration(context, node)) {
+            const nestedSuiteFrame = createSuiteFrame();
+            const callback = getCallback(node);
+            if (callback !== undefined) {
+                checkHelperNode(context, callback.body, nestedSuiteFrame, helperExpansionPath);
+            }
+            return;
+        }
+        if (isTestDeclaration(context, node)) {
+            checkTestTitle(context, node, suiteFrame);
+            return;
+        }
+        checkHelperDefinedTests(context, node, suiteFrame, helperExpansionPath);
+    }
+    for (const child of (0, ancestor_js_1.childrenOf)(node, context.sourceCode.visitorKeys)) {
+        if (!ast_js_1.FUNCTION_NODES.includes(child.type)) {
+            checkHelperNode(context, child, suiteFrame, helperExpansionPath);
+        }
+    }
+}
+function isSuiteDeclaration(context, node) {
+    return ((0, mocha_style_test_frameworks_js_1.isMochaTestConstruct)(context, node, mocha_style_test_frameworks_js_1.SUITE_FUNCTION_NAMES) ||
+        isPlaywrightDescribe(context, node.callee));
+}
+function isTestDeclaration(context, node) {
+    return isConcreteTestDeclaration(context, node) || isPlaywrightTest(context, node);
+}
+function isConcreteTestDeclaration(context, node) {
+    return (0, mocha_style_test_frameworks_js_1.isMochaTestConstruct)(context, node, mocha_style_test_frameworks_js_1.TEST_FUNCTION_NAMES) && (0, mocha_style_test_frameworks_js_1.hasCallback)(node);
+}
+function isIgnoredSuiteDeclaration(context, node) {
+    if (isNonConcreteMochaSuite(context, node.callee)) {
+        return true;
+    }
+    return getPlaywrightDescribeClassification(context, node.callee) === 'ignored';
+}
+function isNonConcreteMochaSuite(context, node) {
+    const calleeParts = (0, mocha_style_test_frameworks_js_1.getMochaCalleeParts)(node);
+    if (calleeParts === undefined) {
+        return false;
+    }
+    const constructName = (0, mocha_style_test_frameworks_js_1.getMochaConstructName)(context, calleeParts.base);
+    if (constructName === undefined || !mocha_style_test_frameworks_js_1.SUITE_FUNCTION_NAMES.includes(constructName)) {
+        return false;
+    }
+    return !calleeParts.modifiers.every(modifier => (0, mocha_style_test_frameworks_js_1.isConcreteMochaTestModifier)(context, modifier));
+}
+function getCallback(node) {
+    return node.arguments.find(isCallbackFunctionNode);
+}
+function isCallbackFunctionNode(node) {
+    return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
+}
+function isFunctionNode(node) {
+    return ast_js_1.FUNCTION_NODES.includes(node.type);
+}
+function getLocalHelperFunction(context, node) {
+    if (node.callee.type !== 'Identifier') {
+        return undefined;
+    }
+    const variable = (0, ast_js_1.getVariableFromScope)(context.sourceCode.getScope(node.callee), node.callee.name);
+    const definition = variable?.defs.find(isLocalFunctionDefinition);
+    if (definition?.node.type === 'FunctionDeclaration') {
+        return definition.node;
+    }
+    if (definition?.node.type === 'VariableDeclarator' &&
+        definition.node.init != null &&
+        isFunctionNode(definition.node.init)) {
+        return definition.node.init;
+    }
+    return undefined;
+}
+function isLocalFunctionDefinition(definition) {
+    if (definition.type === 'FunctionName') {
+        return true;
+    }
+    return (definition.type === 'Variable' &&
+        definition.node.type === 'VariableDeclarator' &&
+        definition.node.init != null &&
+        isFunctionNode(definition.node.init));
+}
+function isInConcreteCollectionCallback(functionNesting, concreteSuiteCallbackNesting) {
+    return functionNesting === concreteSuiteCallbackNesting;
+}
+function isPlaywrightDescribe(context, callee) {
+    return getPlaywrightDescribeClassification(context, callee) === 'concrete';
+}
+function isPlaywrightTest(context, node) {
+    const qualifiers = (0, mocha_style_test_frameworks_js_1.getPlaywrightTestQualifiers)(context, node.callee);
+    if (qualifiers === undefined) {
+        return false;
+    }
+    return (qualifiers.every(qualifier => mocha_style_test_frameworks_js_1.PLAYWRIGHT_TEST_MODIFIERS.has(qualifier)) &&
+        (!qualifiers.includes('fail') || (0, mocha_style_test_frameworks_js_1.hasCallback)(node)));
+}
+function getPlaywrightDescribeClassification(context, callee) {
+    const qualifiers = (0, mocha_style_test_frameworks_js_1.getPlaywrightTestQualifiers)(context, callee) ?? (0, mocha_style_test_frameworks_js_1.getPlaywrightDescribeQualifiers)(callee);
+    if (qualifiers?.[0] !== 'describe') {
+        return 'unknown';
+    }
+    const modifiers = qualifiers.slice(1);
+    if (modifiers.some(modifier => PLAYWRIGHT_DISABLED_DESCRIBE_MODIFIERS.has(modifier))) {
+        return 'ignored';
+    }
+    const runnableModifiers = modifiers.at(-1) === mocha_style_test_frameworks_js_1.PLAYWRIGHT_DESCRIBE_FOCUS_MODIFIER ? modifiers.slice(0, -1) : modifiers;
+    return runnableModifiers.every(modifier => mocha_style_test_frameworks_js_1.PLAYWRIGHT_DESCRIBE_MODIFIERS.has(modifier))
+        ? 'concrete'
+        : 'unknown';
+}

package/cjs/{S4784 → S8780}/generated-meta.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/S4784/javascript
+// https://sonarsource.github.io/rspec/#/rspec/S8780/javascript
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -31,21 +31,22 @@ 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',
     docs: {
-        description: 'Using regular expressions is security-sensitive',
-        recommended: false,
-        url: 'https://sonarsource.github.io/rspec/#/rspec/S4784/javascript',
+        description: 'Async test assertions should be awaited or returned',
+        recommended: true,
+        url: 'https://sonarsource.github.io/rspec/#/rspec/S8780/javascript',
         requiresTypeChecking: false,
     },
     fixable: undefined,
-    deprecated: true,
+    deprecated: false,
     defaultOptions: [],
 };
-exports.sonarKey = 'S4784';
-exports.scope = 'Main';
+exports.sonarKey = 'S8780';
+exports.scope = 'Tests';
 exports.languages = ['js', 'ts'];
 exports.requiredDependency = [];
+exports.skipOnGeneratedSource = false;

package/cjs/{S2255 → S8780}/meta.js

@@ -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 = 'cookies';
+exports.eslintId = 'async-test-assertions';

package/cjs/S8780/rule.js

@@ -0,0 +1,321 @@
+"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/S8780/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 generate_meta_js_1 = require("../helpers/generate-meta.js");
+const ast_js_1 = require("../helpers/ast.js");
+const mocha_js_1 = require("../helpers/mocha.js");
+const module_js_1 = require("../helpers/module.js");
+const meta = __importStar(require("./generated-meta.js"));
+const messages = {
+    awaitOrReturn: 'Await or return this async assertion.',
+};
+const JEST_MODULES = ['jest', '@jest/globals'];
+const VITEST_MODULES = ['vitest'];
+const JASMINE_MODULES = ['jasmine'];
+const JASMINE_DEPENDENCIES = ['jasmine', 'jasmine-core', 'jasmine-node', 'karma-jasmine'];
+const PLAYWRIGHT_MODULES = ['@playwright/test'];
+const TEST_FUNCTION_NAMES = new Set([
+    'it',
+    'it.only',
+    'it.skip',
+    'test',
+    'test.only',
+    'test.skip',
+    'specify',
+    'specify.only',
+    'specify.skip',
+    'vitest.it',
+    'vitest.it.only',
+    'vitest.it.skip',
+    'vitest.test',
+    'vitest.test.only',
+    'vitest.test.skip',
+    '@playwright.test.test',
+    '@playwright.test.test.only',
+    '@playwright.test.test.skip',
+]);
+const PLAYWRIGHT_ASYNC_MATCHERS = new Set([
+    'toBeAttached',
+    'toBeChecked',
+    'toBeDisabled',
+    'toBeEditable',
+    'toBeEmpty',
+    'toBeEnabled',
+    'toBeFocused',
+    'toBeHidden',
+    'toBeInViewport',
+    'toBeOK',
+    'toBeVisible',
+    'toContainClass',
+    'toContainText',
+    'toHaveAccessibleDescription',
+    'toHaveAccessibleName',
+    'toHaveAttribute',
+    'toHaveClass',
+    'toHaveCount',
+    'toHaveCSS',
+    'toHaveId',
+    'toHaveJSProperty',
+    'toHaveRole',
+    'toHaveScreenshot',
+    'toHaveText',
+    'toHaveTitle',
+    'toHaveURL',
+    'toHaveValue',
+    'toHaveValues',
+    'toMatchAriaSnapshot',
+]);
+exports.rule = {
+    meta: (0, generate_meta_js_1.generateMeta)(meta, { messages }),
+    create(context) {
+        const frameworks = {
+            jest: (0, module_js_1.importsOrDependsOnModule)(context, JEST_MODULES, ['jest']),
+            vitest: (0, module_js_1.importsOrDependsOnModule)(context, VITEST_MODULES, VITEST_MODULES),
+            jasmine: (0, module_js_1.importsOrDependsOnModule)(context, JASMINE_MODULES, JASMINE_DEPENDENCIES),
+            playwright: (0, module_js_1.importsOrDependsOnModule)(context, PLAYWRIGHT_MODULES, PLAYWRIGHT_MODULES),
+        };
+        if (!Object.values(frameworks).some(Boolean)) {
+            return {};
+        }
+        return {
+            'CallExpression:exit'(node) {
+                const call = node;
+                const callback = extractSupportedTestCallback(context, call);
+                if (!callback) {
+                    return;
+                }
+                if (callback.body.type !== 'BlockStatement') {
+                    return;
+                }
+                forEachExpressionStatement(callback.body, statement => {
+                    const assertionNode = getAsyncAssertionNode(context, statement.expression, frameworks);
+                    if (assertionNode) {
+                        context.report({
+                            node: assertionNode,
+                            messageId: 'awaitOrReturn',
+                        });
+                    }
+                });
+            },
+        };
+    },
+};
+function extractSupportedTestCallback(context, call) {
+    const mochaTestCase = (0, mocha_js_1.extractTestCase)(call);
+    if (mochaTestCase) {
+        return isFunctionArgument(mochaTestCase.callback) ? mochaTestCase.callback : null;
+    }
+    const name = (0, module_js_1.getFullyQualifiedName)(context, call.callee) ?? getDottedName(call.callee);
+    if (!name || !TEST_FUNCTION_NAMES.has(name)) {
+        return null;
+    }
+    for (const argument of call.arguments) {
+        if (isFunctionArgument(argument)) {
+            return argument;
+        }
+    }
+    return null;
+}
+function isFunctionArgument(node) {
+    return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
+}
+function forEachExpressionStatement(node, callback) {
+    switch (node.type) {
+        case 'ExpressionStatement':
+            callback(node);
+            return;
+        case 'BlockStatement':
+            node.body.forEach(child => forEachExpressionStatement(child, callback));
+            return;
+        case 'IfStatement':
+            forEachExpressionStatement(node.consequent, callback);
+            if (node.alternate) {
+                forEachExpressionStatement(node.alternate, callback);
+            }
+            return;
+        case 'ForStatement':
+        case 'ForInStatement':
+        case 'ForOfStatement':
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+        case 'LabeledStatement':
+        case 'WithStatement':
+            forEachExpressionStatement(node.body, callback);
+            return;
+        case 'SwitchStatement':
+            node.cases.forEach(switchCase => switchCase.consequent.forEach(child => forEachExpressionStatement(child, callback)));
+            return;
+        case 'TryStatement':
+            forEachExpressionStatement(node.block, callback);
+            if (node.handler) {
+                forEachExpressionStatement(node.handler.body, callback);
+            }
+            if (node.finalizer) {
+                forEachExpressionStatement(node.finalizer, callback);
+            }
+            return;
+    }
+}
+function getAsyncAssertionNode(context, expression, frameworks) {
+    const unwrapped = unwrapChainExpression(expression);
+    if (unwrapped.type === 'AwaitExpression') {
+        return null;
+    }
+    if (unwrapped.type !== 'CallExpression') {
+        return null;
+    }
+    return (getJestOrVitestAsyncNode(context, unwrapped, frameworks) ??
+        getJasmineAsyncNode(context, unwrapped, frameworks) ??
+        getPlaywrightAsyncNode(context, unwrapped, frameworks));
+}
+function getJestOrVitestAsyncNode(context, call, frameworks) {
+    if (!frameworks.jest && !frameworks.vitest) {
+        return null;
+    }
+    const chain = collectCallChain(call);
+    const asyncSegment = chain.find(segment => segment.name === 'resolves' || segment.name === 'rejects');
+    if (!asyncSegment) {
+        return null;
+    }
+    const root = getRootCall(call);
+    if (!root || !isExpectCall(context, root, frameworks, false)) {
+        return null;
+    }
+    return asyncSegment.node;
+}
+function getJasmineAsyncNode(context, call, frameworks) {
+    if (!frameworks.jasmine) {
+        return null;
+    }
+    const root = getRootCall(call);
+    if (root && isNamedCall(context, root, 'expectAsync', ['jasmine.expectAsync'])) {
+        return root.callee;
+    }
+    return null;
+}
+function getPlaywrightAsyncNode(context, call, frameworks) {
+    if (!frameworks.playwright || call.callee.type !== 'MemberExpression' || call.callee.computed) {
+        return null;
+    }
+    const matcher = call.callee.property;
+    if (!(0, ast_js_1.isIdentifier)(matcher) || !PLAYWRIGHT_ASYNC_MATCHERS.has(matcher.name)) {
+        return null;
+    }
+    const root = getRootCall(call);
+    if (root && isExpectCall(context, root, frameworks, true)) {
+        return matcher;
+    }
+    return null;
+}
+function collectCallChain(call) {
+    const chain = [];
+    let current = call;
+    while (current.type === 'CallExpression' || current.type === 'MemberExpression') {
+        if (current.type === 'CallExpression') {
+            current = unwrapChainExpression(current.callee);
+            continue;
+        }
+        if (current.computed || !(0, ast_js_1.isIdentifier)(current.property)) {
+            break;
+        }
+        chain.push({ name: current.property.name, node: current.property });
+        current = unwrapChainExpression(current.object);
+    }
+    return chain;
+}
+function getRootCall(call) {
+    let current = call;
+    while (current.type === 'CallExpression' || current.type === 'MemberExpression') {
+        if (current.type === 'CallExpression') {
+            const callee = unwrapChainExpression(current.callee);
+            if (callee.type !== 'MemberExpression' ||
+                (callee.object.type !== 'CallExpression' && callee.object.type !== 'MemberExpression')) {
+                return current;
+            }
+            current = callee;
+            continue;
+        }
+        current = unwrapChainExpression(current.object);
+    }
+    return null;
+}
+function isExpectCall(context, call, frameworks, playwrightOnly) {
+    const fqn = (0, module_js_1.getFullyQualifiedName)(context, call.callee);
+    if (fqn) {
+        return playwrightOnly
+            ? fqn === '@playwright.test.expect'
+            : fqn === 'expect' ||
+                fqn === '@jest.globals.expect' ||
+                fqn === 'vitest.expect' ||
+                (frameworks.jest && (0, ast_js_1.isIdentifier)(call.callee, 'expect')) ||
+                (frameworks.vitest && (0, ast_js_1.isIdentifier)(call.callee, 'expect'));
+    }
+    return !playwrightOnly && (0, ast_js_1.isIdentifier)(call.callee, 'expect');
+}
+function isNamedCall(context, call, globalName, importedNames) {
+    const fqn = (0, module_js_1.getFullyQualifiedName)(context, call.callee);
+    return importedNames.includes(fqn ?? '') || (0, ast_js_1.isIdentifier)(call.callee, globalName);
+}
+function unwrapChainExpression(node) {
+    return node.type === 'ChainExpression' ? node.expression : node;
+}
+function getDottedName(node) {
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type !== 'MemberExpression' || node.computed || !(0, ast_js_1.isIdentifier)(node.property)) {
+        return null;
+    }
+    const objectName = getDottedName(node.object);
+    return objectName ? `${objectName}.${node.property.name}` : null;
+}