eslint 5.6.0 → 5.9.0

package/lib/rules/require-atomic-updates.js

@@ -12,14 +12,18 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "problem",
+
         docs: {
             description: "disallow assignments that can lead to race conditions due to usage of `await` or `yield`",
             category: "Possible Errors",
             recommended: false,
             url: "https://eslint.org/docs/rules/require-atomic-updates"
         },
+
         fixable: null,
         schema: [],
+
         messages: {
             nonAtomicUpdate: "Possible race condition: `{{value}}` might be reassigned based on an outdated value of `{{value}}`."
         }
@@ -119,6 +123,66 @@ module.exports = {
             });
         }
 
+        const alreadyReportedAssignments = new WeakSet();
+
+        class AssignmentTrackerState {
+            constructor({ openAssignmentsWithoutReads = new Set(), openAssignmentsWithReads = new Set() } = {}) {
+                this.openAssignmentsWithoutReads = openAssignmentsWithoutReads;
+                this.openAssignmentsWithReads = openAssignmentsWithReads;
+            }
+
+            copy() {
+                return new AssignmentTrackerState({
+                    openAssignmentsWithoutReads: new Set(this.openAssignmentsWithoutReads),
+                    openAssignmentsWithReads: new Set(this.openAssignmentsWithReads)
+                });
+            }
+
+            merge(other) {
+                const initialAssignmentsWithoutReadsCount = this.openAssignmentsWithoutReads.size;
+                const initialAssignmentsWithReadsCount = this.openAssignmentsWithReads.size;
+
+                other.openAssignmentsWithoutReads.forEach(assignment => this.openAssignmentsWithoutReads.add(assignment));
+                other.openAssignmentsWithReads.forEach(assignment => this.openAssignmentsWithReads.add(assignment));
+
+                return this.openAssignmentsWithoutReads.size > initialAssignmentsWithoutReadsCount ||
+                    this.openAssignmentsWithReads.size > initialAssignmentsWithReadsCount;
+            }
+
+            enterAssignment(assignmentExpression) {
+                (assignmentExpression.operator === "=" ? this.openAssignmentsWithoutReads : this.openAssignmentsWithReads).add(assignmentExpression);
+            }
+
+            exitAssignment(assignmentExpression) {
+                this.openAssignmentsWithoutReads.delete(assignmentExpression);
+                this.openAssignmentsWithReads.delete(assignmentExpression);
+            }
+
+            exitAwaitOrYield(node, surroundingFunction) {
+                return [...this.openAssignmentsWithReads]
+                    .filter(assignment => !isLocalVariableWithoutEscape(assignment.left, surroundingFunction))
+                    .forEach(assignment => {
+                        if (!alreadyReportedAssignments.has(assignment)) {
+                            reportAssignment(assignment);
+                            alreadyReportedAssignments.add(assignment);
+                        }
+                    });
+            }
+
+            exitIdentifierOrMemberExpression(node) {
+                [...this.openAssignmentsWithoutReads]
+                    .filter(assignment => (
+                        assignment.left !== node &&
+                        assignment.left.type === node.type &&
+                        astUtils.equalTokens(assignment.left, node, sourceCode)
+                    ))
+                    .forEach(assignment => {
+                        this.openAssignmentsWithoutReads.delete(assignment);
+                        this.openAssignmentsWithReads.add(assignment);
+                    });
+            }
+        }
+
         /**
          * If the control flow graph of a function enters an assignment expression, then does the
          * both of the following steps in order (possibly with other steps in between) before exiting the
@@ -135,54 +199,51 @@ module.exports = {
             codePathSegment,
             surroundingFunction,
             {
-                seenSegments = new Set(),
-                openAssignmentsWithoutReads = new Set(),
-                openAssignmentsWithReads = new Set()
+                stateBySegmentStart = new WeakMap(),
+                stateBySegmentEnd = new WeakMap()
             } = {}
         ) {
-            if (seenSegments.has(codePathSegment)) {
-
-                // An AssignmentExpression can't contain loops, so it's not necessary to reenter them with new state.
-                return;
+            if (!stateBySegmentStart.has(codePathSegment)) {
+                stateBySegmentStart.set(codePathSegment, new AssignmentTrackerState());
             }
 
+            const currentState = stateBySegmentStart.get(codePathSegment).copy();
+
             expressionsByCodePathSegment.get(codePathSegment).forEach(({ entering, node }) => {
                 if (node.type === "AssignmentExpression") {
                     if (entering) {
-                        (node.operator === "=" ? openAssignmentsWithoutReads : openAssignmentsWithReads).add(node);
+                        currentState.enterAssignment(node);
                     } else {
-                        openAssignmentsWithoutReads.delete(node);
-                        openAssignmentsWithReads.delete(node);
+                        currentState.exitAssignment(node);
                     }
                 } else if (!entering && (node.type === "AwaitExpression" || node.type === "YieldExpression")) {
-                    [...openAssignmentsWithReads]
-                        .filter(assignment => !isLocalVariableWithoutEscape(assignment.left, surroundingFunction))
-                        .forEach(reportAssignment);
-
-                    openAssignmentsWithReads.clear();
+                    currentState.exitAwaitOrYield(node, surroundingFunction);
                 } else if (!entering && (node.type === "Identifier" || node.type === "MemberExpression")) {
-                    [...openAssignmentsWithoutReads]
-                        .filter(assignment => (
-                            assignment.left !== node &&
-                            assignment.left.type === node.type &&
-                            astUtils.equalTokens(assignment.left, node, sourceCode)
-                        ))
-                        .forEach(assignment => {
-                            openAssignmentsWithoutReads.delete(assignment);
-                            openAssignmentsWithReads.add(assignment);
-                        });
+                    currentState.exitIdentifierOrMemberExpression(node);
                 }
             });
 
+            stateBySegmentEnd.set(codePathSegment, currentState);
+
             codePathSegment.nextSegments.forEach(nextSegment => {
+                if (stateBySegmentStart.has(nextSegment)) {
+                    if (!stateBySegmentStart.get(nextSegment).merge(currentState)) {
+
+                        /*
+                         * This segment has already been processed with the given set of inputs;
+                         * no need to do it again. After no new state is available to process
+                         * for any control flow segment in the graph, the analysis reaches a fixpoint and
+                         * traversal stops.
+                         */
+                        return;
+                    }
+                } else {
+                    stateBySegmentStart.set(nextSegment, currentState.copy());
+                }
                 findOutdatedReads(
                     nextSegment,
                     surroundingFunction,
-                    {
-                        seenSegments: new Set(seenSegments).add(codePathSegment),
-                        openAssignmentsWithoutReads: new Set(openAssignmentsWithoutReads),
-                        openAssignmentsWithReads: new Set(openAssignmentsWithReads)
-                    }
+                    { stateBySegmentStart, stateBySegmentEnd }
                 );
             });
         }

package/lib/rules/require-await.js

@@ -31,12 +31,15 @@ function capitalizeFirstLetter(text) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow async functions which have no `await` expression",
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/require-await"
         },
+
         schema: []
     },
 

package/lib/rules/require-jsdoc.js

@@ -6,6 +6,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require JSDoc comments",
             category: "Stylistic Issues",

package/lib/rules/require-unicode-regexp.js

@@ -22,15 +22,19 @@ const {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "enforce the use of `u` flag on RegExp",
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/require-unicode-regexp"
         },
+
         messages: {
             requireUFlag: "Use the 'u' flag."
         },
+
         schema: []
     },
 

package/lib/rules/require-yield.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require generator functions to contain `yield`",
             category: "ECMAScript 6",

package/lib/rules/rest-spread-spacing.js

@@ -11,13 +11,17 @@
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce spacing between rest and spread operators and their expressions",
             category: "ECMAScript 6",
             recommended: false,
             url: "https://eslint.org/docs/rules/rest-spread-spacing"
         },
+
         fixable: "whitespace",
+
         schema: [
             {
                 enum: ["always", "never"]

package/lib/rules/semi-spacing.js

@@ -13,6 +13,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent spacing before and after semicolons",
             category: "Stylistic Issues",

package/lib/rules/semi-style.js

@@ -65,12 +65,15 @@ function isLastChild(node) {
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce location of semicolons",
             category: "Stylistic Issues",
             recommended: false,
             url: "https://eslint.org/docs/rules/semi-style"
         },
+
         schema: [{ enum: ["last", "first"] }],
         fixable: "whitespace"
     },

package/lib/rules/semi.js

@@ -17,6 +17,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require or disallow semicolons instead of ASI",
             category: "Stylistic Issues",

package/lib/rules/sort-imports.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "enforce sorted import declarations within modules",
             category: "ECMAScript 6",

package/lib/rules/sort-keys.js

@@ -73,12 +73,15 @@ const isValidOrders = {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require object keys to be sorted",
             category: "Stylistic Issues",
             recommended: false,
             url: "https://eslint.org/docs/rules/sort-keys"
         },
+
         schema: [
             {
                 enum: ["asc", "desc"]

package/lib/rules/sort-vars.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require variables within the same declaration block to be sorted",
             category: "Stylistic Issues",

package/lib/rules/space-before-blocks.js

@@ -13,6 +13,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent spacing before blocks",
             category: "Stylistic Issues",
@@ -32,13 +34,13 @@ module.exports = {
                         type: "object",
                         properties: {
                             keywords: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "off"]
                             },
                             functions: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "off"]
                             },
                             classes: {
-                                enum: ["always", "never"]
+                                enum: ["always", "never", "off"]
                             }
                         },
                         additionalProperties: false
@@ -51,18 +53,27 @@ module.exports = {
     create(context) {
         const config = context.options[0],
             sourceCode = context.getSourceCode();
-        let checkFunctions = true,
-            checkKeywords = true,
-            checkClasses = true;
+        let alwaysFunctions = true,
+            alwaysKeywords = true,
+            alwaysClasses = true,
+            neverFunctions = false,
+            neverKeywords = false,
+            neverClasses = false;
 
         if (typeof config === "object") {
-            checkFunctions = config.functions !== "never";
-            checkKeywords = config.keywords !== "never";
-            checkClasses = config.classes !== "never";
+            alwaysFunctions = config.functions === "always";
+            alwaysKeywords = config.keywords === "always";
+            alwaysClasses = config.classes === "always";
+            neverFunctions = config.functions === "never";
+            neverKeywords = config.keywords === "never";
+            neverClasses = config.classes === "never";
         } else if (config === "never") {
-            checkFunctions = false;
-            checkKeywords = false;
-            checkClasses = false;
+            alwaysFunctions = false;
+            alwaysKeywords = false;
+            alwaysClasses = false;
+            neverFunctions = true;
+            neverKeywords = true;
+            neverClasses = true;
         }
 
         /**
@@ -88,35 +99,35 @@ module.exports = {
                 const hasSpace = sourceCode.isSpaceBetweenTokens(precedingToken, node);
                 const parent = context.getAncestors().pop();
                 let requireSpace;
+                let requireNoSpace;
 
                 if (parent.type === "FunctionExpression" || parent.type === "FunctionDeclaration") {
-                    requireSpace = checkFunctions;
+                    requireSpace = alwaysFunctions;
+                    requireNoSpace = neverFunctions;
                 } else if (node.type === "ClassBody") {
-                    requireSpace = checkClasses;
+                    requireSpace = alwaysClasses;
+                    requireNoSpace = neverClasses;
                 } else {
-                    requireSpace = checkKeywords;
+                    requireSpace = alwaysKeywords;
+                    requireNoSpace = neverKeywords;
                 }
 
-                if (requireSpace) {
-                    if (!hasSpace) {
-                        context.report({
-                            node,
-                            message: "Missing space before opening brace.",
-                            fix(fixer) {
-                                return fixer.insertTextBefore(node, " ");
-                            }
-                        });
-                    }
-                } else {
-                    if (hasSpace) {
-                        context.report({
-                            node,
-                            message: "Unexpected space before opening brace.",
-                            fix(fixer) {
-                                return fixer.removeRange([precedingToken.range[1], node.range[0]]);
-                            }
-                        });
-                    }
+                if (requireSpace && !hasSpace) {
+                    context.report({
+                        node,
+                        message: "Missing space before opening brace.",
+                        fix(fixer) {
+                            return fixer.insertTextBefore(node, " ");
+                        }
+                    });
+                } else if (requireNoSpace && hasSpace) {
+                    context.report({
+                        node,
+                        message: "Unexpected space before opening brace.",
+                        fix(fixer) {
+                            return fixer.removeRange([precedingToken.range[1], node.range[0]]);
+                        }
+                    });
                 }
             }
         }

package/lib/rules/space-before-function-paren.js

@@ -16,6 +16,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent spacing before `function` definition opening parenthesis",
             category: "Stylistic Issues",

package/lib/rules/space-in-parens.js

@@ -12,6 +12,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent spacing inside parentheses",
             category: "Stylistic Issues",

package/lib/rules/space-infix-ops.js

@@ -10,6 +10,8 @@
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require spacing around infix operators",
             category: "Stylistic Issues",
@@ -34,37 +36,25 @@ module.exports = {
 
     create(context) {
         const int32Hint = context.options[0] ? context.options[0].int32Hint === true : false;
-
-        const OPERATORS = [
-            "*", "/", "%", "+", "-", "<<", ">>", ">>>", "<", "<=", ">", ">=", "in",
-            "instanceof", "==", "!=", "===", "!==", "&", "^", "|", "&&", "||", "=",
-            "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "&=", "^=", "|=",
-            "?", ":", ",", "**"
-        ];
-
         const sourceCode = context.getSourceCode();
 
         /**
          * Returns the first token which violates the rule
          * @param {ASTNode} left - The left node of the main node
          * @param {ASTNode} right - The right node of the main node
+         * @param {string} op - The operator of the main node
          * @returns {Object} The violator token or null
          * @private
          */
-        function getFirstNonSpacedToken(left, right) {
-            const tokens = sourceCode.getTokensBetween(left, right, 1);
-
-            for (let i = 1, l = tokens.length - 1; i < l; ++i) {
-                const op = tokens[i];
-
-                if (
-                    (op.type === "Punctuator" || op.type === "Keyword") &&
-                    OPERATORS.indexOf(op.value) >= 0 &&
-                    (tokens[i - 1].range[1] >= op.range[0] || op.range[1] >= tokens[i + 1].range[0])
-                ) {
-                    return op;
-                }
+        function getFirstNonSpacedToken(left, right, op) {
+            const operator = sourceCode.getFirstTokenBetween(left, right, token => token.value === op);
+            const prev = sourceCode.getTokenBefore(operator);
+            const next = sourceCode.getTokenAfter(operator);
+
+            if (!sourceCode.isSpaceBetweenTokens(prev, operator) || !sourceCode.isSpaceBetweenTokens(operator, next)) {
+                return operator;
             }
+
             return null;
         }
 
@@ -110,7 +100,10 @@ module.exports = {
             const leftNode = (node.left.typeAnnotation) ? node.left.typeAnnotation : node.left;
             const rightNode = node.right;
 
-            const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode);
+            // search for = in AssignmentPattern nodes
+            const operator = node.operator || "=";
+
+            const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, operator);
 
             if (nonSpacedNode) {
                 if (!(int32Hint && sourceCode.getText(node).endsWith("|0"))) {
@@ -126,8 +119,8 @@ module.exports = {
          * @private
          */
         function checkConditional(node) {
-            const nonSpacedConsequesntNode = getFirstNonSpacedToken(node.test, node.consequent);
-            const nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate);
+            const nonSpacedConsequesntNode = getFirstNonSpacedToken(node.test, node.consequent, "?");
+            const nonSpacedAlternateNode = getFirstNonSpacedToken(node.consequent, node.alternate, ":");
 
             if (nonSpacedConsequesntNode) {
                 report(node, nonSpacedConsequesntNode);
@@ -147,7 +140,7 @@ module.exports = {
             const rightNode = node.init;
 
             if (rightNode) {
-                const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode);
+                const nonSpacedNode = getFirstNonSpacedToken(leftNode, rightNode, "=");
 
                 if (nonSpacedNode) {
                     report(node, nonSpacedNode);

package/lib/rules/space-unary-ops.js

@@ -16,6 +16,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent spacing before or after unary operators",
             category: "Stylistic Issues",

package/lib/rules/spaced-comment.js

@@ -151,6 +151,8 @@ function createNeverStylePattern(markers) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "enforce consistent spacing after the `//` or `/*` in a comment",
             category: "Stylistic Issues",

package/lib/rules/strict.js

@@ -80,6 +80,8 @@ function isSimpleParameterList(params) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require or disallow strict mode directives",
             category: "Strict Mode",

package/lib/rules/switch-colon-spacing.js

@@ -17,12 +17,15 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce spacing around colons of switch statements",
             category: "Stylistic Issues",
             recommended: false,
             url: "https://eslint.org/docs/rules/switch-colon-spacing"
         },
+
         schema: [
             {
                 type: "object",
@@ -33,6 +36,7 @@ module.exports = {
                 additionalProperties: false
             }
         ],
+
         fixable: "whitespace"
     },
 

package/lib/rules/symbol-description.js

@@ -18,6 +18,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require symbol descriptions",
             category: "ECMAScript 6",

package/lib/rules/template-curly-spacing.js

@@ -24,6 +24,8 @@ const CLOSE_PAREN = /^\}/;
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require or disallow spacing around embedded expressions of template strings",
             category: "ECMAScript 6",

package/lib/rules/template-tag-spacing.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require or disallow spacing between template tags and their literals",
             category: "Stylistic Issues",

package/lib/rules/unicode-bom.js

@@ -10,6 +10,8 @@
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require or disallow Unicode byte order mark (BOM)",
             category: "Stylistic Issues",

package/lib/rules/use-isnan.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "problem",
+
         docs: {
             description: "require calls to `isNaN()` when checking for `NaN`",
             category: "Possible Errors",

package/lib/rules/valid-jsdoc.js

@@ -16,6 +16,8 @@ const doctrine = require("doctrine");
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "enforce valid JSDoc comments",
             category: "Possible Errors",