eslint 7.2.0 → 7.5.0

package/lib/rules/no-setter-return.js

@@ -39,15 +39,12 @@ function isGlobalReference(node, scope) {
  * @returns {boolean} `true` if the node is argument at the given position.
  */
 function isArgumentOfGlobalMethodCall(node, scope, objectName, methodName, index) {
-    const parent = node.parent;
+    const callNode = node.parent;
 
-    return parent.type === "CallExpression" &&
-        parent.arguments[index] === node &&
-        parent.callee.type === "MemberExpression" &&
-        astUtils.getStaticPropertyName(parent.callee) === methodName &&
-        parent.callee.object.type === "Identifier" &&
-        parent.callee.object.name === objectName &&
-        isGlobalReference(parent.callee.object, scope);
+    return callNode.type === "CallExpression" &&
+        callNode.arguments[index] === node &&
+        astUtils.isSpecificMemberAccess(callNode.callee, objectName, methodName) &&
+        isGlobalReference(astUtils.skipChainExpression(callNode.callee).object, scope);
 }
 
 /**

package/lib/rules/no-unexpected-multiline.js

@@ -68,7 +68,7 @@ module.exports = {
         return {
 
             MemberExpression(node) {
-                if (!node.computed) {
+                if (!node.computed || node.optional) {
                     return;
                 }
                 checkForBreakAfter(node.object, "property");
@@ -96,7 +96,7 @@ module.exports = {
             },
 
             CallExpression(node) {
-                if (node.arguments.length === 0) {
+                if (node.arguments.length === 0 || node.optional) {
                     return;
                 }
                 checkForBreakAfter(node.callee, "function");

package/lib/rules/no-unneeded-ternary.js

@@ -122,7 +122,6 @@ module.exports = {
                 if (isBooleanLiteral(node.alternate) && isBooleanLiteral(node.consequent)) {
                     context.report({
                         node,
-                        loc: node.consequent.loc.start,
                         messageId: "unnecessaryConditionalExpression",
                         fix(fixer) {
                             if (node.consequent.value === node.alternate.value) {
@@ -144,7 +143,6 @@ module.exports = {
                 } else if (!defaultAssignment && matchesDefaultAssignment(node)) {
                     context.report({
                         node,
-                        loc: node.consequent.loc.start,
                         messageId: "unnecessaryConditionalAssignment",
                         fix: fixer => {
                             const shouldParenthesizeAlternate =

package/lib/rules/no-unreachable-loop.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Rule to disallow loops with a body that allows only one iteration
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const allLoopTypes = ["WhileStatement", "DoWhileStatement", "ForStatement", "ForInStatement", "ForOfStatement"];
+
+/**
+ * Determines whether the given node is the first node in the code path to which a loop statement
+ * 'loops' for the next iteration.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a looping target.
+ */
+function isLoopingTarget(node) {
+    const parent = node.parent;
+
+    if (parent) {
+        switch (parent.type) {
+            case "WhileStatement":
+                return node === parent.test;
+            case "DoWhileStatement":
+                return node === parent.body;
+            case "ForStatement":
+                return node === (parent.update || parent.test || parent.body);
+            case "ForInStatement":
+            case "ForOfStatement":
+                return node === parent.left;
+
+            // no default
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Creates an array with elements from the first given array that are not included in the second given array.
+ * @param {Array} arrA The array to compare from.
+ * @param {Array} arrB The array to compare against.
+ * @returns {Array} a new array that represents `arrA \ arrB`.
+ */
+function getDifference(arrA, arrB) {
+    return arrA.filter(a => !arrB.includes(a));
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow loops with a body that allows only one iteration",
+            category: "Possible Errors",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-unreachable-loop"
+        },
+
+        schema: [{
+            type: "object",
+            properties: {
+                ignore: {
+                    type: "array",
+                    items: {
+                        enum: allLoopTypes
+                    },
+                    uniqueItems: true
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            invalid: "Invalid loop. Its body allows only one iteration."
+        }
+    },
+
+    create(context) {
+        const ignoredLoopTypes = context.options[0] && context.options[0].ignore || [],
+            loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
+            loopSelector = loopTypesToCheck.join(","),
+            loopsByTargetSegments = new Map(),
+            loopsToReport = new Set();
+
+        let currentCodePath = null;
+
+        return {
+            onCodePathStart(codePath) {
+                currentCodePath = codePath;
+            },
+
+            onCodePathEnd() {
+                currentCodePath = currentCodePath.upper;
+            },
+
+            [loopSelector](node) {
+
+                /**
+                 * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
+                 * For unreachable segments, the code path analysis does not raise events required for this implementation.
+                 */
+                if (currentCodePath.currentSegments.some(segment => segment.reachable)) {
+                    loopsToReport.add(node);
+                }
+            },
+
+            onCodePathSegmentStart(segment, node) {
+                if (isLoopingTarget(node)) {
+                    const loop = node.parent;
+
+                    loopsByTargetSegments.set(segment, loop);
+                }
+            },
+
+            onCodePathSegmentLoop(_, toSegment, node) {
+                const loop = loopsByTargetSegments.get(toSegment);
+
+                /**
+                 * The second iteration is reachable, meaning that the loop is valid by the logic of this rule,
+                 * only if there is at least one loop event with the appropriate target (which has been already
+                 * determined in the `loopsByTargetSegments` map), raised from either:
+                 *
+                 * - the end of the loop's body (in which case `node === loop`)
+                 * - a `continue` statement
+                 *
+                 * This condition skips loop events raised from `ForInStatement > .right` and `ForOfStatement > .right` nodes.
+                 */
+                if (node === loop || node.type === "ContinueStatement") {
+
+                    // Removes loop if it exists in the set. Otherwise, `Set#delete` has no effect and doesn't throw.
+                    loopsToReport.delete(loop);
+                }
+            },
+
+            "Program:exit"() {
+                loopsToReport.forEach(
+                    node => context.report({ node, messageId: "invalid" })
+                );
+            }
+        };
+    }
+};

package/lib/rules/no-unused-expressions.js

@@ -8,6 +8,22 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/**
+ * Returns `true`.
+ * @returns {boolean} `true`.
+ */
+function alwaysTrue() {
+    return true;
+}
+
+/**
+ * Returns `false`.
+ * @returns {boolean} `false`.
+ */
+function alwaysFalse() {
+    return false;
+}
+
 module.exports = {
     meta: {
         type: "suggestion",
@@ -101,40 +117,56 @@ module.exports = {
         }
 
         /**
-         * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.
-         * @param {ASTNode} node any node
-         * @returns {boolean} whether the given node is a valid expression
+         * The member functions return `true` if the type has no side-effects.
+         * Unknown nodes are handled as `false`, then this rule ignores those.
          */
-        function isValidExpression(node) {
-            if (allowTernary) {
-
-                // Recursive check for ternary and logical expressions
-                if (node.type === "ConditionalExpression") {
-                    return isValidExpression(node.consequent) && isValidExpression(node.alternate);
+        const Checker = Object.assign(Object.create(null), {
+            isDisallowed(node) {
+                return (Checker[node.type] || alwaysFalse)(node);
+            },
+
+            ArrayExpression: alwaysTrue,
+            ArrowFunctionExpression: alwaysTrue,
+            BinaryExpression: alwaysTrue,
+            ChainExpression(node) {
+                return Checker.isDisallowed(node.expression);
+            },
+            ClassExpression: alwaysTrue,
+            ConditionalExpression(node) {
+                if (allowTernary) {
+                    return Checker.isDisallowed(node.consequent) || Checker.isDisallowed(node.alternate);
                 }
-            }
-
-            if (allowShortCircuit) {
-                if (node.type === "LogicalExpression") {
-                    return isValidExpression(node.right);
+                return true;
+            },
+            FunctionExpression: alwaysTrue,
+            Identifier: alwaysTrue,
+            Literal: alwaysTrue,
+            LogicalExpression(node) {
+                if (allowShortCircuit) {
+                    return Checker.isDisallowed(node.right);
                 }
-            }
-
-            if (allowTaggedTemplates && node.type === "TaggedTemplateExpression") {
                 return true;
+            },
+            MemberExpression: alwaysTrue,
+            MetaProperty: alwaysTrue,
+            ObjectExpression: alwaysTrue,
+            SequenceExpression: alwaysTrue,
+            TaggedTemplateExpression() {
+                return !allowTaggedTemplates;
+            },
+            TemplateLiteral: alwaysTrue,
+            ThisExpression: alwaysTrue,
+            UnaryExpression(node) {
+                return node.operator !== "void" && node.operator !== "delete";
             }
-
-            return /^(?:Assignment|Call|New|Update|Yield|Await|Import)Expression$/u.test(node.type) ||
-                (node.type === "UnaryExpression" && ["delete", "void"].indexOf(node.operator) >= 0);
-        }
+        });
 
         return {
             ExpressionStatement(node) {
-                if (!isValidExpression(node.expression) && !isDirective(node, context.getAncestors())) {
+                if (Checker.isDisallowed(node.expression) && !isDirective(node, context.getAncestors())) {
                     context.report({ node, messageId: "unusedExpression" });
                 }
             }
         };
-
     }
 };

package/lib/rules/no-unused-vars.js

@@ -68,7 +68,8 @@ module.exports = {
                             caughtErrorsIgnorePattern: {
                                 type: "string"
                             }
-                        }
+                        },
+                        additionalProperties: false
                     }
                 ]
             }

package/lib/rules/no-useless-call.js

@@ -17,13 +17,15 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
  */
 function isCallOrNonVariadicApply(node) {
+    const callee = astUtils.skipChainExpression(node.callee);
+
     return (
-        node.callee.type === "MemberExpression" &&
-        node.callee.property.type === "Identifier" &&
-        node.callee.computed === false &&
+        callee.type === "MemberExpression" &&
+        callee.property.type === "Identifier" &&
+        callee.computed === false &&
         (
-            (node.callee.property.name === "call" && node.arguments.length >= 1) ||
-            (node.callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
+            (callee.property.name === "call" && node.arguments.length >= 1) ||
+            (callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
         )
     );
 }
@@ -74,12 +76,13 @@ module.exports = {
                     return;
                 }
 
-                const applied = node.callee.object;
+                const callee = astUtils.skipChainExpression(node.callee);
+                const applied = astUtils.skipChainExpression(callee.object);
                 const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
                 const thisArg = node.arguments[0];
 
                 if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
-                    context.report({ node, messageId: "unnecessaryCall", data: { name: node.callee.property.name } });
+                    context.report({ node, messageId: "unnecessaryCall", data: { name: callee.property.name } });
                 }
             }
         };

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/object-property-newline.js

@@ -77,7 +77,7 @@ module.exports = {
                     if (lastTokenOfPreviousProperty.loc.end.line === firstTokenOfCurrentProperty.loc.start.line) {
                         context.report({
                             node,
-                            loc: firstTokenOfCurrentProperty.loc.start,
+                            loc: firstTokenOfCurrentProperty.loc,
                             messageId,
                             fix(fixer) {
                                 const comma = sourceCode.getTokenBefore(firstTokenOfCurrentProperty);

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.

package/lib/rules/operator-linebreak.js

@@ -35,11 +35,8 @@ module.exports = {
                 properties: {
                     overrides: {
                         type: "object",
-                        properties: {
-                            anyOf: {
-                                type: "string",
-                                enum: ["after", "before", "none", "ignore"]
-                            }
+                        additionalProperties: {
+                            enum: ["after", "before", "none", "ignore"]
                         }
                     }
                 },

package/lib/rules/padded-blocks.js

@@ -58,7 +58,8 @@ module.exports = {
                     allowSingleLineBlocks: {
                         type: "boolean"
                     }
-                }
+                },
+                additionalProperties: false
             }
         ],
 

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);
     }