eslint-plugin-sonarjs 1.0.4-alpha.2 → 1.0.4

package/lib/package.json

@@ -0,0 +1,106 @@
+{
+    "name": "eslint-plugin-sonarjs",
+    "version": "1.0.4",
+    "description": "SonarJS rules for ESLint",
+    "main": "lib/src/index.js",
+    "types": "lib/src/index.d.ts",
+    "repository": "git@github.com:SonarSource/eslint-plugin-sonarjs.git",
+    "license": "LGPL-3.0-only",
+    "keywords": [
+        "sonarjs",
+        "eslint",
+        "eslintplugin"
+    ],
+    "bugs": {
+        "url": "https://github.com/SonarSource/eslint-plugin-sonarjs/issues"
+    },
+    "homepage": "https://github.com/SonarSource/eslint-plugin-sonarjs",
+    "engines": {
+        "node": ">=16"
+    },
+    "files": [
+        "lib",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "rimraf lib && tsc -d -p src",
+        "test": "jest",
+        "ruling": "ts-node --files ruling/index.ts",
+        "precommit": "pretty-quick --staged",
+        "prepare": "husky install .husky",
+        "prepack": "npm run build",
+        "format": "prettier --write .",
+        "check-format": "prettier --list-different ."
+    },
+    "peerDependencies": {
+        "eslint": "^8.0.0 || ^9.0.0"
+    },
+    "devDependencies": {
+        "@babel/core": "7.24.4",
+        "@babel/eslint-parser": "7.24.1",
+        "@babel/plugin-proposal-export-default-from": "7.24.1",
+        "@babel/plugin-proposal-function-bind": "7.24.1",
+        "@babel/preset-env": "7.24.4",
+        "@babel/preset-flow": "7.24.1",
+        "@babel/preset-react": "7.24.1",
+        "@types/eslint": "8.56.10",
+        "@types/eslint-ruling": "npm:@types/eslint@^8.56.10",
+        "@types/jest": "29.5.12",
+        "@types/lodash": "4.17.0",
+        "@types/minimist": "1.2.5",
+        "@types/node": "20.12.7",
+        "@typescript-eslint/parser": "7.7.1",
+        "@typescript-eslint/rule-tester": "7.7.1",
+        "@typescript-eslint/utils": "7.7.1",
+        "eslint": "8.57.0",
+        "eslint-config-prettier": "9.1.0",
+        "eslint-plugin-import": "2.29.1",
+        "eslint-plugin-notice": "0.9.10",
+        "eslint-plugin-sonarjs": "0.25.1",
+        "eslint-ruling": "npm:eslint@8.57.0",
+        "husky": "9.0.11",
+        "jest": "29.7.0",
+        "jest-sonar-reporter": "2.0.0",
+        "lodash": "4.17.21",
+        "minimist": "1.2.8",
+        "prettier": "3.2.5",
+        "pretty-quick": "4.0.0",
+        "rimraf": "5.0.5",
+        "semver": "^7.6.0",
+        "ts-jest": "29.1.2",
+        "ts-node": "10.9.2",
+        "typescript": "5.4.5"
+    },
+    "prettier": {
+        "printWidth": 100,
+        "trailingComma": "all",
+        "singleQuote": true,
+        "arrowParens": "avoid",
+        "endOfLine": "lf"
+    },
+    "jest": {
+        "roots": [
+            "tests",
+            "src"
+        ],
+        "collectCoverageFrom": [
+            "src/**/*.ts"
+        ],
+        "moduleFileExtensions": [
+            "ts",
+            "js",
+            "json"
+        ],
+        "transform": {
+            "^.+\\.ts$": [
+                "ts-jest",
+                {
+                    "babelConfig": false
+                }
+            ]
+        },
+        "testMatch": [
+            "<rootDir>/tests/**/*.test.ts"
+        ]
+    }
+}

package/lib/src/index.d.ts

@@ -0,0 +1,101 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { FlatConfig } from '@typescript-eslint/utils/ts-eslint';
+export declare const rules: {
+    'cognitive-complexity': TSESLint.RuleModule<string, (number | "sonar-runtime" | "metric")[], TSESLint.RuleListener>;
+    'elseif-without-else': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'max-switch-cases': TSESLint.RuleModule<string, [number], TSESLint.RuleListener>;
+    'no-all-duplicated-branches': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-collapsible-if': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-collection-size-mischeck': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-duplicate-string': TSESLint.RuleModule<string, [{
+        threshold?: number | undefined;
+        ignoreStrings?: string | undefined;
+    } | undefined, "sonar-runtime"] | [{
+        threshold?: number | undefined;
+        ignoreStrings?: string | undefined;
+    } | undefined], TSESLint.RuleListener>;
+    'no-duplicated-branches': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-element-overwrite': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-empty-collection': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-extra-arguments': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-gratuitous-expressions': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-identical-conditions': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-identical-expressions': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-identical-functions': TSESLint.RuleModule<string, (number | "sonar-runtime")[], TSESLint.RuleListener>;
+    'no-ignored-return': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-inverted-boolean-check': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-nested-switch': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-nested-template-literals': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-one-iteration-loop': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-redundant-boolean': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-redundant-jump': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-same-line-conditional': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-small-switch': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-unused-collection': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-use-of-empty-return-value': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'no-useless-catch': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'non-existent-operator': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'prefer-immediate-return': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'prefer-object-literal': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'prefer-single-boolean-return': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    'prefer-while': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+};
+export declare const configs: {
+    recommended: FlatConfig.Config;
+    'recommended-legacy': TSESLint.ClassicConfig.Config;
+};
+export declare const meta: {
+    name: string;
+    version: string;
+};
+declare const _default: {
+    rules: {
+        'cognitive-complexity': TSESLint.RuleModule<string, (number | "sonar-runtime" | "metric")[], TSESLint.RuleListener>;
+        'elseif-without-else': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'max-switch-cases': TSESLint.RuleModule<string, [number], TSESLint.RuleListener>;
+        'no-all-duplicated-branches': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-collapsible-if': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-collection-size-mischeck': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-duplicate-string': TSESLint.RuleModule<string, [{
+            threshold?: number | undefined;
+            ignoreStrings?: string | undefined;
+        } | undefined, "sonar-runtime"] | [{
+            threshold?: number | undefined;
+            ignoreStrings?: string | undefined;
+        } | undefined], TSESLint.RuleListener>;
+        'no-duplicated-branches': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-element-overwrite': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-empty-collection': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-extra-arguments': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-gratuitous-expressions': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-identical-conditions': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-identical-expressions': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-identical-functions': TSESLint.RuleModule<string, (number | "sonar-runtime")[], TSESLint.RuleListener>;
+        'no-ignored-return': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-inverted-boolean-check': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-nested-switch': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-nested-template-literals': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-one-iteration-loop': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-redundant-boolean': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-redundant-jump': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-same-line-conditional': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-small-switch': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-unused-collection': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-use-of-empty-return-value': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'no-useless-catch': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'non-existent-operator': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'prefer-immediate-return': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'prefer-object-literal': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'prefer-single-boolean-return': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+        'prefer-while': TSESLint.RuleModule<string, string[], TSESLint.RuleListener>;
+    };
+    configs: {
+        recommended: FlatConfig.Config;
+        'recommended-legacy': TSESLint.ClassicConfig.Config;
+    };
+    meta: {
+        name: string;
+        version: string;
+    };
+};
+export default _default;

package/lib/src/index.js

@@ -0,0 +1,117 @@
+"use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meta = exports.configs = exports.rules = void 0;
+const cognitiveComplexity = __importStar(require("./rules/cognitive-complexity"));
+const elseifWithoutElse = __importStar(require("./rules/elseif-without-else"));
+const maxSwitchCases = __importStar(require("./rules/max-switch-cases"));
+const noAllDuplicatedBranches = __importStar(require("./rules/no-all-duplicated-branches"));
+const noCollapsibleIf = __importStar(require("./rules/no-collapsible-if"));
+const noCollectionSizeMischeck = __importStar(require("./rules/no-collection-size-mischeck"));
+const noDuplicateString = __importStar(require("./rules/no-duplicate-string"));
+const noDuplicatedBranches = __importStar(require("./rules/no-duplicated-branches"));
+const noElementOverwrite = __importStar(require("./rules/no-element-overwrite"));
+const noEmptyCollection = __importStar(require("./rules/no-empty-collection"));
+const noExtraArguments = __importStar(require("./rules/no-extra-arguments"));
+const noGratuitousExpressions = __importStar(require("./rules/no-gratuitous-expressions"));
+const noIdenticalConditions = __importStar(require("./rules/no-identical-conditions"));
+const noIdenticalExpressions = __importStar(require("./rules/no-identical-expressions"));
+const noIdenticalFunctions = __importStar(require("./rules/no-identical-functions"));
+const noIgnoredReturn = __importStar(require("./rules/no-ignored-return"));
+const noInvertedBooleanCheck = __importStar(require("./rules/no-inverted-boolean-check"));
+const noNestedSwitch = __importStar(require("./rules/no-nested-switch"));
+const noNestedTemplateLiterals = __importStar(require("./rules/no-nested-template-literals"));
+const noOneIterationLoop = __importStar(require("./rules/no-one-iteration-loop"));
+const noRedundantBoolean = __importStar(require("./rules/no-redundant-boolean"));
+const noRedundantJump = __importStar(require("./rules/no-redundant-jump"));
+const noSameLineConditional = __importStar(require("./rules/no-same-line-conditional"));
+const noSmallSwitch = __importStar(require("./rules/no-small-switch"));
+const noUnusedCollection = __importStar(require("./rules/no-unused-collection"));
+const noUseOfEmptyReturnValue = __importStar(require("./rules/no-use-of-empty-return-value"));
+const noUselessCatch = __importStar(require("./rules/no-useless-catch"));
+const nonExistentOperator = __importStar(require("./rules/non-existent-operator"));
+const preferImmediateReturn = __importStar(require("./rules/prefer-immediate-return"));
+const preferObjectLiteral = __importStar(require("./rules/prefer-object-literal"));
+const preferSingleBooleanReturn = __importStar(require("./rules/prefer-single-boolean-return"));
+const preferWhile = __importStar(require("./rules/prefer-while"));
+const package_json_1 = require("../package.json");
+exports.rules = {
+    'cognitive-complexity': cognitiveComplexity,
+    'elseif-without-else': elseifWithoutElse,
+    'max-switch-cases': maxSwitchCases,
+    'no-all-duplicated-branches': noAllDuplicatedBranches,
+    'no-collapsible-if': noCollapsibleIf,
+    'no-collection-size-mischeck': noCollectionSizeMischeck,
+    'no-duplicate-string': noDuplicateString,
+    'no-duplicated-branches': noDuplicatedBranches,
+    'no-element-overwrite': noElementOverwrite,
+    'no-empty-collection': noEmptyCollection,
+    'no-extra-arguments': noExtraArguments,
+    'no-gratuitous-expressions': noGratuitousExpressions,
+    'no-identical-conditions': noIdenticalConditions,
+    'no-identical-expressions': noIdenticalExpressions,
+    'no-identical-functions': noIdenticalFunctions,
+    'no-ignored-return': noIgnoredReturn,
+    'no-inverted-boolean-check': noInvertedBooleanCheck,
+    'no-nested-switch': noNestedSwitch,
+    'no-nested-template-literals': noNestedTemplateLiterals,
+    'no-one-iteration-loop': noOneIterationLoop,
+    'no-redundant-boolean': noRedundantBoolean,
+    'no-redundant-jump': noRedundantJump,
+    'no-same-line-conditional': noSameLineConditional,
+    'no-small-switch': noSmallSwitch,
+    'no-unused-collection': noUnusedCollection,
+    'no-use-of-empty-return-value': noUseOfEmptyReturnValue,
+    'no-useless-catch': noUselessCatch,
+    'non-existent-operator': nonExistentOperator,
+    'prefer-immediate-return': preferImmediateReturn,
+    'prefer-object-literal': preferObjectLiteral,
+    'prefer-single-boolean-return': preferSingleBooleanReturn,
+    'prefer-while': preferWhile,
+};
+const recommendedLegacyConfig = { plugins: ['sonarjs'], rules: {} };
+const recommendedConfig = {
+    plugins: {
+        sonarjs: {
+            rules: exports.rules,
+        },
+    },
+    rules: {},
+};
+for (const key in exports.rules) {
+    const rule = exports.rules[key];
+    const recommended = rule.meta.docs?.recommended;
+    recommendedConfig.rules[`sonarjs/${key}`] = recommended === undefined ? 'off' : 'error';
+}
+recommendedLegacyConfig.rules = recommendedConfig.rules;
+exports.configs = {
+    recommended: recommendedConfig,
+    'recommended-legacy': recommendedLegacyConfig,
+};
+exports.meta = {
+    name: package_json_1.name,
+    version: package_json_1.version,
+};
+exports.default = { rules: exports.rules, configs: exports.configs, meta: exports.meta };

package/lib/src/rules/cognitive-complexity.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<string, (number | 'metric' | 'sonar-runtime')[]>;
+export = rule;

package/lib/src/rules/cognitive-complexity.js

@@ -0,0 +1,273 @@
+"use strict";
+/*
+ * eslint-plugin-sonarjs
+ * Copyright (C) 2018-2021 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+// https://sonarsource.github.io/rspec/#/rspec/S3776
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const nodes_1 = require("../utils/nodes");
+const locations_1 = require("../utils/locations");
+const docs_url_1 = __importDefault(require("../utils/docs-url"));
+const jsx_1 = require("../utils/jsx");
+const DEFAULT_THRESHOLD = 15;
+const message = 'Refactor this function to reduce its Cognitive Complexity from {{complexityAmount}} to the {{threshold}} allowed.';
+const rule = {
+    defaultOptions: [],
+    meta: {
+        messages: {
+            refactorFunction: message,
+            sonarRuntime: '{{sonarRuntimeData}}',
+            fileComplexity: '{{complexityAmount}}',
+        },
+        type: 'suggestion',
+        docs: {
+            description: 'Cognitive Complexity of functions should not be too high',
+            url: (0, docs_url_1.default)(__filename),
+        },
+        schema: [
+            { type: 'integer', minimum: 0 },
+            {
+                // internal parameter
+                type: 'string',
+                enum: ['sonar-runtime', 'metric'],
+            },
+        ],
+    },
+    create(context) {
+        const { options } = context;
+        /** Complexity threshold */
+        const threshold = typeof options[0] === 'number' ? options[0] : DEFAULT_THRESHOLD;
+        /** Indicator if the file complexity should be reported */
+        const isFileComplexity = context.options.includes('metric');
+        /** Set of already considered (with already computed complexity) logical expressions */
+        const consideredLogicalExpressions = new Set();
+        /** Stack of scopes that are either functions or the program */
+        const scopes = [];
+        return {
+            ':function': (node) => {
+                onEnterFunction(node);
+            },
+            ':function:exit'(node) {
+                onLeaveFunction(node);
+            },
+            '*'(node) {
+                if (scopes[scopes.length - 1]?.nestingNodes.has(node)) {
+                    scopes[scopes.length - 1].nestingLevel++;
+                }
+            },
+            '*:exit'(node) {
+                if (scopes[scopes.length - 1]?.nestingNodes.has(node)) {
+                    scopes[scopes.length - 1].nestingLevel--;
+                    scopes[scopes.length - 1].nestingNodes.delete(node);
+                }
+            },
+            Program(node) {
+                scopes.push({
+                    node,
+                    nestingLevel: 0,
+                    nestingNodes: new Set(),
+                    complexityPoints: [],
+                });
+            },
+            'Program:exit'(node) {
+                const programComplexity = scopes.pop();
+                if (isFileComplexity) {
+                    // value from the message will be saved in SonarQube as file complexity metric
+                    context.report({
+                        node,
+                        messageId: 'fileComplexity',
+                        data: {
+                            complexityAmount: programComplexity.complexityPoints.reduce((acc, cur) => acc + cur.complexity, 0),
+                        },
+                    });
+                }
+            },
+            IfStatement(node) {
+                visitIfStatement(node);
+            },
+            ForStatement(node) {
+                visitLoop(node);
+            },
+            ForInStatement(node) {
+                visitLoop(node);
+            },
+            ForOfStatement(node) {
+                visitLoop(node);
+            },
+            DoWhileStatement(node) {
+                visitLoop(node);
+            },
+            WhileStatement(node) {
+                visitLoop(node);
+            },
+            SwitchStatement(node) {
+                visitSwitchStatement(node);
+            },
+            ContinueStatement(node) {
+                visitContinueOrBreakStatement(node);
+            },
+            BreakStatement(node) {
+                visitContinueOrBreakStatement(node);
+            },
+            CatchClause(node) {
+                visitCatchClause(node);
+            },
+            LogicalExpression(node) {
+                visitLogicalExpression(node);
+            },
+            ConditionalExpression(node) {
+                visitConditionalExpression(node);
+            },
+        };
+        function onEnterFunction(node) {
+            scopes.push({ node, nestingLevel: 0, nestingNodes: new Set(), complexityPoints: [] });
+        }
+        function onLeaveFunction(node) {
+            const functionComplexity = scopes.pop();
+            checkFunction(functionComplexity.complexityPoints, (0, locations_1.getMainFunctionTokenLocation)(node, node.parent, context));
+        }
+        function visitIfStatement(ifStatement) {
+            const { parent } = ifStatement;
+            const { loc: ifLoc } = (0, locations_1.getFirstToken)(ifStatement, context);
+            // if the current `if` statement is `else if`, do not count it in structural complexity
+            if ((0, nodes_1.isIfStatement)(parent) && parent.alternate === ifStatement) {
+                addComplexity(ifLoc);
+            }
+            else {
+                addStructuralComplexity(ifLoc);
+            }
+            // always increase nesting level inside `then` statement
+            scopes[scopes.length - 1].nestingNodes.add(ifStatement.consequent);
+            // if `else` branch is not `else if` then
+            // - increase nesting level inside `else` statement
+            // - add +1 complexity
+            if (ifStatement.alternate && !(0, nodes_1.isIfStatement)(ifStatement.alternate)) {
+                scopes[scopes.length - 1].nestingNodes.add(ifStatement.alternate);
+                const elseTokenLoc = (0, locations_1.getFirstTokenAfter)(ifStatement.consequent, context).loc;
+                addComplexity(elseTokenLoc);
+            }
+        }
+        function visitLoop(loop) {
+            addStructuralComplexity((0, locations_1.getFirstToken)(loop, context).loc);
+            scopes[scopes.length - 1].nestingNodes.add(loop.body);
+        }
+        function visitSwitchStatement(switchStatement) {
+            addStructuralComplexity((0, locations_1.getFirstToken)(switchStatement, context).loc);
+            for (const switchCase of switchStatement.cases) {
+                scopes[scopes.length - 1].nestingNodes.add(switchCase);
+            }
+        }
+        function visitContinueOrBreakStatement(statement) {
+            if (statement.label) {
+                addComplexity((0, locations_1.getFirstToken)(statement, context).loc);
+            }
+        }
+        function visitCatchClause(catchClause) {
+            addStructuralComplexity((0, locations_1.getFirstToken)(catchClause, context).loc);
+            scopes[scopes.length - 1].nestingNodes.add(catchClause.body);
+        }
+        function visitConditionalExpression(conditionalExpression) {
+            const questionTokenLoc = (0, locations_1.getFirstTokenAfter)(conditionalExpression.test, context).loc;
+            addStructuralComplexity(questionTokenLoc);
+            scopes[scopes.length - 1].nestingNodes.add(conditionalExpression.consequent);
+            scopes[scopes.length - 1].nestingNodes.add(conditionalExpression.alternate);
+        }
+        function visitLogicalExpression(logicalExpression) {
+            const jsxShortCircuitNodes = (0, jsx_1.getJsxShortCircuitNodes)(logicalExpression);
+            if (jsxShortCircuitNodes != null) {
+                jsxShortCircuitNodes.forEach(node => consideredLogicalExpressions.add(node));
+                return;
+            }
+            if (isDefaultValuePattern(logicalExpression)) {
+                return;
+            }
+            if (!consideredLogicalExpressions.has(logicalExpression)) {
+                const flattenedLogicalExpressions = flattenLogicalExpression(logicalExpression);
+                let previous;
+                for (const current of flattenedLogicalExpressions) {
+                    if (!previous || previous.operator !== current.operator) {
+                        const operatorTokenLoc = (0, locations_1.getFirstTokenAfter)(current.left, context).loc;
+                        addComplexity(operatorTokenLoc);
+                    }
+                    previous = current;
+                }
+            }
+        }
+        function isDefaultValuePattern(node) {
+            const { left, right, operator, parent } = node;
+            const operators = ['||', '??'];
+            const literals = ['Literal', 'ArrayExpression', 'ObjectExpression'];
+            switch (parent?.type) {
+                /* Matches: const x = a || literal */
+                case 'VariableDeclarator':
+                    return operators.includes(operator) && literals.includes(right.type);
+                /* Matches: a = a || literal */
+                case 'AssignmentExpression':
+                    return (operators.includes(operator) &&
+                        literals.includes(right.type) &&
+                        context.sourceCode.getText(parent.left) === context.sourceCode.getText(left));
+                default:
+                    return false;
+            }
+        }
+        function flattenLogicalExpression(node) {
+            if ((0, nodes_1.isLogicalExpression)(node)) {
+                consideredLogicalExpressions.add(node);
+                return [
+                    ...flattenLogicalExpression(node.left),
+                    node,
+                    ...flattenLogicalExpression(node.right),
+                ];
+            }
+            return [];
+        }
+        function addStructuralComplexity(location) {
+            const added = scopes[scopes.length - 1].nestingLevel + 1;
+            const complexityPoint = { complexity: added, location };
+            scopes[scopes.length - 1].complexityPoints.push(complexityPoint);
+        }
+        function addComplexity(location) {
+            const complexityPoint = { complexity: 1, location };
+            scopes[scopes.length - 1].complexityPoints.push(complexityPoint);
+        }
+        function checkFunction(complexity = [], loc) {
+            if (isFileComplexity) {
+                return;
+            }
+            const complexityAmount = complexity.reduce((acc, cur) => acc + cur.complexity, 0);
+            if (complexityAmount > threshold) {
+                const secondaryLocations = complexity.map(complexityPoint => {
+                    const { complexity, location } = complexityPoint;
+                    const message = complexity === 1 ? '+1' : `+${complexity} (incl. ${complexity - 1} for nesting)`;
+                    return (0, locations_1.issueLocation)(location, undefined, message);
+                });
+                (0, locations_1.report)(context, {
+                    messageId: 'refactorFunction',
+                    data: {
+                        complexityAmount,
+                        threshold,
+                    },
+                    loc,
+                }, secondaryLocations, message, complexityAmount - threshold);
+            }
+        }
+    },
+};
+module.exports = rule;

package/lib/src/rules/elseif-without-else.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+declare const rule: TSESLint.RuleModule<string, string[]>;
+export = rule;

package/lib/src/rules/elseif-without-else.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * eslint-plugin-sonarjs
+ * Copyright (C) 2018-2021 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+// https://sonarsource.github.io/rspec/#/rspec/S126
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const docs_url_1 = __importDefault(require("../utils/docs-url"));
+const rule = {
+    defaultOptions: [],
+    meta: {
+        messages: {
+            addMissingElseClause: 'Add the missing "else" clause.',
+        },
+        schema: [],
+        type: 'suggestion',
+        docs: {
+            description: '"if ... else if" constructs should end with "else" clauses',
+            url: (0, docs_url_1.default)(__filename),
+        },
+    },
+    create(context) {
+        return {
+            IfStatement: (node) => {
+                const ifstmt = node;
+                if (isElseIf(ifstmt) && !ifstmt.alternate) {
+                    const { sourceCode } = context;
+                    const elseKeyword = sourceCode.getTokenBefore(node, token => token.type === 'Keyword' && token.value === 'else');
+                    const ifKeyword = sourceCode.getFirstToken(node, token => token.type === 'Keyword' && token.value === 'if');
+                    context.report({
+                        messageId: 'addMissingElseClause',
+                        loc: {
+                            start: elseKeyword.loc.start,
+                            end: ifKeyword.loc.end,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+function isElseIf(node) {
+    const { parent } = node;
+    return parent?.type === 'IfStatement' && parent.alternate === node;
+}
+module.exports = rule;