eslint-plugin-sonarjs 1.0.4 → 2.0.0

package/lib/src/rules/no-collection-size-mischeck.js

@@ -1,98 +0,0 @@
-"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/S3981
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const parser_services_1 = require("../utils/parser-services");
-const docs_url_1 = __importDefault(require("../utils/docs-url"));
-const CollectionLike = ['Array', 'Map', 'Set', 'WeakMap', 'WeakSet'];
-const CollectionSizeLike = ['length', 'size'];
-const rule = {
-    defaultOptions: [],
-    meta: {
-        messages: {
-            fixCollectionSizeCheck: 'Fix this expression; {{propertyName}} of "{{objectName}}" is always greater or equal to zero.',
-            suggestFixedSizeCheck: 'Use "{{operator}}" for {{operation}} check',
-        },
-        schema: [],
-        type: 'problem',
-        hasSuggestions: true,
-        docs: {
-            description: 'Collection sizes and array length comparisons should make sense',
-            recommended: 'recommended',
-            url: (0, docs_url_1.default)(__filename),
-        },
-    },
-    create(context) {
-        const services = context.sourceCode.parserServices;
-        const isTypeCheckerAvailable = (0, parser_services_1.isParserServicesWithTypeInformation)(services);
-        return {
-            BinaryExpression: (node) => {
-                const expr = node;
-                if (['<', '>='].includes(expr.operator)) {
-                    const lhs = expr.left;
-                    const rhs = expr.right;
-                    if (isZeroLiteral(rhs) && lhs.type === 'MemberExpression') {
-                        const { object, property } = lhs;
-                        if (property.type === 'Identifier' &&
-                            CollectionSizeLike.includes(property.name) &&
-                            (!isTypeCheckerAvailable || isCollection(object, services))) {
-                            context.report({
-                                messageId: 'fixCollectionSizeCheck',
-                                data: {
-                                    propertyName: property.name,
-                                    objectName: context.sourceCode.getText(object),
-                                },
-                                node,
-                                suggest: getSuggestion(expr, property.name, context),
-                            });
-                        }
-                    }
-                }
-            },
-        };
-    },
-};
-function isZeroLiteral(node) {
-    return node.type === 'Literal' && node.value === 0;
-}
-function isCollection(node, services) {
-    const checker = services.program.getTypeChecker();
-    const tp = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(node));
-    return !!tp.symbol && CollectionLike.includes(tp.symbol.name);
-}
-function getSuggestion(expr, operation, context) {
-    const { left, operator } = expr;
-    const operatorToken = context.sourceCode.getTokenAfter(left, token => token.value === operator);
-    const fixedOperator = operator === '<' ? '==' : '>';
-    return [
-        {
-            messageId: 'suggestFixedSizeCheck',
-            data: {
-                operation,
-                operator: fixedOperator,
-            },
-            fix: fixer => fixer.replaceText(operatorToken, fixedOperator),
-        },
-    ];
-}
-module.exports = rule;

package/lib/src/rules/no-duplicate-string.d.ts

@@ -1,10 +0,0 @@
-import type { TSESLint } from '@typescript-eslint/utils';
-type Options = [{
-    threshold?: number;
-    ignoreStrings?: string;
-} | undefined, 'sonar-runtime'] | [{
-    threshold?: number;
-    ignoreStrings?: string;
-} | undefined];
-declare const rule: TSESLint.RuleModule<string, Options>;
-export = rule;

package/lib/src/rules/no-duplicate-string.js

@@ -1,135 +0,0 @@
-"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/S1192
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const docs_url_1 = __importDefault(require("../utils/docs-url"));
-const locations_1 = require("../utils/locations");
-// Number of times a literal must be duplicated to trigger an issue
-const DEFAULT_THRESHOLD = 3;
-const DEFAULT_IGNORE_STRINGS = 'application/json';
-const MIN_LENGTH = 10;
-const NO_SEPARATOR_REGEXP = /^\w*$/;
-const EXCLUDED_CONTEXTS = [
-    'ImportDeclaration',
-    'ImportExpression',
-    'JSXAttribute',
-    'ExportAllDeclaration',
-    'ExportNamedDeclaration',
-];
-const message = 'Define a constant instead of duplicating this literal {{times}} times.';
-const rule = {
-    defaultOptions: [
-        {
-            threshold: DEFAULT_THRESHOLD,
-            ignoreStrings: DEFAULT_IGNORE_STRINGS,
-        },
-    ],
-    meta: {
-        messages: {
-            defineConstant: message,
-            sonarRuntime: '{{sonarRuntimeData}}',
-        },
-        type: 'suggestion',
-        docs: {
-            description: 'String literals should not be duplicated',
-            recommended: 'recommended',
-            url: (0, docs_url_1.default)(__filename),
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    threshold: { type: 'integer', minimum: 2 },
-                    ignoreStrings: { type: 'string', default: DEFAULT_IGNORE_STRINGS },
-                },
-            },
-            {
-                type: 'string',
-                enum: ['sonar-runtime'] /* internal parameter for rules having secondary locations */,
-            },
-        ],
-    },
-    create(context) {
-        const literalsByValue = new Map();
-        const { threshold, ignoreStrings } = extractOptions(context);
-        const whitelist = ignoreStrings.split(',');
-        return {
-            Literal: (node) => {
-                const literal = node;
-                const { parent } = literal;
-                if (typeof literal.value === 'string' &&
-                    parent &&
-                    !['ExpressionStatement', 'TSLiteralType'].includes(parent.type)) {
-                    const stringContent = literal.value.trim();
-                    if (!whitelist.includes(literal.value) &&
-                        !isExcludedByUsageContext(context, literal) &&
-                        stringContent.length >= MIN_LENGTH &&
-                        !stringContent.match(NO_SEPARATOR_REGEXP)) {
-                        const sameStringLiterals = literalsByValue.get(stringContent) || [];
-                        sameStringLiterals.push(literal);
-                        literalsByValue.set(stringContent, sameStringLiterals);
-                    }
-                }
-            },
-            'Program:exit'() {
-                literalsByValue.forEach(literals => {
-                    if (literals.length >= threshold) {
-                        const [primaryNode, ...secondaryNodes] = literals;
-                        const secondaryIssues = secondaryNodes.map(node => (0, locations_1.issueLocation)(node.loc, node.loc, 'Duplication'));
-                        (0, locations_1.report)(context, {
-                            messageId: 'defineConstant',
-                            node: primaryNode,
-                            data: { times: literals.length.toString() },
-                        }, secondaryIssues, message);
-                    }
-                });
-            },
-        };
-    },
-};
-function isExcludedByUsageContext(context, literal) {
-    const { parent } = literal;
-    const parentType = parent.type;
-    return (EXCLUDED_CONTEXTS.includes(parentType) ||
-        isRequireContext(parent, context) ||
-        isObjectPropertyKey(parent, literal));
-}
-function isRequireContext(parent, context) {
-    return (parent.type === 'CallExpression' && context.sourceCode.getText(parent.callee) === 'require');
-}
-function isObjectPropertyKey(parent, literal) {
-    return parent.type === 'Property' && parent.key === literal;
-}
-function extractOptions(context) {
-    let threshold = DEFAULT_THRESHOLD;
-    let ignoreStrings = DEFAULT_IGNORE_STRINGS;
-    const options = context.options[0];
-    if (typeof options?.threshold === 'number') {
-        threshold = options.threshold;
-    }
-    if (typeof options?.ignoreStrings === 'string') {
-        ignoreStrings = options.ignoreStrings;
-    }
-    return { threshold, ignoreStrings };
-}
-module.exports = rule;

package/lib/src/rules/no-duplicated-branches.d.ts

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

package/lib/src/rules/no-duplicated-branches.js

@@ -1,147 +0,0 @@
-"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/S1871
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const nodes_1 = require("../utils/nodes");
-const equivalence_1 = require("../utils/equivalence");
-const conditions_1 = require("../utils/conditions");
-const locations_1 = require("../utils/locations");
-const docs_url_1 = __importDefault(require("../utils/docs-url"));
-const message = "This {{type}}'s code block is the same as the block for the {{type}} on line {{line}}.";
-const rule = {
-    defaultOptions: [],
-    meta: {
-        messages: {
-            sameConditionalBlock: message,
-            sonarRuntime: '{{sonarRuntimeData}}',
-        },
-        type: 'problem',
-        docs: {
-            description: 'Two branches in a conditional structure should not have exactly the same implementation',
-            recommended: 'recommended',
-            url: (0, docs_url_1.default)(__filename),
-        },
-        schema: [
-            {
-                // internal parameter
-                type: 'string',
-                enum: ['sonar-runtime'],
-            },
-        ],
-    },
-    create(context) {
-        return {
-            IfStatement(node) {
-                visitIfStatement(node);
-            },
-            SwitchStatement(node) {
-                visitSwitchStatement(node);
-            },
-        };
-        function visitIfStatement(ifStmt) {
-            if ((0, nodes_1.isIfStatement)(ifStmt.parent)) {
-                return;
-            }
-            const { branches, endsWithElse } = (0, conditions_1.collectIfBranches)(ifStmt);
-            if (allEquivalentWithoutDefault(branches, endsWithElse)) {
-                branches.slice(1).forEach((branch, i) => reportIssue(branch, branches[i], 'branch'));
-                return;
-            }
-            for (let i = 1; i < branches.length; i++) {
-                if (hasRequiredSize([branches[i]])) {
-                    for (let j = 0; j < i; j++) {
-                        if (compareIfBranches(branches[i], branches[j])) {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        function visitSwitchStatement(switchStmt) {
-            const { cases } = switchStmt;
-            const { endsWithDefault } = (0, conditions_1.collectSwitchBranches)(switchStmt);
-            const nonEmptyCases = cases.filter(c => (0, conditions_1.takeWithoutBreak)(expandSingleBlockStatement(c.consequent)).length > 0);
-            const casesWithoutBreak = nonEmptyCases.map(c => (0, conditions_1.takeWithoutBreak)(expandSingleBlockStatement(c.consequent)));
-            if (allEquivalentWithoutDefault(casesWithoutBreak, endsWithDefault)) {
-                nonEmptyCases
-                    .slice(1)
-                    .forEach((caseStmt, i) => reportIssue(caseStmt, nonEmptyCases[i], 'case'));
-                return;
-            }
-            for (let i = 1; i < cases.length; i++) {
-                const firstClauseWithoutBreak = (0, conditions_1.takeWithoutBreak)(expandSingleBlockStatement(cases[i].consequent));
-                if (hasRequiredSize(firstClauseWithoutBreak)) {
-                    for (let j = 0; j < i; j++) {
-                        const secondClauseWithoutBreak = (0, conditions_1.takeWithoutBreak)(expandSingleBlockStatement(cases[j].consequent));
-                        if ((0, equivalence_1.areEquivalent)(firstClauseWithoutBreak, secondClauseWithoutBreak, context.sourceCode)) {
-                            reportIssue(cases[i], cases[j], 'case');
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        function hasRequiredSize(nodes) {
-            if (nodes.length > 0) {
-                const tokens = [
-                    ...context.sourceCode.getTokens(nodes[0]),
-                    ...context.sourceCode.getTokens(nodes[nodes.length - 1]),
-                ].filter(token => token.value !== '{' && token.value !== '}');
-                return (tokens.length > 0 && tokens[tokens.length - 1].loc.end.line > tokens[0].loc.start.line);
-            }
-            return false;
-        }
-        function compareIfBranches(a, b) {
-            const equivalent = (0, equivalence_1.areEquivalent)(a, b, context.sourceCode);
-            if (equivalent && b.loc) {
-                reportIssue(a, b, 'branch');
-            }
-            return equivalent;
-        }
-        function expandSingleBlockStatement(nodes) {
-            if (nodes.length === 1) {
-                const node = nodes[0];
-                if ((0, nodes_1.isBlockStatement)(node)) {
-                    return node.body;
-                }
-            }
-            return nodes;
-        }
-        function allEquivalentWithoutDefault(branches, endsWithDefault) {
-            return (!endsWithDefault &&
-                branches.length > 1 &&
-                branches
-                    .slice(1)
-                    .every((branch, index) => (0, equivalence_1.areEquivalent)(branch, branches[index], context.sourceCode)));
-        }
-        function reportIssue(node, equivalentNode, type) {
-            const equivalentNodeLoc = equivalentNode.loc;
-            (0, locations_1.report)(context, {
-                messageId: 'sameConditionalBlock',
-                data: { type, line: String(equivalentNode.loc.start.line) },
-                node,
-            }, [(0, locations_1.issueLocation)(equivalentNodeLoc, equivalentNodeLoc, 'Original')], message);
-        }
-    },
-};
-module.exports = rule;

package/lib/src/rules/no-element-overwrite.d.ts

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

package/lib/src/rules/no-element-overwrite.js

@@ -1,177 +0,0 @@
-"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/S4143
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const equivalence_1 = require("../utils/equivalence");
-const nodes_1 = require("../utils/nodes");
-const locations_1 = require("../utils/locations");
-const docs_url_1 = __importDefault(require("../utils/docs-url"));
-const message = 'Verify this is the index that was intended; "{{index}}" was already set on line {{line}}.';
-const rule = {
-    defaultOptions: [],
-    meta: {
-        messages: {
-            verifyIntendedIndex: message,
-            sonarRuntime: '{{sonarRuntimeData}}',
-        },
-        type: 'problem',
-        docs: {
-            description: 'Collection elements should not be replaced unconditionally',
-            recommended: 'recommended',
-            url: (0, docs_url_1.default)(__filename),
-        },
-        schema: [
-            {
-                // internal parameter
-                type: 'string',
-                enum: ['sonar-runtime'],
-            },
-        ],
-    },
-    create(context) {
-        return {
-            SwitchCase(node) {
-                const switchCase = node;
-                checkStatements(switchCase.consequent);
-            },
-            BlockStatement(node) {
-                const block = node;
-                checkStatements(block.body);
-            },
-            Program(node) {
-                const program = node;
-                checkStatements(program.body);
-            },
-        };
-        function checkStatements(statements) {
-            const usedKeys = new Map();
-            let collection;
-            statements.forEach(statement => {
-                const keyWriteUsage = getKeyWriteUsage(statement);
-                if (keyWriteUsage) {
-                    if (collection &&
-                        !(0, equivalence_1.areEquivalent)(keyWriteUsage.collectionNode, collection, context.sourceCode)) {
-                        usedKeys.clear();
-                    }
-                    const sameKeyWriteUsage = usedKeys.get(keyWriteUsage.indexOrKey);
-                    if (sameKeyWriteUsage && sameKeyWriteUsage.node.loc) {
-                        const sameKeyWriteUsageLoc = sameKeyWriteUsage.node.loc;
-                        const secondaryLocations = [
-                            (0, locations_1.issueLocation)(sameKeyWriteUsageLoc, sameKeyWriteUsageLoc, 'Original value'),
-                        ];
-                        (0, locations_1.report)(context, {
-                            node: keyWriteUsage.node,
-                            messageId: 'verifyIntendedIndex',
-                            data: {
-                                index: keyWriteUsage.indexOrKey,
-                                line: sameKeyWriteUsage.node.loc.start.line,
-                            },
-                        }, secondaryLocations, message);
-                    }
-                    usedKeys.set(keyWriteUsage.indexOrKey, keyWriteUsage);
-                    collection = keyWriteUsage.collectionNode;
-                }
-                else {
-                    usedKeys.clear();
-                }
-            });
-        }
-        function getKeyWriteUsage(node) {
-            if ((0, nodes_1.isExpressionStatement)(node)) {
-                return arrayKeyWriteUsage(node.expression) || mapOrSetKeyWriteUsage(node.expression);
-            }
-            return undefined;
-        }
-        function arrayKeyWriteUsage(node) {
-            // a[b] = ...
-            if (isSimpleAssignment(node) && (0, nodes_1.isMemberExpression)(node.left) && node.left.computed) {
-                const { left, right } = node;
-                const index = extractIndex(left.property);
-                if (index !== undefined && !isUsed(left.object, right)) {
-                    return {
-                        collectionNode: left.object,
-                        indexOrKey: index,
-                        node,
-                    };
-                }
-            }
-            return undefined;
-        }
-        function mapOrSetKeyWriteUsage(node) {
-            if ((0, nodes_1.isCallExpression)(node) && (0, nodes_1.isMemberExpression)(node.callee)) {
-                const propertyAccess = node.callee;
-                if ((0, nodes_1.isIdentifier)(propertyAccess.property)) {
-                    const methodName = propertyAccess.property.name;
-                    const addMethod = methodName === 'add' && node.arguments.length === 1;
-                    const setMethod = methodName === 'set' && node.arguments.length === 2;
-                    if (addMethod || setMethod) {
-                        const key = extractIndex(node.arguments[0]);
-                        if (key) {
-                            return {
-                                collectionNode: propertyAccess.object,
-                                indexOrKey: key,
-                                node,
-                            };
-                        }
-                    }
-                }
-            }
-            return undefined;
-        }
-        function extractIndex(node) {
-            if ((0, nodes_1.isLiteral)(node)) {
-                const { value } = node;
-                return typeof value === 'number' || typeof value === 'string' ? String(value) : undefined;
-            }
-            else if ((0, nodes_1.isIdentifier)(node)) {
-                return node.name;
-            }
-            return undefined;
-        }
-        function isUsed(value, expression) {
-            const valueTokens = context.sourceCode.getTokens(value);
-            const expressionTokens = context.sourceCode.getTokens(expression);
-            const foundUsage = expressionTokens.find((token, index) => {
-                if (eq(token, valueTokens[0])) {
-                    for (let expressionIndex = index, valueIndex = 0; expressionIndex < expressionTokens.length && valueIndex < valueTokens.length; expressionIndex++, valueIndex++) {
-                        if (!eq(expressionTokens[expressionIndex], valueTokens[valueIndex])) {
-                            break;
-                        }
-                        else if (valueIndex === valueTokens.length - 1) {
-                            return true;
-                        }
-                    }
-                }
-                return false;
-            });
-            return foundUsage !== undefined;
-        }
-    },
-};
-function eq(token1, token2) {
-    return token1.value === token2.value;
-}
-function isSimpleAssignment(node) {
-    return (0, nodes_1.isAssignmentExpression)(node) && node.operator === '=';
-}
-module.exports = rule;

package/lib/src/rules/no-empty-collection.d.ts

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