eslint-plugin-sonarjs 4.0.2 → 4.1.0

package/cjs/helpers/dependency-manifests/resolvers/package-json.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageJsonManifestResolver = void 0;
+const files_js_1 = require("../../files.js");
+const index_js_1 = require("../index.js");
+const closest_js_1 = require("../../find-up/closest.js");
+const helpers_js_1 = require("./helpers.js");
+const parse_js_1 = require("../parse.js");
+const parsed_dependency_files_js_1 = require("../parsed-dependency-files.js");
+exports.packageJsonManifestResolver = {
+    resolve(dir, topDir, fileSystem) {
+        const packageJson = (0, helpers_js_1.getManifestFileInDir)(index_js_1.PACKAGE_JSON, dir, topDir, fileSystem);
+        if (!packageJson) {
+            return [];
+        }
+        let parsedPackageJson = (0, parsed_dependency_files_js_1.parsePackageJson)(packageJson) ?? {};
+        let catalogSource = undefined;
+        const closestParent = findClosestParentPackageJsonWithCatalogs(dir, topDir, fileSystem);
+        if (closestParent) {
+            // If the closest parent package.json has catalogs defined, we use it as the catalog source for resolving catalog references.
+            const workspaces = Array.isArray(closestParent.workspaces)
+                ? undefined
+                : closestParent.workspaces;
+            catalogSource = {
+                catalog: workspaces?.catalog ?? closestParent.catalog,
+                catalogs: workspaces?.catalogs ?? closestParent.catalogs,
+            };
+        }
+        else {
+            // No parent package.json with catalogs found, we check if there's a pnpm workspace file that we can use as a catalog source.
+            const pnpmWorkspaceFile = closest_js_1.closestPatternCache
+                .get(index_js_1.PNPM_WORKSPACE_YAML, fileSystem)
+                .get(topDir)
+                .get(dir);
+            const parsedPnpmWorkspace = pnpmWorkspaceFile
+                ? (0, parsed_dependency_files_js_1.parsePnpmWorkspace)(pnpmWorkspaceFile)
+                : undefined;
+            if (parsedPnpmWorkspace) {
+                parsedPackageJson = injectWorkspacePackages(parsedPackageJson, parsedPnpmWorkspace);
+                catalogSource = parsedPnpmWorkspace;
+            }
+        }
+        parsedPackageJson = resolveCatalogReferences(parsedPackageJson, catalogSource);
+        // Match Node's resolution: explicit "module" is ESM, anything else (including
+        // missing "type") is CommonJS.
+        const moduleType = parsedPackageJson.type === 'module' ? 'module' : 'commonjs';
+        return [
+            {
+                type: 'package-json',
+                manifest: parsedPackageJson,
+                dependencies: buildDependencies(parsedPackageJson),
+                moduleType,
+            },
+        ];
+    },
+};
+function buildDependencies(packageJson) {
+    const dependencies = new Map();
+    const fieldsToVisit = [
+        'name',
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+        '_moduleAliases',
+        'workspaces',
+    ];
+    for (const field of fieldsToVisit) {
+        if (!packageJson[field]) {
+            continue;
+        }
+        if (field === 'name') {
+            (0, parse_js_1.addDependencies)(dependencies, { [packageJson[field]]: '*' });
+            continue;
+        }
+        if (field === 'workspaces') {
+            (0, parse_js_1.addDependenciesArray)(dependencies, Array.isArray(packageJson[field])
+                ? packageJson[field]
+                : (packageJson[field]?.packages ?? []));
+            continue;
+        }
+        (0, parse_js_1.addDependencies)(dependencies, packageJson[field]);
+    }
+    return dependencies;
+}
+function resolveCatalogReferences(packageJson, catalogSource) {
+    const depFields = [
+        'dependencies',
+        'devDependencies',
+        'peerDependencies',
+        'optionalDependencies',
+    ];
+    const modifiedPackageJson = { ...packageJson };
+    for (const field of depFields) {
+        const deps = packageJson[field];
+        if (!deps) {
+            continue;
+        }
+        const resolvedDeps = {};
+        for (const [depName, depVersion] of Object.entries(deps)) {
+            if (typeof depVersion === 'string' && depVersion.startsWith('catalog:')) {
+                const catalogName = depVersion.slice('catalog:'.length).trim() || 'default';
+                const resolvedDep = catalogName === 'default'
+                    ? catalogSource?.catalog?.[depName]
+                    : catalogSource?.catalogs?.[catalogName]?.[depName];
+                resolvedDeps[depName] = resolvedDep ?? depVersion;
+                !resolvedDep &&
+                    console.debug(`Dependency "${depName}" could not be resolved for catalog "${catalogName}"`);
+            }
+            else {
+                resolvedDeps[depName] = depVersion ?? '';
+            }
+        }
+        modifiedPackageJson[field] = resolvedDeps;
+    }
+    return modifiedPackageJson;
+}
+function injectWorkspacePackages(packageJson, pnpmWorkspace) {
+    if (!pnpmWorkspace.packages || packageJson.workspaces) {
+        return packageJson;
+    }
+    return {
+        ...packageJson,
+        workspaces: pnpmWorkspace.packages,
+    };
+}
+/**
+ * Find the closest parent package.json with catalogs defined.
+ * @param dir Directory to start the search from
+ * @param topDir Top directory to stop the search at
+ * @param fileSystem Filesystem to use for the search
+ * @returns The closest parent package.json with catalogs, or undefined if no package.json with catalogs is found
+ */
+function findClosestParentPackageJsonWithCatalogs(dir, topDir, fileSystem) {
+    if (dir === topDir) {
+        // No point in searching for parent package.json if we're already at the top directory.
+        return undefined;
+    }
+    let currentDir = (0, helpers_js_1.getParentDirPath)(dir);
+    const cache = closest_js_1.closestPatternCache.get(index_js_1.PACKAGE_JSON, fileSystem).get(topDir);
+    while (currentDir !== null) {
+        const file = cache.get(currentDir);
+        if (!file) {
+            return undefined;
+        }
+        const parsed = (0, parsed_dependency_files_js_1.parsePackageJson)(file);
+        if (parsed && hasCatalogs(parsed)) {
+            return parsed;
+        }
+        const fileDir = (0, files_js_1.dirnamePath)(file.filePath);
+        if (fileDir === topDir) {
+            return undefined;
+        }
+        currentDir = (0, helpers_js_1.getParentDirPath)(fileDir);
+    }
+    return undefined;
+}
+function hasCatalogs(packageJson) {
+    if (packageJson.catalog || packageJson.catalogs) {
+        return true;
+    }
+    const { workspaces } = packageJson;
+    if (workspaces && !Array.isArray(workspaces)) {
+        return !!(workspaces.catalog || workspaces.catalogs);
+    }
+    return false;
+}

package/cjs/helpers/dependency-manifests/resolvers/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFINITELY_TYPED = void 0;
+exports.DEFINITELY_TYPED = '@types/';

package/cjs/helpers/entropy.js

@@ -1,11 +1,13 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shannonEntropy = shannonEntropy;
 /*
  * 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
@@ -15,8 +17,6 @@
  * You should have received a copy of the Sonar Source-Available License
  * along with this program; if not, see https://sonarsource.com/license/ssal/
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.shannonEntropy = shannonEntropy;
 function shannonEntropy(str) {
     if (!str) {
         return 0;

package/cjs/helpers/files.js

@@ -5,17 +5,20 @@ exports.stripBOM = stripBOM;
 exports.normalizePath = normalizePath;
 exports.normalizeToAbsolutePath = normalizeToAbsolutePath;
 exports.isRoot = isRoot;
+exports.assertNestedPath = assertNestedPath;
+exports.getPathRoot = getPathRoot;
 exports.isAbsolutePath = isAbsolutePath;
 exports.dirnamePath = dirnamePath;
+exports.relativeToAncestorPath = relativeToAncestorPath;
 exports.joinPaths = joinPaths;
 exports.basenamePath = basenamePath;
 /*
  * 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
@@ -35,6 +38,7 @@ exports.ROOT_PATH = '/';
  * Byte Order Marker
  */
 const BOM_BYTE = 0xfeff;
+const isWindows = process.platform === 'win32';
 /**
  * Removes any Byte Order Marker (BOM) from a string's head
  *
@@ -49,7 +53,6 @@ function stripBOM(str) {
     }
     return str;
 }
-const isWindows = process.platform === 'win32';
 /**
  * Normalizes a path to Unix format (forward slashes).
  * For absolute paths on Windows, resolves them to ensure they have a drive letter.
@@ -95,6 +98,25 @@ function isParseResultRoot(result) {
 function isRoot(file) {
     return isParseResultRoot((0, win32_1.parse)(file)) || isParseResultRoot((0, posix_1.parse)(file));
 }
+function assertNestedPath(from, topDir) {
+    const fromSanitized = from.endsWith('/') ? from : from + '/';
+    const topDirSanitized = topDir.endsWith('/') ? topDir : topDir + '/';
+    if (!fromSanitized.startsWith(topDirSanitized)) {
+        throw new Error(`"${from}" is not nested under topDir "${topDir}"`);
+    }
+}
+/**
+ * Returns the filesystem root that contains the given absolute path.
+ * Examples: '/a/b' -> '/', 'C:/a/b' -> 'C:/', 'D:/foo' -> 'D:/'.
+ * Used as a cross-platform "no upper bound" sentinel for find-up callers.
+ */
+function getPathRoot(filePath) {
+    const winRoot = (0, win32_1.parse)(filePath).root;
+    if (winRoot) {
+        return toUnixPath(winRoot);
+    }
+    return exports.ROOT_PATH;
+}
 function isAbsolutePath(path) {
     // Check for Windows drive letter (e.g., 'c:', 'C:', 'D:')
     // Node's isAbsolute considers 'c:' as relative (drive-relative), but we treat it as absolute
@@ -112,6 +134,13 @@ function isAbsolutePath(path) {
 function dirnamePath(filePath) {
     return (0, posix_1.dirname)(filePath);
 }
+function relativeToAncestorPath(filePath, topDir) {
+    const topDirPrefix = topDir.endsWith('/') ? topDir : `${topDir}/`;
+    if (filePath === topDir) {
+        return '';
+    }
+    return filePath.startsWith(topDirPrefix) ? filePath.slice(topDirPrefix.length) : undefined;
+}
 /**
  * Type-safe path join that preserves the NormalizedAbsolutePath brand.
  * Joins path segments using posix separators.

package/cjs/helpers/find-up/all-in-parent-dirs.js

@@ -18,6 +18,7 @@ exports.patternInParentsCache = new cache_js_1.ComputedCache((pattern, filesyste
                 // handle path.dirname returning "." in windows
                 return [];
             }
+            (0, files_js_1.assertNestedPath)(from, topDir);
             if (!(0, files_js_1.isRoot)(from) && from !== topDir) {
                 const parent = (0, files_js_1.dirnamePath)(from);
                 return [...readDir.get(from), ...newCache.get(parent)];

package/cjs/helpers/find-up/closest.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.closestPatternCache = 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
@@ -34,6 +34,7 @@ exports.closestPatternCache = new cache_js_1.ComputedCache((pattern, filesystem
                 // handle path.dirname returning "." in windows
                 return undefined;
             }
+            (0, files_js_1.assertNestedPath)(from, topDir);
             const matchingFiles = readDir.get(from);
             if (matchingFiles.length > 0) {
                 return matchingFiles[0];

package/cjs/helpers/find-up/find-minimatch.js

@@ -28,8 +28,8 @@ exports.MinimatchCache = new cache_js_1.ComputedCache((matcher, filesystem = nod
                     }
                     if (stats.isFile()) {
                         files.push({
-                            path: fullEntryPath,
-                            content: filesystem.readFileSync(fullEntryPath),
+                            filePath: fullEntryPath,
+                            fileContent: filesystem.readFileSync(fullEntryPath, 'utf8'),
                         });
                     }
                 }

package/cjs/helpers/generate-meta.js

@@ -20,7 +20,7 @@ function generateMeta(sonarMeta, ruleMeta) {
     };
     // If rules contains default options, we will augment them with our defaults.
     if (ruleMeta?.defaultOptions) {
-        metadata.defaultOptions = (0, lodash_merge_1.default)(ruleMeta.defaultOptions, sonarMeta.meta.defaultOptions);
+        metadata.defaultOptions = (0, lodash_merge_1.default)([], ruleMeta.defaultOptions, sonarMeta.meta.defaultOptions);
     }
     // RSPEC metadata can include fixable also for rules with suggestions, because RSPEC doesn't differentiate between fix
     // and suggestion like ESLint does. That's why we set fixable using ruleMeta

package/cjs/helpers/internal-metrics.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toInternalMetricsSettings = toInternalMetricsSettings;
+exports.getInternalMetricsSink = getInternalMetricsSink;
+const SONAR_INTERNAL_SETTINGS_KEY = 'sonarInternal';
+const SONAR_INTERNAL_METRICS_SINK_KEY = 'metricsSink';
+function toInternalMetricsSettings(metricsSink) {
+    return {
+        [SONAR_INTERNAL_SETTINGS_KEY]: {
+            [SONAR_INTERNAL_METRICS_SINK_KEY]: metricsSink,
+        },
+    };
+}
+function getInternalMetricsSink(settings) {
+    if (!settings || typeof settings !== 'object') {
+        return undefined;
+    }
+    const sonarInternal = settings[SONAR_INTERNAL_SETTINGS_KEY];
+    if (!sonarInternal || typeof sonarInternal !== 'object') {
+        return undefined;
+    }
+    const metricsSink = sonarInternal[SONAR_INTERNAL_METRICS_SINK_KEY];
+    if (!metricsSink || typeof metricsSink !== 'object') {
+        return undefined;
+    }
+    return metricsSink;
+}

package/cjs/helpers/mocha-style-test-frameworks.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAYWRIGHT_DESCRIBE_FOCUS_MODIFIER = exports.PLAYWRIGHT_DESCRIBE_MODIFIERS = exports.PLAYWRIGHT_TEST_MODIFIERS = exports.SUITE_FUNCTION_NAMES = exports.TEST_FUNCTION_NAMES = exports.SUPPORTED_TEST_FRAMEWORKS = void 0;
+exports.isMochaTestConstruct = isMochaTestConstruct;
+exports.isConcreteMochaTestModifier = isConcreteMochaTestModifier;
+exports.getMochaCalleeParts = getMochaCalleeParts;
+exports.getMochaConstructName = getMochaConstructName;
+exports.hasCallback = hasCallback;
+exports.getStaticTitle = getStaticTitle;
+exports.getPlaywrightTestQualifiers = getPlaywrightTestQualifiers;
+exports.getPlaywrightDescribeQualifiers = getPlaywrightDescribeQualifiers;
+const ast_js_1 = require("./ast.js");
+const module_js_1 = require("./module.js");
+exports.SUPPORTED_TEST_FRAMEWORKS = ['jest', 'mocha', 'vitest', '@playwright/test'];
+const MOCHA_STYLE_TEST_FRAMEWORKS = new Set(['jest', 'mocha', 'vitest']);
+exports.TEST_FUNCTION_NAMES = ['it', 'specify', 'test'];
+exports.SUITE_FUNCTION_NAMES = ['describe', 'context', 'suite'];
+const COMMON_MOCHA_TEST_MODIFIERS = new Set(['only', 'concurrent']);
+const JEST_TEST_MODIFIERS = new Set(['failing']);
+const VITEST_TEST_MODIFIERS = new Set(['sequential']);
+const PLAYWRIGHT_TEST_FQN = '@playwright.test.test';
+exports.PLAYWRIGHT_TEST_MODIFIERS = new Set(['only', 'fail']);
+exports.PLAYWRIGHT_DESCRIBE_MODIFIERS = new Set(['parallel', 'serial']);
+exports.PLAYWRIGHT_DESCRIBE_FOCUS_MODIFIER = 'only';
+function isMochaTestConstruct(context, node, constructs) {
+    const calleeParts = getMochaCalleeParts(node.callee);
+    if (calleeParts === undefined) {
+        return false;
+    }
+    const constructName = getMochaConstructName(context, calleeParts.base);
+    if (constructName === undefined || !constructs.includes(constructName)) {
+        return false;
+    }
+    return calleeParts.modifiers.every(modifier => isConcreteMochaTestModifier(context, modifier));
+}
+function isConcreteMochaTestModifier(context, modifier) {
+    return (COMMON_MOCHA_TEST_MODIFIERS.has(modifier) ||
+        (JEST_TEST_MODIFIERS.has(modifier) && isTestFrameworkActive(context, 'jest')) ||
+        (VITEST_TEST_MODIFIERS.has(modifier) && isTestFrameworkActive(context, 'vitest')));
+}
+function isTestFrameworkActive(context, framework) {
+    return (0, module_js_1.importsOrDependsOnModule)(context, [framework], [framework]);
+}
+function getMochaCalleeParts(node) {
+    const modifiers = [];
+    let current = node;
+    while (true) {
+        if (current.type === 'CallExpression') {
+            current = current.callee;
+        }
+        else if (isQualifyingMember(current)) {
+            modifiers.unshift(current.property.name);
+            current = current.object;
+        }
+        else {
+            break;
+        }
+    }
+    return current.type === 'Identifier' ? { base: current, modifiers } : undefined;
+}
+function collectMemberChain(node) {
+    const qualifiers = [];
+    let current = node;
+    while (isQualifyingMember(current)) {
+        qualifiers.unshift(current.property.name);
+        current = current.object;
+    }
+    return { base: current, qualifiers };
+}
+function isQualifyingMember(node) {
+    return node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property);
+}
+function getMochaConstructName(context, identifier) {
+    const variable = (0, ast_js_1.getVariableFromScope)(context.sourceCode.getScope(identifier), identifier.name);
+    if (variable?.defs.some(def => def.type === 'ImportBinding' || isSupportedRequireBinding(def.node))) {
+        return getMochaConstructNameFromFqn((0, module_js_1.getFullyQualifiedName)(context, identifier));
+    }
+    return variable == null || variable.defs.length === 0 ? identifier.name : undefined;
+}
+function getMochaConstructNameFromFqn(fqn) {
+    const parts = fqn?.split('.');
+    if (parts?.length !== 2) {
+        return undefined;
+    }
+    const [framework, constructName] = parts;
+    return MOCHA_STYLE_TEST_FRAMEWORKS.has(framework) ? constructName : undefined;
+}
+function isSupportedRequireBinding(node) {
+    if (node.type !== 'VariableDeclarator' || node.init == null) {
+        return false;
+    }
+    const requireCall = getRequireCall(node.init);
+    const moduleName = requireCall?.arguments[0];
+    return (moduleName?.type === 'Literal' &&
+        typeof moduleName.value === 'string' &&
+        exports.SUPPORTED_TEST_FRAMEWORKS.includes(moduleName.value));
+}
+function getRequireCall(node) {
+    if (isRequireCall(node)) {
+        return node;
+    }
+    if (node.type === 'MemberExpression') {
+        return getRequireCall(node.object);
+    }
+    return undefined;
+}
+function isRequireCall(node) {
+    return (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        node.callee.name === 'require');
+}
+function hasCallback(node) {
+    return node.arguments.some(argument => ast_js_1.FUNCTION_NODES.includes(argument.type));
+}
+function getStaticTitle(node) {
+    if ((0, ast_js_1.isStringLiteral)(node)) {
+        return node.value;
+    }
+    if ((0, ast_js_1.isStaticTemplateLiteral)(node)) {
+        const value = node.quasis[0].value;
+        return value.cooked ?? value.raw;
+    }
+    return undefined;
+}
+function getPlaywrightTestQualifiers(context, node) {
+    const { base, qualifiers } = collectMemberChain(node);
+    return (0, module_js_1.getFullyQualifiedName)(context, base) === PLAYWRIGHT_TEST_FQN ? qualifiers : undefined;
+}
+function getPlaywrightDescribeQualifiers(node) {
+    const { base, qualifiers } = collectMemberChain(node);
+    return (0, ast_js_1.isIdentifier)(base, 'test') ? qualifiers : undefined;
+}

package/cjs/helpers/mocha.js

@@ -4,17 +4,18 @@ exports.isTestConstruct = isTestConstruct;
 exports.extractTestCase = extractTestCase;
 exports.isTestCase = isTestCase;
 exports.isDescribeCase = isDescribeCase;
+exports.isLifecycleHook = isLifecycleHook;
 const ast_js_1 = require("./ast.js");
-const TEST_CONSTRUCTS = [
-    'describe',
-    'context',
-    'it',
-    'specify',
+const LIFECYCLE_HOOK_CONSTRUCTS = [
     'before',
     'after',
+    'beforeAll',
+    'afterAll',
     'beforeEach',
     'afterEach',
 ];
+const TEST_CONSTRUCTS = ['describe', 'context', 'it', 'specify', ...LIFECYCLE_HOOK_CONSTRUCTS];
+const TEST_CASE_CONSTRUCTS = ['it', 'specify', 'test'];
 function isTestConstruct(node, constructs = TEST_CONSTRUCTS) {
     return constructs.some(construct => {
         return (node.type === 'CallExpression' &&
@@ -41,7 +42,7 @@ function extractTestCase(node) {
  * @returns
  */
 function isTestCase(node) {
-    return isTestConstruct(node, ['it', 'specify']);
+    return isTestConstruct(node, TEST_CASE_CONSTRUCTS);
 }
 /**
  * returns true if the node is a describe block
@@ -50,5 +51,14 @@ function isTestCase(node) {
  * @returns
  */
 function isDescribeCase(node) {
-    return isTestConstruct(node, ['describe']);
+    return isTestConstruct(node, ['describe', 'context']);
+}
+/**
+ * returns true if the node is a lifecycle hook
+ *
+ * @param node
+ * @returns
+ */
+function isLifecycleHook(node) {
+    return isTestConstruct(node, LIFECYCLE_HOOK_CONSTRUCTS);
 }

package/cjs/helpers/module-ts.js

@@ -6,11 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFullyQualifiedNameTS = getFullyQualifiedNameTS;
 /*
  * 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
@@ -26,7 +26,12 @@ const module_js_1 = require("./module.js");
 function getFullyQualifiedNameTS(services, rootNode) {
     const result = [];
     let node = rootNode;
+    const visitedNodes = new Set();
     while (node) {
+        if (visitedNodes.has(node)) {
+            return null;
+        }
+        visitedNodes.add(node);
         switch (node.kind) {
             case typescript_1.default.SyntaxKind.CallExpression: {
                 const callExpressionNode = node;