eslint 7.1.0 → 7.4.0

package/lib/rule-tester/rule-tester.js

@@ -644,6 +644,10 @@ class RuleTester {
             assert.ok(item.errors || item.errors === 0,
                 `Did not specify errors for an invalid test of ${ruleName}`);
 
+            if (Array.isArray(item.errors) && item.errors.length === 0) {
+                assert.fail("Invalid cases must have at least one error");
+            }
+
             const ruleHasMetaMessages = hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages");
             const friendlyIDList = ruleHasMetaMessages ? `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]` : null;
 
@@ -651,6 +655,11 @@ class RuleTester {
             const messages = result.messages;
 
             if (typeof item.errors === "number") {
+
+                if (item.errors === 0) {
+                    assert.fail("Invalid cases must have 'error' value greater than 0");
+                }
+
                 assert.strictEqual(messages.length, item.errors, util.format("Should have %d error%s but had %d: %s",
                     item.errors, item.errors === 1 ? "" : "s", messages.length, util.inspect(messages)));
             } else {

package/lib/rules/array-callback-return.js

@@ -9,8 +9,6 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const lodash = require("lodash");
-
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -43,6 +41,19 @@ function isTargetMethod(node) {
     );
 }
 
+/**
+ * Returns a human-legible description of an array method
+ * @param {string} arrayMethodName A method name to fully qualify
+ * @returns {string} the method name prefixed with `Array.` if it is a class method,
+ *      or else `Array.prototype.` if it is an instance method.
+ */
+function fullMethodName(arrayMethodName) {
+    if (["from", "of", "isArray"].includes(arrayMethodName)) {
+        return "Array.".concat(arrayMethodName);
+    }
+    return "Array.prototype.".concat(arrayMethodName);
+}
+
 /**
  * Checks whether or not a given node is a function expression which is the
  * callback of an array method, returning the method name.
@@ -153,10 +164,10 @@ module.exports = {
         ],
 
         messages: {
-            expectedAtEnd: "Expected to return a value at the end of {{name}}.",
-            expectedInside: "Expected to return a value in {{name}}.",
-            expectedReturnValue: "{{name}} expected a return value.",
-            expectedNoReturnValue: "{{name}} did not expect a return value."
+            expectedAtEnd: "{{arrayMethodName}}() expects a value to be returned at the end of {{name}}.",
+            expectedInside: "{{arrayMethodName}}() expects a return value from {{name}}.",
+            expectedReturnValue: "{{arrayMethodName}}() expects a return value from {{name}}.",
+            expectedNoReturnValue: "{{arrayMethodName}}() expects no useless return value from {{name}}."
         }
     },
 
@@ -202,14 +213,13 @@ module.exports = {
             }
 
             if (messageId) {
-                let name = astUtils.getFunctionNameWithKind(node);
+                const name = astUtils.getFunctionNameWithKind(node);
 
-                name = messageId === "expectedNoReturnValue" ? lodash.upperFirst(name) : name;
                 context.report({
                     node,
                     loc: astUtils.getFunctionHeadLoc(node, sourceCode),
                     messageId,
-                    data: { name }
+                    data: { name, arrayMethodName: fullMethodName(funcInfo.arrayMethodName) }
                 });
             }
         }
@@ -273,7 +283,8 @@ module.exports = {
                         node,
                         messageId,
                         data: {
-                            name: lodash.upperFirst(astUtils.getFunctionNameWithKind(funcInfo.node))
+                            name: astUtils.getFunctionNameWithKind(funcInfo.node),
+                            arrayMethodName: fullMethodName(funcInfo.arrayMethodName)
                         }
                     });
                 }

package/lib/rules/arrow-body-style.js

@@ -136,7 +136,7 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: arrowBody.loc.start,
+                        loc: arrowBody.loc,
                         messageId,
                         fix(fixer) {
                             const fixes = [];
@@ -201,7 +201,7 @@ module.exports = {
                 if (always || (asNeeded && requireReturnForObjectLiteral && arrowBody.type === "ObjectExpression")) {
                     context.report({
                         node,
-                        loc: arrowBody.loc.start,
+                        loc: arrowBody.loc,
                         messageId: "expectedBlock",
                         fix(fixer) {
                             const fixes = [];

package/lib/rules/arrow-parens.js

@@ -15,15 +15,12 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /**
- * Get location should be reported by AST node.
- * @param {ASTNode} node AST Node.
- * @returns {Location} Location information.
+ * Determines if the given arrow function has block body.
+ * @param {ASTNode} node `ArrowFunctionExpression` node.
+ * @returns {boolean} `true` if the function has block body.
  */
-function getLocation(node) {
-    return {
-        start: node.params[0].loc.start,
-        end: node.params[node.params.length - 1].loc.end
-    };
+function hasBlockBody(node) {
+    return node.body.type === "BlockStatement";
 }
 
 //------------------------------------------------------------------------------
@@ -75,126 +72,112 @@ module.exports = {
         const sourceCode = context.getSourceCode();
 
         /**
-         * Determines whether a arrow function argument end with `)`
-         * @param {ASTNode} node The arrow function node.
-         * @returns {void}
+         * Finds opening paren of parameters for the given arrow function, if it exists.
+         * It is assumed that the given arrow function has exactly one parameter.
+         * @param {ASTNode} node `ArrowFunctionExpression` node.
+         * @returns {Token|null} the opening paren, or `null` if the given arrow function doesn't have parens of parameters.
          */
-        function parens(node) {
-            const isAsync = node.async;
-            const firstTokenOfParam = sourceCode.getFirstToken(node, isAsync ? 1 : 0);
-
-            /**
-             * Remove the parenthesis around a parameter
-             * @param {Fixer} fixer Fixer
-             * @returns {string} fixed parameter
-             */
-            function fixParamsWithParenthesis(fixer) {
-                const paramToken = sourceCode.getTokenAfter(firstTokenOfParam);
-
-                /*
-                 * ES8 allows Trailing commas in function parameter lists and calls
-                 * https://github.com/eslint/eslint/issues/8834
-                 */
-                const closingParenToken = sourceCode.getTokenAfter(paramToken, astUtils.isClosingParenToken);
-                const asyncToken = isAsync ? sourceCode.getTokenBefore(firstTokenOfParam) : null;
-                const shouldAddSpaceForAsync = asyncToken && (asyncToken.range[1] === firstTokenOfParam.range[0]);
-
-                return fixer.replaceTextRange([
-                    firstTokenOfParam.range[0],
-                    closingParenToken.range[1]
-                ], `${shouldAddSpaceForAsync ? " " : ""}${paramToken.value}`);
+        function findOpeningParenOfParams(node) {
+            const tokenBeforeParams = sourceCode.getTokenBefore(node.params[0]);
+
+            if (
+                tokenBeforeParams &&
+                astUtils.isOpeningParenToken(tokenBeforeParams) &&
+                node.range[0] <= tokenBeforeParams.range[0]
+            ) {
+                return tokenBeforeParams;
             }
 
-            /**
-             * Checks whether there are comments inside the params or not.
-             * @returns {boolean} `true` if there are comments inside of parens, else `false`
-             */
-            function hasCommentsInParens() {
-                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
-                    const closingParenToken = sourceCode.getTokenAfter(node.params[0], astUtils.isClosingParenToken);
+            return null;
+        }
 
-                    return closingParenToken && sourceCode.commentsExistBetween(firstTokenOfParam, closingParenToken);
-                }
-                return false;
+        /**
+         * Finds closing paren of parameters for the given arrow function.
+         * It is assumed that the given arrow function has parens of parameters and that it has exactly one parameter.
+         * @param {ASTNode} node `ArrowFunctionExpression` node.
+         * @returns {Token} the closing paren of parameters.
+         */
+        function getClosingParenOfParams(node) {
+            return sourceCode.getTokenAfter(node.params[0], astUtils.isClosingParenToken);
+        }
 
-            }
+        /**
+         * Determines whether the given arrow function has comments inside parens of parameters.
+         * It is assumed that the given arrow function has parens of parameters.
+         * @param {ASTNode} node `ArrowFunctionExpression` node.
+         * @param {Token} openingParen Opening paren of parameters.
+         * @returns {boolean} `true` if the function has at least one comment inside of parens of parameters.
+         */
+        function hasCommentsInParensOfParams(node, openingParen) {
+            return sourceCode.commentsExistBetween(openingParen, getClosingParenOfParams(node));
+        }
 
-            if (hasCommentsInParens()) {
-                return;
-            }
+        /**
+         * Determines whether the given arrow function has unexpected tokens before opening paren of parameters,
+         * in which case it will be assumed that the existing parens of parameters are necessary.
+         * Only tokens within the range of the arrow function (tokens that are part of the arrow function) are taken into account.
+         * Example: <T>(a) => b
+         * @param {ASTNode} node `ArrowFunctionExpression` node.
+         * @param {Token} openingParen Opening paren of parameters.
+         * @returns {boolean} `true` if the function has at least one unexpected token.
+         */
+        function hasUnexpectedTokensBeforeOpeningParen(node, openingParen) {
+            const expectedCount = node.async ? 1 : 0;
 
-            // "as-needed", { "requireForBlockBody": true }: x => x
-            if (
-                requireForBlockBody &&
-                node.params[0].type === "Identifier" &&
-                !node.params[0].typeAnnotation &&
-                node.body.type !== "BlockStatement" &&
-                !node.returnType
-            ) {
-                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
-                    context.report({
-                        node,
-                        messageId: "unexpectedParensInline",
-                        loc: getLocation(node),
-                        fix: fixParamsWithParenthesis
-                    });
-                }
-                return;
-            }
+            return sourceCode.getFirstToken(node, { skip: expectedCount }) !== openingParen;
+        }
 
-            if (
-                requireForBlockBody &&
-                node.body.type === "BlockStatement"
-            ) {
-                if (!astUtils.isOpeningParenToken(firstTokenOfParam)) {
-                    context.report({
-                        node,
-                        messageId: "expectedParensBlock",
-                        loc: getLocation(node),
-                        fix(fixer) {
-                            return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);
-                        }
-                    });
-                }
-                return;
-            }
+        return {
+            "ArrowFunctionExpression[params.length=1]"(node) {
+                const shouldHaveParens = !asNeeded || requireForBlockBody && hasBlockBody(node);
+                const openingParen = findOpeningParenOfParams(node);
+                const hasParens = openingParen !== null;
+                const [param] = node.params;
 
-            // "as-needed": x => x
-            if (asNeeded &&
-                node.params[0].type === "Identifier" &&
-                !node.params[0].typeAnnotation &&
-                !node.returnType
-            ) {
-                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
+                if (shouldHaveParens && !hasParens) {
                     context.report({
                         node,
-                        messageId: "unexpectedParens",
-                        loc: getLocation(node),
-                        fix: fixParamsWithParenthesis
+                        messageId: requireForBlockBody ? "expectedParensBlock" : "expectedParens",
+                        loc: param.loc,
+                        *fix(fixer) {
+                            yield fixer.insertTextBefore(param, "(");
+                            yield fixer.insertTextAfter(param, ")");
+                        }
                     });
                 }
-                return;
-            }
 
-            if (firstTokenOfParam.type === "Identifier") {
-                const after = sourceCode.getTokenAfter(firstTokenOfParam);
-
-                // (x) => x
-                if (after.value !== ")") {
+                if (
+                    !shouldHaveParens &&
+                    hasParens &&
+                    param.type === "Identifier" &&
+                    !param.typeAnnotation &&
+                    !node.returnType &&
+                    !hasCommentsInParensOfParams(node, openingParen) &&
+                    !hasUnexpectedTokensBeforeOpeningParen(node, openingParen)
+                ) {
                     context.report({
                         node,
-                        messageId: "expectedParens",
-                        loc: getLocation(node),
-                        fix(fixer) {
-                            return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);
+                        messageId: requireForBlockBody ? "unexpectedParensInline" : "unexpectedParens",
+                        loc: param.loc,
+                        *fix(fixer) {
+                            const tokenBeforeOpeningParen = sourceCode.getTokenBefore(openingParen);
+                            const closingParen = getClosingParenOfParams(node);
+
+                            if (
+                                tokenBeforeOpeningParen &&
+                                tokenBeforeOpeningParen.range[1] === openingParen.range[0] &&
+                                !astUtils.canTokensBeAdjacent(tokenBeforeOpeningParen, sourceCode.getFirstToken(param))
+                            ) {
+                                yield fixer.insertTextBefore(openingParen, " ");
+                            }
+
+                            // remove parens, whitespace inside parens, and possible trailing comma
+                            yield fixer.removeRange([openingParen.range[0], param.range[0]]);
+                            yield fixer.removeRange([param.range[1], closingParen.range[1]]);
                         }
                     });
                 }
             }
-        }
-
-        return {
-            "ArrowFunctionExpression[params.length=1]": parens
         };
     }
 };

package/lib/rules/camelcase.js

@@ -32,6 +32,10 @@ module.exports = {
                         type: "boolean",
                         default: false
                     },
+                    ignoreGlobals: {
+                        type: "boolean",
+                        default: false
+                    },
                     properties: {
                         enum: ["always", "never"]
                     },
@@ -61,8 +65,11 @@ module.exports = {
         let properties = options.properties || "";
         const ignoreDestructuring = options.ignoreDestructuring;
         const ignoreImports = options.ignoreImports;
+        const ignoreGlobals = options.ignoreGlobals;
         const allow = options.allow || [];
 
+        let globalScope;
+
         if (properties !== "always" && properties !== "never") {
             properties = "always";
         }
@@ -159,6 +166,37 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+         * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+         * @param {ASTNode} node `Identifier` node to check.
+         * @returns {boolean} `true` if the node is a reference to a global variable.
+         */
+        function isReferenceToGlobalVariable(node) {
+            const variable = globalScope.set.get(node.name);
+
+            return variable && variable.defs.length === 0 &&
+                variable.references.some(ref => ref.identifier === node);
+        }
+
+        /**
+         * Checks whether the given node represents a reference to a property of an object in an object literal expression.
+         * This allows to differentiate between a global variable that is allowed to be used as a reference, and the key
+         * of the expressed object (which shouldn't be allowed).
+         * @param {ASTNode} node `Identifier` node to check.
+         * @returns {boolean} `true` if the node is a property name of an object literal expression
+         */
+        function isPropertyNameInObjectLiteral(node) {
+            const parent = node.parent;
+
+            return (
+                parent.type === "Property" &&
+                parent.parent.type === "ObjectExpression" &&
+                !parent.computed &&
+                parent.key === node
+            );
+        }
+
         /**
          * Reports an AST node as a rule violation.
          * @param {ASTNode} node The node to report.
@@ -174,6 +212,10 @@ module.exports = {
 
         return {
 
+            Program() {
+                globalScope = context.getScope();
+            },
+
             Identifier(node) {
 
                 /*
@@ -189,6 +231,11 @@ module.exports = {
                     return;
                 }
 
+                // Check if it's a global variable
+                if (ignoreGlobals && isReferenceToGlobalVariable(node) && !isPropertyNameInObjectLiteral(node)) {
+                    return;
+                }
+
                 // MemberExpressions get special rules
                 if (node.parent.type === "MemberExpression") {
 

package/lib/rules/comma-dangle.js

@@ -124,7 +124,8 @@ module.exports = {
                         }
                     ]
                 }
-            ]
+            ],
+            additionalItems: false
         },
 
         messages: {

package/lib/rules/curly.js

@@ -457,11 +457,18 @@ module.exports = {
 
         return {
             IfStatement(node) {
-                if (node.parent.type !== "IfStatement") {
+                const parent = node.parent;
+                const isElseIf = parent.type === "IfStatement" && parent.alternate === node;
+
+                if (!isElseIf) {
+
+                    // This is a top `if`, check the whole `if-else-if` chain
                     prepareIfChecks(node).forEach(preparedCheck => {
                         preparedCheck.check();
                     });
                 }
+
+                // Skip `else if`, it's already checked (when the top `if` was visited)
             },
 
             WhileStatement(node) {

package/lib/rules/func-call-spacing.js

@@ -116,7 +116,13 @@ module.exports = {
             if (never && hasWhitespace) {
                 context.report({
                     node,
-                    loc: leftToken.loc.start,
+                    loc: {
+                        start: leftToken.loc.end,
+                        end: {
+                            line: rightToken.loc.start.line,
+                            column: rightToken.loc.start.column - 1
+                        }
+                    },
                     messageId: "unexpectedWhitespace",
                     fix(fixer) {
 
@@ -134,7 +140,13 @@ module.exports = {
             } else if (!never && !hasWhitespace) {
                 context.report({
                     node,
-                    loc: leftToken.loc.start,
+                    loc: {
+                        start: {
+                            line: leftToken.loc.end.line,
+                            column: leftToken.loc.end.column - 1
+                        },
+                        end: rightToken.loc.start
+                    },
                     messageId: "missing",
                     fix(fixer) {
                         return fixer.insertTextBefore(rightToken, " ");
@@ -143,7 +155,10 @@ module.exports = {
             } else if (!never && !allowNewlines && hasNewline) {
                 context.report({
                     node,
-                    loc: leftToken.loc.start,
+                    loc: {
+                        start: leftToken.loc.end,
+                        end: rightToken.loc.start
+                    },
                     messageId: "unexpectedNewline",
                     fix(fixer) {
                         return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ");

package/lib/rules/{id-blacklist.js → id-denylist.js}

@@ -1,6 +1,6 @@
 /**
  * @fileoverview Rule that warns when identifier names that are
- * blacklisted in the configuration are used.
+ * specified in the configuration are used.
  * @author Keith Cirkel (http://keithcirkel.co.uk)
  */
 
@@ -117,7 +117,7 @@ module.exports = {
             description: "disallow specified identifiers",
             category: "Stylistic Issues",
             recommended: false,
-            url: "https://eslint.org/docs/rules/id-blacklist"
+            url: "https://eslint.org/docs/rules/id-denylist"
         },
 
         schema: {
@@ -128,25 +128,25 @@ module.exports = {
             uniqueItems: true
         },
         messages: {
-            blacklisted: "Identifier '{{name}}' is blacklisted."
+            restricted: "Identifier '{{name}}' is restricted."
         }
     },
 
     create(context) {
 
-        const blacklist = new Set(context.options);
+        const denyList = new Set(context.options);
         const reportedNodes = new Set();
 
         let globalScope;
 
         /**
-         * Checks whether the given name is blacklisted.
+         * Checks whether the given name is restricted.
          * @param {string} name The name to check.
-         * @returns {boolean} `true` if the name is blacklisted.
+         * @returns {boolean} `true` if the name is restricted.
          * @private
          */
-        function isBlacklisted(name) {
-            return blacklist.has(name);
+        function isRestricted(name) {
+            return denyList.has(name);
         }
 
         /**
@@ -172,8 +172,8 @@ module.exports = {
 
             /*
              * Member access has special rules for checking property names.
-             * Read access to a property with a blacklisted name is allowed, because it can be on an object that user has no control over.
-             * Write access isn't allowed, because it potentially creates a new property with a blacklisted name.
+             * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
+             * Write access isn't allowed, because it potentially creates a new property with a restricted name.
              */
             if (
                 parent.type === "MemberExpression" &&
@@ -205,7 +205,7 @@ module.exports = {
             if (!reportedNodes.has(node)) {
                 context.report({
                     node,
-                    messageId: "blacklisted",
+                    messageId: "restricted",
                     data: {
                         name: node.name
                     }
@@ -221,7 +221,7 @@ module.exports = {
             },
 
             Identifier(node) {
-                if (isBlacklisted(node.name) && shouldCheck(node)) {
+                if (isRestricted(node.name) && shouldCheck(node)) {
                     report(node);
                 }
             }

package/lib/rules/id-match.js

@@ -39,7 +39,8 @@ module.exports = {
                         type: "boolean",
                         default: false
                     }
-                }
+                },
+                additionalProperties: false
             }
         ],
         messages: {

package/lib/rules/index.js

@@ -56,7 +56,10 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "grouped-accessor-pairs": () => require("./grouped-accessor-pairs"),
     "guard-for-in": () => require("./guard-for-in"),
     "handle-callback-err": () => require("./handle-callback-err"),
-    "id-blacklist": () => require("./id-blacklist"),
+
+    // Renamed to id-denylist.
+    "id-blacklist": () => require("./id-denylist"),
+    "id-denylist": () => require("./id-denylist"),
     "id-length": () => require("./id-length"),
     "id-match": () => require("./id-match"),
     "implicit-arrow-linebreak": () => require("./implicit-arrow-linebreak"),
@@ -176,6 +179,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-plusplus": () => require("./no-plusplus"),
     "no-process-env": () => require("./no-process-env"),
     "no-process-exit": () => require("./no-process-exit"),
+    "no-promise-executor-return": () => require("./no-promise-executor-return"),
     "no-proto": () => require("./no-proto"),
     "no-prototype-builtins": () => require("./no-prototype-builtins"),
     "no-redeclare": () => require("./no-redeclare"),
@@ -212,6 +216,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-unmodified-loop-condition": () => require("./no-unmodified-loop-condition"),
     "no-unneeded-ternary": () => require("./no-unneeded-ternary"),
     "no-unreachable": () => require("./no-unreachable"),
+    "no-unreachable-loop": () => require("./no-unreachable-loop"),
     "no-unsafe-finally": () => require("./no-unsafe-finally"),
     "no-unsafe-negation": () => require("./no-unsafe-negation"),
     "no-unused-expressions": () => require("./no-unused-expressions"),

package/lib/rules/key-spacing.js

@@ -433,11 +433,15 @@ module.exports = {
                 tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { includeComments: true }),
                 tokenAfterColon = sourceCode.getTokenAfter(nextColon, { includeComments: true }),
                 isKeySide = side === "key",
-                locStart = isKeySide ? tokenBeforeColon.loc.start : tokenAfterColon.loc.start,
                 isExtra = diff > 0,
                 diffAbs = Math.abs(diff),
                 spaces = Array(diffAbs + 1).join(" ");
 
+            const locStart = isKeySide ? tokenBeforeColon.loc.end : nextColon.loc.start;
+            const locEnd = isKeySide ? nextColon.loc.start : tokenAfterColon.loc.start;
+            const missingLoc = isKeySide ? tokenBeforeColon.loc : tokenAfterColon.loc;
+            const loc = isExtra ? { start: locStart, end: locEnd } : missingLoc;
+
             if ((
                 diff && mode === "strict" ||
                 diff < 0 && mode === "minimum" ||
@@ -482,7 +486,7 @@ module.exports = {
 
                 context.report({
                     node: property[side],
-                    loc: locStart,
+                    loc,
                     messageId,
                     data: {
                         computed: property.computed ? "computed " : "",