eslint 7.4.0 → 7.8.0

package/lib/rules/no-warning-comments.js

@@ -8,6 +8,8 @@
 const { escapeRegExp } = require("lodash");
 const astUtils = require("./utils/ast-utils");
 
+const CHAR_LIMIT = 40;
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -42,12 +44,11 @@ module.exports = {
         ],
 
         messages: {
-            unexpectedComment: "Unexpected '{{matchedTerm}}' comment."
+            unexpectedComment: "Unexpected '{{matchedTerm}}' comment: '{{comment}}'."
         }
     },
 
     create(context) {
-
         const sourceCode = context.getSourceCode(),
             configuration = context.options[0] || {},
             warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
@@ -107,7 +108,15 @@ module.exports = {
              * \bTERM\b|\bTERM\b, this checks the entire comment
              * for the term.
              */
-            return new RegExp(prefix + escaped + suffix + eitherOrWordBoundary + term + wordBoundary, "iu");
+            return new RegExp(
+                prefix +
+                    escaped +
+                    suffix +
+                    eitherOrWordBoundary +
+                    term +
+                    wordBoundary,
+                "iu"
+            );
         }
 
         const warningRegExps = warningTerms.map(convertToRegExp);
@@ -135,18 +144,40 @@ module.exports = {
          * @returns {void} undefined.
          */
         function checkComment(node) {
-            if (astUtils.isDirectiveComment(node) && selfConfigRegEx.test(node.value)) {
+            const comment = node.value;
+
+            if (
+                astUtils.isDirectiveComment(node) &&
+                selfConfigRegEx.test(comment)
+            ) {
                 return;
             }
 
-            const matches = commentContainsWarningTerm(node.value);
+            const matches = commentContainsWarningTerm(comment);
 
             matches.forEach(matchedTerm => {
+                let commentToDisplay = "";
+                let truncated = false;
+
+                for (const c of comment.trim().split(/\s+/u)) {
+                    const tmp = commentToDisplay ? `${commentToDisplay} ${c}` : c;
+
+                    if (tmp.length <= CHAR_LIMIT) {
+                        commentToDisplay = tmp;
+                    } else {
+                        truncated = true;
+                        break;
+                    }
+                }
+
                 context.report({
                     node,
                     messageId: "unexpectedComment",
                     data: {
-                        matchedTerm
+                        matchedTerm,
+                        comment: `${commentToDisplay}${
+                            truncated ? "..." : ""
+                        }`
                     }
                 });
             });
@@ -156,7 +187,9 @@ module.exports = {
             Program() {
                 const comments = sourceCode.getAllComments();
 
-                comments.filter(token => token.type !== "Shebang").forEach(checkComment);
+                comments
+                    .filter(token => token.type !== "Shebang")
+                    .forEach(checkComment);
             }
         };
     }

package/lib/rules/no-whitespace-before-property.js

@@ -49,8 +49,6 @@ module.exports = {
          * @private
          */
         function reportError(node, leftToken, rightToken) {
-            const replacementText = node.computed ? "" : ".";
-
             context.report({
                 node,
                 messageId: "unexpectedWhitespace",
@@ -58,7 +56,9 @@ module.exports = {
                     propName: sourceCode.getText(node.property)
                 },
                 fix(fixer) {
-                    if (!node.computed && astUtils.isDecimalInteger(node.object)) {
+                    let replacementText = "";
+
+                    if (!node.computed && !node.optional && astUtils.isDecimalInteger(node.object)) {
 
                         /*
                          * If the object is a number literal, fixing it to something like 5.toString() would cause a SyntaxError.
@@ -66,6 +66,18 @@ module.exports = {
                          */
                         return null;
                     }
+
+                    // Don't fix if comments exist.
+                    if (sourceCode.commentsExistBetween(leftToken, rightToken)) {
+                        return null;
+                    }
+
+                    if (node.optional) {
+                        replacementText = "?.";
+                    } else if (!node.computed) {
+                        replacementText = ".";
+                    }
+
                     return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], replacementText);
                 }
             });
@@ -86,7 +98,7 @@ module.exports = {
 
                 if (node.computed) {
                     rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken);
-                    leftToken = sourceCode.getTokenBefore(rightToken);
+                    leftToken = sourceCode.getTokenBefore(rightToken, node.optional ? 1 : 0);
                 } else {
                     rightToken = sourceCode.getFirstToken(node.property);
                     leftToken = sourceCode.getTokenBefore(rightToken, 1);

package/lib/rules/object-curly-newline.js

@@ -224,7 +224,7 @@ module.exports = {
                     context.report({
                         messageId: "expectedLinebreakAfterOpeningBrace",
                         node,
-                        loc: openBrace.loc.start,
+                        loc: openBrace.loc,
                         fix(fixer) {
                             if (hasCommentsFirstToken) {
                                 return null;
@@ -238,7 +238,7 @@ module.exports = {
                     context.report({
                         messageId: "expectedLinebreakBeforeClosingBrace",
                         node,
-                        loc: closeBrace.loc.start,
+                        loc: closeBrace.loc,
                         fix(fixer) {
                             if (hasCommentsLastToken) {
                                 return null;
@@ -260,7 +260,7 @@ module.exports = {
                     context.report({
                         messageId: "unexpectedLinebreakAfterOpeningBrace",
                         node,
-                        loc: openBrace.loc.start,
+                        loc: openBrace.loc,
                         fix(fixer) {
                             if (hasCommentsFirstToken) {
                                 return null;
@@ -280,7 +280,7 @@ module.exports = {
                     context.report({
                         messageId: "unexpectedLinebreakBeforeClosingBrace",
                         node,
-                        loc: closeBrace.loc.start,
+                        loc: closeBrace.loc,
                         fix(fixer) {
                             if (hasCommentsLastToken) {
                                 return null;

package/lib/rules/operator-assignment.js

@@ -40,45 +40,6 @@ function isNonCommutativeOperatorWithShorthand(operator) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/**
- * Checks whether two expressions reference the same value. For example:
- *     a = a
- *     a.b = a.b
- *     a[0] = a[0]
- *     a['b'] = a['b']
- * @param   {ASTNode} a Left side of the comparison.
- * @param   {ASTNode} b Right side of the comparison.
- * @returns {boolean}   True if both sides match and reference the same value.
- */
-function same(a, b) {
-    if (a.type !== b.type) {
-        return false;
-    }
-
-    switch (a.type) {
-        case "Identifier":
-            return a.name === b.name;
-
-        case "Literal":
-            return a.value === b.value;
-
-        case "MemberExpression":
-
-            /*
-             * x[0] = x[0]
-             * x[y] = x[y]
-             * x.y = x.y
-             */
-            return same(a.object, b.object) && same(a.property, b.property);
-
-        case "ThisExpression":
-            return true;
-
-        default:
-            return false;
-    }
-}
-
 /**
  * Determines if the left side of a node can be safely fixed (i.e. if it activates the same getters/setters and)
  * toString calls regardless of whether assignment shorthand is used)
@@ -148,12 +109,12 @@ module.exports = {
             const operator = expr.operator;
 
             if (isCommutativeOperatorWithShorthand(operator) || isNonCommutativeOperatorWithShorthand(operator)) {
-                if (same(left, expr.left)) {
+                if (astUtils.isSameReference(left, expr.left, true)) {
                     context.report({
                         node,
                         messageId: "replaced",
                         fix(fixer) {
-                            if (canBeFixed(left)) {
+                            if (canBeFixed(left) && canBeFixed(expr.left)) {
                                 const equalsToken = getOperatorToken(node);
                                 const operatorToken = getOperatorToken(expr);
                                 const leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]);
@@ -169,7 +130,7 @@ module.exports = {
                             return null;
                         }
                     });
-                } else if (same(left, expr.right) && isCommutativeOperatorWithShorthand(operator)) {
+                } else if (astUtils.isSameReference(left, expr.right, true) && isCommutativeOperatorWithShorthand(operator)) {
 
                     /*
                      * This case can't be fixed safely.
@@ -190,7 +151,7 @@ module.exports = {
          * @returns {void}
          */
         function prohibit(node) {
-            if (node.operator !== "=") {
+            if (node.operator !== "=" && !astUtils.isLogicalAssignmentOperator(node.operator)) {
                 context.report({
                     node,
                     messageId: "unexpected",

package/lib/rules/padding-line-between-statements.js

@@ -85,10 +85,10 @@ function newNodeTypeTester(type) {
  */
 function isIIFEStatement(node) {
     if (node.type === "ExpressionStatement") {
-        let call = node.expression;
+        let call = astUtils.skipChainExpression(node.expression);
 
         if (call.type === "UnaryExpression") {
-            call = call.argument;
+            call = astUtils.skipChainExpression(call.argument);
         }
         return call.type === "CallExpression" && astUtils.isFunction(call.callee);
     }

package/lib/rules/prefer-arrow-callback.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -66,6 +68,7 @@ function getCallbackInfo(node) {
     const retv = { isCallback: false, isLexicalThis: false };
     let currentNode = node;
     let parent = node.parent;
+    let bound = false;
 
     while (currentNode) {
         switch (parent.type) {
@@ -73,23 +76,34 @@ function getCallbackInfo(node) {
             // Checks parents recursively.
 
             case "LogicalExpression":
+            case "ChainExpression":
             case "ConditionalExpression":
                 break;
 
             // Checks whether the parent node is `.bind(this)` call.
             case "MemberExpression":
-                if (parent.object === currentNode &&
+                if (
+                    parent.object === currentNode &&
                     !parent.property.computed &&
                     parent.property.type === "Identifier" &&
-                    parent.property.name === "bind" &&
-                    parent.parent.type === "CallExpression" &&
-                    parent.parent.callee === parent
+                    parent.property.name === "bind"
                 ) {
-                    retv.isLexicalThis = (
-                        parent.parent.arguments.length === 1 &&
-                        parent.parent.arguments[0].type === "ThisExpression"
-                    );
-                    parent = parent.parent;
+                    const maybeCallee = parent.parent.type === "ChainExpression"
+                        ? parent.parent
+                        : parent;
+
+                    if (astUtils.isCallee(maybeCallee)) {
+                        if (!bound) {
+                            bound = true; // Use only the first `.bind()` to make `isLexicalThis` value.
+                            retv.isLexicalThis = (
+                                maybeCallee.parent.arguments.length === 1 &&
+                                maybeCallee.parent.arguments[0].type === "ThisExpression"
+                            );
+                        }
+                        parent = maybeCallee.parent;
+                    } else {
+                        return retv;
+                    }
                 } else {
                     return retv;
                 }
@@ -272,7 +286,7 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "preferArrowCallback",
-                        fix(fixer) {
+                        *fix(fixer) {
                             if ((!callbackInfo.isLexicalThis && scopeInfo.this) || hasDuplicateParams(node.params)) {
 
                                 /*
@@ -281,30 +295,81 @@ module.exports = {
                                  * If the callback function has duplicates in its list of parameters (possible in sloppy mode),
                                  * don't replace it with an arrow function, because this is a SyntaxError with arrow functions.
                                  */
-                                return null;
+                                return; // eslint-disable-line eslint-plugin/fixer-return -- false positive
                             }
 
-                            const paramsLeftParen = node.params.length ? sourceCode.getTokenBefore(node.params[0]) : sourceCode.getTokenBefore(node.body, 1);
-                            const paramsRightParen = sourceCode.getTokenBefore(node.body);
-                            const asyncKeyword = node.async ? "async " : "";
-                            const paramsFullText = sourceCode.text.slice(paramsLeftParen.range[0], paramsRightParen.range[1]);
-                            const arrowFunctionText = `${asyncKeyword}${paramsFullText} => ${sourceCode.getText(node.body)}`;
+                            // Remove `.bind(this)` if exists.
+                            if (callbackInfo.isLexicalThis) {
+                                const memberNode = node.parent;
 
-                            /*
-                             * If the callback function has `.bind(this)`, replace it with an arrow function and remove the binding.
-                             * Otherwise, just replace the arrow function itself.
-                             */
-                            const replacedNode = callbackInfo.isLexicalThis ? node.parent.parent : node;
+                                /*
+                                 * If `.bind(this)` exists but the parent is not `.bind(this)`, don't remove it automatically.
+                                 * E.g. `(foo || function(){}).bind(this)`
+                                 */
+                                if (memberNode.type !== "MemberExpression") {
+                                    return; // eslint-disable-line eslint-plugin/fixer-return -- false positive
+                                }
+
+                                const callNode = memberNode.parent;
+                                const firstTokenToRemove = sourceCode.getTokenAfter(memberNode.object, astUtils.isNotClosingParenToken);
+                                const lastTokenToRemove = sourceCode.getLastToken(callNode);
+
+                                /*
+                                 * If the member expression is parenthesized, don't remove the right paren.
+                                 * E.g. `(function(){}.bind)(this)`
+                                 *                    ^^^^^^^^^^^^
+                                 */
+                                if (astUtils.isParenthesised(sourceCode, memberNode)) {
+                                    return; // eslint-disable-line eslint-plugin/fixer-return -- false positive
+                                }
+
+                                // If comments exist in the `.bind(this)`, don't remove those.
+                                if (sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove)) {
+                                    return; // eslint-disable-line eslint-plugin/fixer-return -- false positive
+                                }
+
+                                yield fixer.removeRange([firstTokenToRemove.range[0], lastTokenToRemove.range[1]]);
+                            }
+
+                            // Convert the function expression to an arrow function.
+                            const functionToken = sourceCode.getFirstToken(node, node.async ? 1 : 0);
+                            const leftParenToken = sourceCode.getTokenAfter(functionToken, astUtils.isOpeningParenToken);
+
+                            if (sourceCode.commentsExistBetween(functionToken, leftParenToken)) {
+
+                                // Remove only extra tokens to keep comments.
+                                yield fixer.remove(functionToken);
+                                if (node.id) {
+                                    yield fixer.remove(node.id);
+                                }
+                            } else {
+
+                                // Remove extra tokens and spaces.
+                                yield fixer.removeRange([functionToken.range[0], leftParenToken.range[0]]);
+                            }
+                            yield fixer.insertTextBefore(node.body, "=> ");
+
+                            // Get the node that will become the new arrow function.
+                            let replacedNode = callbackInfo.isLexicalThis ? node.parent.parent : node;
+
+                            if (replacedNode.type === "ChainExpression") {
+                                replacedNode = replacedNode.parent;
+                            }
 
                             /*
                              * If the replaced node is part of a BinaryExpression, LogicalExpression, or MemberExpression, then
                              * the arrow function needs to be parenthesized, because `foo || () => {}` is invalid syntax even
                              * though `foo || function() {}` is valid.
                              */
-                            const needsParens = replacedNode.parent.type !== "CallExpression" && replacedNode.parent.type !== "ConditionalExpression";
-                            const replacementText = needsParens ? `(${arrowFunctionText})` : arrowFunctionText;
-
-                            return fixer.replaceText(replacedNode, replacementText);
+                            if (
+                                replacedNode.parent.type !== "CallExpression" &&
+                                replacedNode.parent.type !== "ConditionalExpression" &&
+                                !astUtils.isParenthesised(sourceCode, replacedNode) &&
+                                !astUtils.isParenthesised(sourceCode, node)
+                            ) {
+                                yield fixer.insertTextBefore(replacedNode, "(");
+                                yield fixer.insertTextAfter(replacedNode, ")");
+                            }
                         }
                     });
                 }

package/lib/rules/prefer-exponentiation-operator.js

@@ -52,7 +52,7 @@ function doesExponentNeedParens(exponent) {
  * @returns {boolean} `true` if the expression needs to be parenthesised.
  */
 function doesExponentiationExpressionNeedParens(node, sourceCode) {
-    const parent = node.parent;
+    const parent = node.parent.type === "ChainExpression" ? node.parent.parent : node.parent;
 
     const needsParens = (
         parent.type === "ClassDeclaration" ||

package/lib/rules/prefer-numeric-literals.js

@@ -29,19 +29,10 @@ const radixMap = new Map([
  * false otherwise.
  */
 function isParseInt(calleeNode) {
-    switch (calleeNode.type) {
-        case "Identifier":
-            return calleeNode.name === "parseInt";
-        case "MemberExpression":
-            return calleeNode.object.type === "Identifier" &&
-                calleeNode.object.name === "Number" &&
-                calleeNode.property.type === "Identifier" &&
-                calleeNode.property.name === "parseInt";
-
-        // no default
-    }
-
-    return false;
+    return (
+        astUtils.isSpecificId(calleeNode, "parseInt") ||
+        astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
+    );
 }
 
 //------------------------------------------------------------------------------
@@ -112,6 +103,16 @@ module.exports = {
                                 /*
                                  * If the newly-produced literal would be invalid, (e.g. 0b1234),
                                  * or it would yield an incorrect parseInt result for some other reason, don't make a fix.
+                                 *
+                                 * If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+`
+                                 * per the specification doesn't support numeric separators. Thus, the above condition will be `true`
+                                 * (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value.
+                                 * Consequently, no autofixes will be made. This is correct behavior because `parseInt` also
+                                 * doesn't support numeric separators, but it does parse part of the string before the first `_`,
+                                 * so the autofix would be invalid:
+                                 *
+                                 *   parseInt("1_1", 2) // === 1
+                                 *   0b1_1 // === 3
                                  */
                                 return null;
                             }

package/lib/rules/prefer-promise-reject-errors.js

@@ -73,9 +73,7 @@ module.exports = {
          * @returns {boolean} `true` if the call is a Promise.reject() call
          */
         function isPromiseRejectCall(node) {
-            return node.callee.type === "MemberExpression" &&
-                node.callee.object.type === "Identifier" && node.callee.object.name === "Promise" &&
-                node.callee.property.type === "Identifier" && node.callee.property.name === "reject";
+            return astUtils.isSpecificMemberAccess(node.callee, "Promise", "reject");
         }
 
         //----------------------------------------------------------------------

package/lib/rules/prefer-regex-literals.js

@@ -102,11 +102,8 @@ module.exports = {
          */
         function isStringRawTaggedStaticTemplateLiteral(node) {
             return node.type === "TaggedTemplateExpression" &&
-                node.tag.type === "MemberExpression" &&
-                node.tag.object.type === "Identifier" &&
-                node.tag.object.name === "String" &&
-                isGlobalReference(node.tag.object) &&
-                astUtils.getStaticPropertyName(node.tag) === "raw" &&
+                astUtils.isSpecificMemberAccess(node.tag, "String", "raw") &&
+                isGlobalReference(astUtils.skipChainExpression(node.tag).object) &&
                 isStaticTemplateLiteral(node.quasi);
         }
 

package/lib/rules/prefer-spread.js

@@ -18,17 +18,13 @@ const astUtils = require("./utils/ast-utils");
  */
 function isVariadicApplyCalling(node) {
     return (
-        node.callee.type === "MemberExpression" &&
-        node.callee.property.type === "Identifier" &&
-        node.callee.property.name === "apply" &&
-        node.callee.computed === false &&
+        astUtils.isSpecificMemberAccess(node.callee, null, "apply") &&
         node.arguments.length === 2 &&
         node.arguments[1].type !== "ArrayExpression" &&
         node.arguments[1].type !== "SpreadElement"
     );
 }
 
-
 /**
  * Checks whether or not `thisArg` is not changed by `.apply()`.
  * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
@@ -75,7 +71,7 @@ module.exports = {
                     return;
                 }
 
-                const applied = node.callee.object;
+                const applied = astUtils.skipChainExpression(astUtils.skipChainExpression(node.callee).object);
                 const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
                 const thisArg = node.arguments[0];
 

package/lib/rules/radix.js

@@ -166,9 +166,12 @@ module.exports = {
                 if (variable && !isShadowed(variable)) {
                     variable.references.forEach(reference => {
                         const node = reference.identifier.parent;
+                        const maybeCallee = node.parent.type === "ChainExpression"
+                            ? node.parent
+                            : node;
 
-                        if (isParseIntMethod(node) && astUtils.isCallee(node)) {
-                            checkArguments(node.parent);
+                        if (isParseIntMethod(node) && astUtils.isCallee(maybeCallee)) {
+                            checkArguments(maybeCallee.parent);
                         }
                     });
                 }

package/lib/rules/sort-imports.js

@@ -44,6 +44,10 @@ module.exports = {
                     ignoreMemberSort: {
                         type: "boolean",
                         default: false
+                    },
+                    allowSeparatedGroups: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -66,6 +70,7 @@ module.exports = {
             ignoreDeclarationSort = configuration.ignoreDeclarationSort || false,
             ignoreMemberSort = configuration.ignoreMemberSort || false,
             memberSyntaxSortOrder = configuration.memberSyntaxSortOrder || ["none", "all", "multiple", "single"],
+            allowSeparatedGroups = configuration.allowSeparatedGroups || false,
             sourceCode = context.getSourceCode();
         let previousDeclaration = null;
 
@@ -115,9 +120,32 @@ module.exports = {
 
         }
 
+        /**
+         * Calculates number of lines between two nodes. It is assumed that the given `left` node appears before
+         * the given `right` node in the source code. Lines are counted from the end of the `left` node till the
+         * start of the `right` node. If the given nodes are on the same line, it returns `0`, same as if they were
+         * on two consecutive lines.
+         * @param {ASTNode} left node that appears before the given `right` node.
+         * @param {ASTNode} right node that appears after the given `left` node.
+         * @returns {number} number of lines between nodes.
+         */
+        function getNumberOfLinesBetween(left, right) {
+            return Math.max(right.loc.start.line - left.loc.end.line - 1, 0);
+        }
+
         return {
             ImportDeclaration(node) {
                 if (!ignoreDeclarationSort) {
+                    if (
+                        previousDeclaration &&
+                        allowSeparatedGroups &&
+                        getNumberOfLinesBetween(previousDeclaration, node) > 0
+                    ) {
+
+                        // reset declaration sort
+                        previousDeclaration = null;
+                    }
+
                     if (previousDeclaration) {
                         const currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(node),
                             previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(previousDeclaration);

package/lib/rules/use-isnan.js

@@ -106,7 +106,7 @@ module.exports = {
          * @returns {void}
          */
         function checkCallExpression(node) {
-            const callee = node.callee;
+            const callee = astUtils.skipChainExpression(node.callee);
 
             if (callee.type === "MemberExpression") {
                 const methodName = astUtils.getStaticPropertyName(callee);