eslint 6.0.0-alpha.2 → 6.1.0

package/lib/rules/arrow-parens.js

@@ -10,6 +10,23 @@
 
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get location should be reported by AST node.
+ *
+ * @param {ASTNode} node AST Node.
+ * @returns {Location} Location information.
+ */
+function getLocation(node) {
+    return {
+        start: node.params[0].loc.start,
+        end: node.params[node.params.length - 1].loc.end
+    };
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -102,6 +119,7 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "unexpectedParensInline",
+                        loc: getLocation(node),
                         fix: fixParamsWithParenthesis
                     });
                 }
@@ -116,6 +134,7 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "expectedParensBlock",
+                        loc: getLocation(node),
                         fix(fixer) {
                             return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);
                         }
@@ -135,6 +154,7 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "unexpectedParens",
+                        loc: getLocation(node),
                         fix: fixParamsWithParenthesis
                     });
                 }
@@ -149,6 +169,7 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "expectedParens",
+                        loc: getLocation(node),
                         fix(fixer) {
                             return fixer.replaceText(firstTokenOfParam, `(${firstTokenOfParam.value})`);
                         }

package/lib/rules/dot-location.js

@@ -54,29 +54,31 @@ module.exports = {
          */
         function checkDotLocation(obj, prop, node) {
             const dot = sourceCode.getTokenBefore(prop);
-            const textBeforeDot = sourceCode.getText().slice(obj.range[1], dot.range[0]);
+
+            // `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], prop.range[0]);
 
-            if (dot.type === "Punctuator" && dot.value === ".") {
-                if (onObject) {
-                    if (!astUtils.isTokenOnSameLine(obj, dot)) {
-                        const neededTextAfterObj = astUtils.isDecimalInteger(obj) ? " " : "";
-
-                        context.report({
-                            node,
-                            loc: dot.loc.start,
-                            messageId: "expectedDotAfterObject",
-                            fix: fixer => fixer.replaceTextRange([obj.range[1], prop.range[0]], `${neededTextAfterObj}.${textBeforeDot}${textAfterDot}`)
-                        });
-                    }
-                } else if (!astUtils.isTokenOnSameLine(dot, prop)) {
+            if (onObject) {
+                if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dot)) {
+                    const neededTextAfterToken = astUtils.isDecimalIntegerNumericToken(tokenBeforeDot) ? " " : "";
+
                     context.report({
                         node,
                         loc: dot.loc.start,
-                        messageId: "expectedDotBeforeProperty",
-                        fix: fixer => fixer.replaceTextRange([obj.range[1], prop.range[0]], `${textBeforeDot}${textAfterDot}.`)
+                        messageId: "expectedDotAfterObject",
+                        fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], prop.range[0]], `${neededTextAfterToken}.${textBeforeDot}${textAfterDot}`)
                     });
                 }
+            } else if (!astUtils.isTokenOnSameLine(dot, prop)) {
+                context.report({
+                    node,
+                    loc: dot.loc.start,
+                    messageId: "expectedDotBeforeProperty",
+                    fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], prop.range[0]], `${textBeforeDot}${textAfterDot}.`)
+                });
             }
         }
 
@@ -86,7 +88,9 @@ module.exports = {
          * @returns {void}
          */
         function checkNode(node) {
-            checkDotLocation(node.object, node.property, node);
+            if (!node.computed) {
+                checkDotLocation(node.object, node.property, node);
+            }
         }
 
         return {

package/lib/rules/max-len.js

@@ -315,6 +315,13 @@ module.exports = {
                         textToMeasure = line;
                     } else if (ignoreTrailingComments && isTrailingComment(line, lineNumber, comment)) {
                         textToMeasure = stripTrailingComment(line, comment);
+
+                        // ignore multiple trailing comments in the same line
+                        let lastIndex = commentsIndex;
+
+                        while (isTrailingComment(textToMeasure, lineNumber, comments[--lastIndex])) {
+                            textToMeasure = stripTrailingComment(textToMeasure, comments[lastIndex]);
+                        }
                     } else {
                         textToMeasure = line;
                     }

package/lib/rules/multiline-comment-style.js

@@ -25,6 +25,7 @@ module.exports = {
         schema: [{ enum: ["starred-block", "separate-lines", "bare-block"] }],
         messages: {
             expectedBlock: "Expected a block comment instead of consecutive line comments.",
+            expectedBareBlock: "Expected a block comment without padding stars.",
             startNewline: "Expected a linebreak after '/*'.",
             endNewline: "Expected a linebreak before '*/'.",
             missingStar: "Expected a '*' at the start of this line.",
@@ -250,7 +251,7 @@ module.exports = {
                                     start: block.loc.start,
                                     end: { line: block.loc.start.line, column: block.loc.start.column + 2 }
                                 },
-                                messageId: "expectedBlock",
+                                messageId: "expectedBareBlock",
                                 fix(fixer) {
                                     return fixer.replaceText(block, convertToBlock(block, commentLines.filter(line => line)));
                                 }

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

@@ -51,6 +51,124 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
+        /**
+         * Checks whether the given names can be safely used to declare block-scoped variables
+         * in the given scope. Name collisions can produce redeclaration syntax errors,
+         * or silently change references and modify behavior of the original code.
+         *
+         * This is not a generic function. In particular, it is assumed that the scope is a function scope or
+         * a function's inner scope, and that the names can be valid identifiers in the given scope.
+         *
+         * @param {string[]} names Array of variable names.
+         * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
+         * @returns {boolean} True if all names can be safely declared, false otherwise.
+         */
+        function isSafeToDeclare(names, scope) {
+
+            if (names.length === 0) {
+                return true;
+            }
+
+            const functionScope = scope.variableScope;
+
+            /*
+             * If this is a function scope, scope.variables will contain parameters, implicit variables such as "arguments",
+             * all function-scoped variables ('var'), and block-scoped variables defined in the scope.
+             * If this is an inner scope, scope.variables will contain block-scoped variables defined in the scope.
+             *
+             * Redeclaring any of these would cause a syntax error, except for the implicit variables.
+             */
+            const declaredVariables = scope.variables.filter(({ defs }) => defs.length > 0);
+
+            if (declaredVariables.some(({ name }) => names.includes(name))) {
+                return false;
+            }
+
+            // Redeclaring a catch variable would also cause a syntax error.
+            if (scope !== functionScope && scope.upper.type === "catch") {
+                if (scope.upper.variables.some(({ name }) => names.includes(name))) {
+                    return false;
+                }
+            }
+
+            /*
+             * Redeclaring an implicit variable, such as "arguments", would not cause a syntax error.
+             * However, if the variable was used, declaring a new one with the same name would change references
+             * and modify behavior.
+             */
+            const usedImplicitVariables = scope.variables.filter(({ defs, references }) =>
+                defs.length === 0 && references.length > 0);
+
+            if (usedImplicitVariables.some(({ name }) => names.includes(name))) {
+                return false;
+            }
+
+            /*
+             * Declaring a variable with a name that was already used to reference a variable from an upper scope
+             * would change references and modify behavior.
+             */
+            if (scope.through.some(t => names.includes(t.identifier.name))) {
+                return false;
+            }
+
+            /*
+             * If the scope is an inner scope (not the function scope), an uninitialized `var` variable declared inside
+             * the scope node (directly or in one of its descendants) is neither declared nor 'through' in the scope.
+             *
+             * For example, this would be a syntax error "Identifier 'a' has already been declared":
+             * function foo() { if (bar) { let a; if (baz) { var a; } } }
+             */
+            if (scope !== functionScope) {
+                const scopeNodeRange = scope.block.range;
+                const variablesToCheck = functionScope.variables.filter(({ name }) => names.includes(name));
+
+                if (variablesToCheck.some(v => v.defs.some(({ node: { range } }) =>
+                    scopeNodeRange[0] <= range[0] && range[1] <= scopeNodeRange[1]))) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+
+        /**
+         * Checks whether the removal of `else` and its braces is safe from variable name collisions.
+         *
+         * @param {Node} node The 'else' node.
+         * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
+         * @returns {boolean} True if it is safe, false otherwise.
+         */
+        function isSafeFromNameCollisions(node, scope) {
+
+            if (node.type === "FunctionDeclaration") {
+
+                // Conditional function declaration. Scope and hoisting are unpredictable, different engines work differently.
+                return false;
+            }
+
+            if (node.type !== "BlockStatement") {
+                return true;
+            }
+
+            const elseBlockScope = scope.childScopes.find(({ block }) => block === node);
+
+            if (!elseBlockScope) {
+
+                // ecmaVersion < 6, `else` block statement cannot have its own scope, no possible collisions.
+                return true;
+            }
+
+            /*
+             * elseBlockScope is supposed to merge into its upper scope. elseBlockScope.variables array contains
+             * only block-scoped variables (such as let and const variables or class and function declarations)
+             * defined directly in the elseBlockScope. These are exactly the only names that could cause collisions.
+             */
+            const namesToCheck = elseBlockScope.variables.map(({ name }) => name);
+
+            return isSafeToDeclare(namesToCheck, scope);
+        }
+
         /**
          * Display the context report if rule is violated
          *
@@ -58,10 +176,17 @@ module.exports = {
          * @returns {void}
          */
         function displayReport(node) {
+            const currentScope = context.getScope();
+
             context.report({
                 node,
                 messageId: "unexpected",
                 fix: fixer => {
+
+                    if (!isSafeFromNameCollisions(node, currentScope)) {
+                        return null;
+                    }
+
                     const sourceCode = context.getSourceCode();
                     const startToken = sourceCode.getFirstToken(node);
                     const elseToken = sourceCode.getTokenBefore(startToken);
@@ -118,6 +243,8 @@ module.exports = {
                      * Extend the replacement range to include the entire
                      * function to avoid conflicting with no-useless-return.
                      * https://github.com/eslint/eslint/issues/8026
+                     *
+                     * Also, to avoid name collisions between two else blocks.
                      */
                     return new FixTracker(fixer, sourceCode)
                         .retainEnclosingFunction(node)

package/lib/rules/no-extra-parens.js

@@ -81,6 +81,8 @@ module.exports = {
         const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" });
         const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" });
 
+        let reportsBuffer;
+
         /**
          * Determines if this rule should be enforced for a node given the current configuration.
          * @param {ASTNode} node - The node to be checked.
@@ -316,19 +318,33 @@ module.exports = {
                 }
             }
 
-            context.report({
-                node,
-                loc: leftParenToken.loc.start,
-                messageId: "unexpected",
-                fix(fixer) {
-                    const parenthesizedSource = sourceCode.text.slice(leftParenToken.range[1], rightParenToken.range[0]);
+            /**
+             * Finishes reporting
+             * @returns {void}
+             * @private
+             */
+            function finishReport() {
+                context.report({
+                    node,
+                    loc: leftParenToken.loc.start,
+                    messageId: "unexpected",
+                    fix(fixer) {
+                        const parenthesizedSource = sourceCode.text.slice(leftParenToken.range[1], rightParenToken.range[0]);
+
+                        return fixer.replaceTextRange([
+                            leftParenToken.range[0],
+                            rightParenToken.range[1]
+                        ], (requiresLeadingSpace(node) ? " " : "") + parenthesizedSource + (requiresTrailingSpace(node) ? " " : ""));
+                    }
+                });
+            }
 
-                    return fixer.replaceTextRange([
-                        leftParenToken.range[0],
-                        rightParenToken.range[1]
-                    ], (requiresLeadingSpace(node) ? " " : "") + parenthesizedSource + (requiresTrailingSpace(node) ? " " : ""));
-                }
-            });
+            if (reportsBuffer) {
+                reportsBuffer.reports.push({ node, finishReport });
+                return;
+            }
+
+            finishReport();
         }
 
         /**
@@ -498,6 +514,126 @@ module.exports = {
             }
         }
 
+        /**
+         * Finds the path from the given node to the specified ancestor.
+         * @param {ASTNode} node First node in the path.
+         * @param {ASTNode} ancestor Last node in the path.
+         * @returns {ASTNode[]} Path, including both nodes.
+         * @throws {Error} If the given node does not have the specified ancestor.
+         */
+        function pathToAncestor(node, ancestor) {
+            const path = [node];
+            let currentNode = node;
+
+            while (currentNode !== ancestor) {
+
+                currentNode = currentNode.parent;
+
+                /* istanbul ignore if */
+                if (currentNode === null) {
+                    throw new Error("Nodes are not in the ancestor-descendant relationship.");
+                }
+
+                path.push(currentNode);
+            }
+
+            return path;
+        }
+
+        /**
+         * Finds the path from the given node to the specified descendant.
+         * @param {ASTNode} node First node in the path.
+         * @param {ASTNode} descendant Last node in the path.
+         * @returns {ASTNode[]} Path, including both nodes.
+         * @throws {Error} If the given node does not have the specified descendant.
+         */
+        function pathToDescendant(node, descendant) {
+            return pathToAncestor(descendant, node).reverse();
+        }
+
+        /**
+         * Checks whether the syntax of the given ancestor of an 'in' expression inside a for-loop initializer
+         * is preventing the 'in' keyword from being interpreted as a part of an ill-formed for-in loop.
+         *
+         * @param {ASTNode} node Ancestor of an 'in' expression.
+         * @param {ASTNode} child Child of the node, ancestor of the same 'in' expression or the 'in' expression itself.
+         * @returns {boolean} True if the keyword 'in' would be interpreted as the 'in' operator, without any parenthesis.
+         */
+        function isSafelyEnclosingInExpression(node, child) {
+            switch (node.type) {
+                case "ArrayExpression":
+                case "ArrayPattern":
+                case "BlockStatement":
+                case "ObjectExpression":
+                case "ObjectPattern":
+                case "TemplateLiteral":
+                    return true;
+                case "ArrowFunctionExpression":
+                case "FunctionExpression":
+                    return node.params.includes(child);
+                case "CallExpression":
+                case "NewExpression":
+                    return node.arguments.includes(child);
+                case "MemberExpression":
+                    return node.computed && node.property === child;
+                case "ConditionalExpression":
+                    return node.consequent === child;
+                default:
+                    return false;
+            }
+        }
+
+        /**
+         * Starts a new reports buffering. Warnings will be stored in a buffer instead of being reported immediately.
+         * An additional logic that requires multiple nodes (e.g. a whole subtree) may dismiss some of the stored warnings.
+         *
+         * @returns {void}
+         */
+        function startNewReportsBuffering() {
+            reportsBuffer = {
+                upper: reportsBuffer,
+                inExpressionNodes: [],
+                reports: []
+            };
+        }
+
+        /**
+         * Ends the current reports buffering.
+         * @returns {void}
+         */
+        function endCurrentReportsBuffering() {
+            const { upper, inExpressionNodes, reports } = reportsBuffer;
+
+            if (upper) {
+                upper.inExpressionNodes.push(...inExpressionNodes);
+                upper.reports.push(...reports);
+            } else {
+
+                // flush remaining reports
+                reports.forEach(({ finishReport }) => finishReport());
+            }
+
+            reportsBuffer = upper;
+        }
+
+        /**
+         * Checks whether the given node is in the current reports buffer.
+         * @param {ASTNode} node Node to check.
+         * @returns {boolean} True if the node is in the current buffer, false otherwise.
+         */
+        function isInCurrentReportsBuffer(node) {
+            return reportsBuffer.reports.some(r => r.node === node);
+        }
+
+        /**
+         * Removes the given node from the current reports buffer.
+         * @param {ASTNode} node Node to remove.
+         * @returns {void}
+         */
+        function removeFromCurrentReportsBuffer(node) {
+            reportsBuffer.reports = reportsBuffer.reports.filter(r => r.node !== node);
+        }
+
         return {
             ArrayExpression(node) {
                 node.elements
@@ -540,7 +676,14 @@ module.exports = {
                 }
             },
 
-            BinaryExpression: checkBinaryLogical,
+            BinaryExpression(node) {
+                if (reportsBuffer && node.operator === "in") {
+                    reportsBuffer.inExpressionNodes.push(node);
+                }
+
+                checkBinaryLogical(node);
+            },
+
             CallExpression: checkCallNew,
 
             ConditionalExpression(node) {
@@ -602,10 +745,6 @@ module.exports = {
             },
 
             ForStatement(node) {
-                if (node.init && hasExcessParens(node.init)) {
-                    report(node.init);
-                }
-
                 if (node.test && hasExcessParens(node.test) && !isCondAssignException(node)) {
                     report(node.test);
                 }
@@ -613,6 +752,81 @@ module.exports = {
                 if (node.update && hasExcessParens(node.update)) {
                     report(node.update);
                 }
+
+                if (node.init) {
+                    startNewReportsBuffering();
+
+                    if (hasExcessParens(node.init)) {
+                        report(node.init);
+                    }
+                }
+            },
+
+            "ForStatement > *.init:exit"(node) {
+
+                /*
+                 * Removing parentheses around `in` expressions might change semantics and cause errors.
+                 *
+                 * For example, this valid for loop:
+                 *      for (let a = (b in c); ;);
+                 * after removing parentheses would be treated as an invalid for-in loop:
+                 *      for (let a = b in c; ;);
+                 */
+
+                if (reportsBuffer.reports.length) {
+                    reportsBuffer.inExpressionNodes.forEach(inExpressionNode => {
+                        const path = pathToDescendant(node, inExpressionNode);
+                        let nodeToExclude;
+
+                        for (let i = 0; i < path.length; i++) {
+                            const pathNode = path[i];
+
+                            if (i < path.length - 1) {
+                                const nextPathNode = path[i + 1];
+
+                                if (isSafelyEnclosingInExpression(pathNode, nextPathNode)) {
+
+                                    // The 'in' expression in safely enclosed by the syntax of its ancestor nodes (e.g. by '{}' or '[]').
+                                    return;
+                                }
+                            }
+
+                            if (isParenthesised(pathNode)) {
+                                if (isInCurrentReportsBuffer(pathNode)) {
+
+                                    // This node was supposed to be reported, but parentheses might be necessary.
+
+                                    if (isParenthesisedTwice(pathNode)) {
+
+                                        /*
+                                         * This node is parenthesised twice, it certainly has at least one pair of `extra` parentheses.
+                                         * If the --fix option is on, the current fixing iteration will remove only one pair of parentheses.
+                                         * The remaining pair is safely enclosing the 'in' expression.
+                                         */
+                                        return;
+                                    }
+
+                                    // Exclude the outermost node only.
+                                    if (!nodeToExclude) {
+                                        nodeToExclude = pathNode;
+                                    }
+
+                                    // Don't break the loop here, there might be some safe nodes or parentheses that will stay inside.
+
+                                } else {
+
+                                    // This node will stay parenthesised, the 'in' expression in safely enclosed by '()'.
+                                    return;
+                                }
+                            }
+                        }
+
+                        // Exclude the node from the list (i.e. treat parentheses as necessary)
+                        removeFromCurrentReportsBuffer(nodeToExclude);
+                    });
+                }
+
+                endCurrentReportsBuffering();
             },
 
             IfStatement(node) {
@@ -664,6 +878,16 @@ module.exports = {
                     }).forEach(property => report(property.value));
             },
 
+            Property(node) {
+                if (node.computed) {
+                    const { key } = node;
+
+                    if (key && hasExcessParens(key) && precedence(key) >= PRECEDENCE_OF_ASSIGNMENT_EXPR) {
+                        report(key);
+                    }
+                }
+            },
+
             ReturnStatement(node) {
                 const returnToken = sourceCode.getFirstToken(node);
 

package/lib/rules/no-octal.js

@@ -28,7 +28,7 @@ module.exports = {
         return {
 
             Literal(node) {
-                if (typeof node.value === "number" && /^0[0-7]/u.test(node.raw)) {
+                if (typeof node.value === "number" && /^0[0-9]/u.test(node.raw)) {
                     context.report({ node, message: "Octal literals should not be used." });
                 }
             }

package/lib/rules/no-param-reassign.js

@@ -67,7 +67,8 @@ module.exports = {
             let node = reference.identifier;
             let parent = node.parent;
 
-            while (parent && !stopNodePattern.test(parent.type)) {
+            while (parent && (!stopNodePattern.test(parent.type) ||
+                    parent.type === "ForInStatement" || parent.type === "ForOfStatement")) {
                 switch (parent.type) {
 
                     // e.g. foo.a = 0;
@@ -85,6 +86,16 @@ module.exports = {
                         }
                         break;
 
+                    // e.g. for (foo.a in b) {}
+                    case "ForInStatement":
+                    case "ForOfStatement":
+                        if (parent.left === node) {
+                            return true;
+                        }
+
+                        // this is a stop node for parent.right and parent.body
+                        return false;
+
                     // EXCLUDES: e.g. cache.get(foo.a).b = 0;
                     case "CallExpression":
                         if (parent.callee !== node) {