eslint 7.3.1 → 7.7.0

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

@@ -9,8 +9,6 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const lodash = require("lodash");
-
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -30,17 +28,27 @@ function isReachable(segment) {
 }
 
 /**
- * Checks a given node is a MemberExpression node which has the specified name's
+ * Checks a given node is a member access which has the specified name's
  * property.
  * @param {ASTNode} node A node to check.
- * @returns {boolean} `true` if the node is a MemberExpression node which has
- *      the specified name's property
+ * @returns {boolean} `true` if the node is a member access which has
+ *      the specified name's property. The node may be a `(Chain|Member)Expression` node.
  */
 function isTargetMethod(node) {
-    return (
-        node.type === "MemberExpression" &&
-        TARGET_METHODS.test(astUtils.getStaticPropertyName(node) || "")
-    );
+    return astUtils.isSpecificMemberAccess(node, null, TARGET_METHODS);
+}
+
+/**
+ * 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);
 }
 
 /**
@@ -65,6 +73,7 @@ function getArrayMethodName(node) {
              */
             case "LogicalExpression":
             case "ConditionalExpression":
+            case "ChainExpression":
                 currentNode = parent;
                 break;
 
@@ -153,10 +162,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 +211,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 +281,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

@@ -75,6 +75,7 @@ module.exports = {
         const never = options[0] === "never";
         const requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral;
         const sourceCode = context.getSourceCode();
+        let funcInfo = null;
 
         /**
          * Checks whether the given node has ASI problem or not.
@@ -99,6 +100,21 @@ module.exports = {
             return sourceCode.getTokenAfter(node);
         }
 
+        /**
+         * Check whether the node is inside of a for loop's init
+         * @param {ASTNode} node node is inside for loop
+         * @returns {boolean} `true` if the node is inside of a for loop, else `false`
+         */
+        function isInsideForLoopInitializer(node) {
+            if (node && node.parent) {
+                if (node.parent.type === "ForStatement" && node.parent.init === node) {
+                    return true;
+                }
+                return isInsideForLoopInitializer(node.parent);
+            }
+            return false;
+        }
+
         /**
          * Determines whether a arrow function body needs braces
          * @param {ASTNode} node The arrow function node.
@@ -136,7 +152,7 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: arrowBody.loc.start,
+                        loc: arrowBody.loc,
                         messageId,
                         fix(fixer) {
                             const fixes = [];
@@ -178,11 +194,13 @@ module.exports = {
                              * If the first token of the reutrn value is `{` or the return value is a sequence expression,
                              * enclose the return value by parentheses to avoid syntax error.
                              */
-                            if (astUtils.isOpeningBraceToken(firstValueToken) || blockBody[0].argument.type === "SequenceExpression") {
-                                fixes.push(
-                                    fixer.insertTextBefore(firstValueToken, "("),
-                                    fixer.insertTextAfter(lastValueToken, ")")
-                                );
+                            if (astUtils.isOpeningBraceToken(firstValueToken) || blockBody[0].argument.type === "SequenceExpression" || (funcInfo.hasInOperator && isInsideForLoopInitializer(node))) {
+                                if (!astUtils.isParenthesised(sourceCode, blockBody[0].argument)) {
+                                    fixes.push(
+                                        fixer.insertTextBefore(firstValueToken, "("),
+                                        fixer.insertTextAfter(lastValueToken, ")")
+                                    );
+                                }
                             }
 
                             /*
@@ -201,7 +219,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 = [];
@@ -245,7 +263,24 @@ module.exports = {
         }
 
         return {
-            "ArrowFunctionExpression:exit": validate
+            "BinaryExpression[operator='in']"() {
+                let info = funcInfo;
+
+                while (info) {
+                    info.hasInOperator = true;
+                    info = info.upper;
+                }
+            },
+            ArrowFunctionExpression() {
+                funcInfo = {
+                    upper: funcInfo,
+                    hasInOperator: false
+                };
+            },
+            "ArrowFunctionExpression:exit"(node) {
+                validate(node);
+                funcInfo = funcInfo.upper;
+            }
         };
     }
 };

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,8 +124,7 @@ module.exports = {
                         }
                     ]
                 }
-            ],
-            additionalItems: false
+            ]
         },
 
         messages: {

package/lib/rules/consistent-return.js

@@ -9,23 +9,12 @@
 //------------------------------------------------------------------------------
 
 const lodash = require("lodash");
-
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Checks whether or not a given node is an `Identifier` node which was named a given name.
- * @param {ASTNode} node A node to check.
- * @param {string} name An expected name of the node.
- * @returns {boolean} `true` if the node is an `Identifier` node which was named as expected.
- */
-function isIdentifier(node, name) {
-    return node.type === "Identifier" && node.name === name;
-}
-
 /**
  * Checks whether or not a given code path segment is unreachable.
  * @param {CodePathSegment} segment A CodePathSegment to check.
@@ -165,7 +154,7 @@ module.exports = {
                 let hasReturnValue = Boolean(argument);
 
                 if (treatUndefinedAsUnspecified && hasReturnValue) {
-                    hasReturnValue = !isIdentifier(argument, "undefined") && argument.operator !== "void";
+                    hasReturnValue = !astUtils.isSpecificId(argument, "undefined") && argument.operator !== "void";
                 }
 
                 if (!funcInfo.hasReturn) {

package/lib/rules/constructor-super.js

@@ -50,6 +50,7 @@ function isPossibleConstructor(node) {
         case "MemberExpression":
         case "CallExpression":
         case "NewExpression":
+        case "ChainExpression":
         case "YieldExpression":
         case "TaggedTemplateExpression":
         case "MetaProperty":

package/lib/rules/dot-location.js

@@ -52,31 +52,37 @@ module.exports = {
          */
         function checkDotLocation(node) {
             const property = node.property;
-            const dot = sourceCode.getTokenBefore(property);
-
-            // `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node.
-            const tokenBeforeDot = sourceCode.getTokenBefore(dot);
-
-            const textBeforeDot = sourceCode.getText().slice(tokenBeforeDot.range[1], dot.range[0]);
-            const textAfterDot = sourceCode.getText().slice(dot.range[1], property.range[0]);
+            const dotToken = sourceCode.getTokenBefore(property);
 
             if (onObject) {
-                if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dot)) {
-                    const neededTextAfterToken = astUtils.isDecimalIntegerNumericToken(tokenBeforeDot) ? " " : "";
 
+                // `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node.
+                const tokenBeforeDot = sourceCode.getTokenBefore(dotToken);
+
+                if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dotToken)) {
                     context.report({
                         node,
-                        loc: dot.loc,
+                        loc: dotToken.loc,
                         messageId: "expectedDotAfterObject",
-                        fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], property.range[0]], `${neededTextAfterToken}.${textBeforeDot}${textAfterDot}`)
+                        *fix(fixer) {
+                            if (dotToken.value.startsWith(".") && astUtils.isDecimalIntegerNumericToken(tokenBeforeDot)) {
+                                yield fixer.insertTextAfter(tokenBeforeDot, ` ${dotToken.value}`);
+                            } else {
+                                yield fixer.insertTextAfter(tokenBeforeDot, dotToken.value);
+                            }
+                            yield fixer.remove(dotToken);
+                        }
                     });
                 }
-            } else if (!astUtils.isTokenOnSameLine(dot, property)) {
+            } else if (!astUtils.isTokenOnSameLine(dotToken, property)) {
                 context.report({
                     node,
-                    loc: dot.loc,
+                    loc: dotToken.loc,
                     messageId: "expectedDotBeforeProperty",
-                    fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], property.range[0]], `${textBeforeDot}${textAfterDot}.`)
+                    *fix(fixer) {
+                        yield fixer.remove(dotToken);
+                        yield fixer.insertTextBefore(property, dotToken.value);
+                    }
                 });
             }
         }