eslint 6.0.0-alpha.1 → 6.0.1

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

@@ -24,12 +24,51 @@ function createReferenceMap(scope, outReferenceMap = new Map()) {
     return outReferenceMap;
 }
 
+/**
+ * Get `reference.writeExpr` of a given reference.
+ * If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a`
+ * @param {escope.Reference} reference The reference to get.
+ * @returns {Expression|null} The `reference.writeExpr`.
+ */
+function getWriteExpr(reference) {
+    if (reference.writeExpr) {
+        return reference.writeExpr;
+    }
+    let node = reference.identifier;
+
+    while (node) {
+        const t = node.parent.type;
+
+        if (t === "AssignmentExpression" && node.parent.left === node) {
+            return node.parent.right;
+        }
+        if (t === "MemberExpression" && node.parent.object === node) {
+            node = node.parent;
+            continue;
+        }
+
+        break;
+    }
+
+    return null;
+}
+
 /**
  * Checks if an expression is a variable that can only be observed within the given function.
- * @param {escope.Variable} variable The variable to check
+ * @param {Variable|null} variable The variable to check
+ * @param {boolean} isMemberAccess If `true` then this is a member access.
  * @returns {boolean} `true` if the variable is local to the given function, and is never referenced in a closure.
  */
-function isLocalVariableWithoutEscape(variable) {
+function isLocalVariableWithoutEscape(variable, isMemberAccess) {
+    if (!variable) {
+        return false; // A global variable which was not defined.
+    }
+
+    // If the reference is a property access and the variable is a parameter, it handles the variable is not local.
+    if (isMemberAccess && variable.defs.some(d => d.type === "Parameter")) {
+        return false;
+    }
+
     const functionScope = variable.scope.variableScope;
 
     return variable.references.every(reference =>
@@ -47,52 +86,49 @@ class SegmentInfo {
      * @returns {void}
      */
     initialize(segment) {
-        const outdatedReadVariables = new Set();
-        const freshReadVariables = new Set();
+        const outdatedReadVariableNames = new Set();
+        const freshReadVariableNames = new Set();
 
         for (const prevSegment of segment.prevSegments) {
             const info = this.info.get(prevSegment);
 
             if (info) {
-                info.outdatedReadVariables.forEach(Set.prototype.add, outdatedReadVariables);
-                info.freshReadVariables.forEach(Set.prototype.add, freshReadVariables);
+                info.outdatedReadVariableNames.forEach(Set.prototype.add, outdatedReadVariableNames);
+                info.freshReadVariableNames.forEach(Set.prototype.add, freshReadVariableNames);
             }
         }
 
-        this.info.set(segment, { outdatedReadVariables, freshReadVariables });
+        this.info.set(segment, { outdatedReadVariableNames, freshReadVariableNames });
     }
 
     /**
      * Mark a given variable as read on given segments.
      * @param {PathSegment[]} segments The segments that it read the variable on.
-     * @param {escope.Variable} variable The variable to be read.
+     * @param {string} variableName The variable name to be read.
      * @returns {void}
      */
-    markAsRead(segments, variable) {
+    markAsRead(segments, variableName) {
         for (const segment of segments) {
             const info = this.info.get(segment);
 
             if (info) {
-                info.freshReadVariables.add(variable);
+                info.freshReadVariableNames.add(variableName);
             }
         }
     }
 
     /**
-     * Move `freshReadVariables` to `outdatedReadVariables`.
+     * Move `freshReadVariableNames` to `outdatedReadVariableNames`.
      * @param {PathSegment[]} segments The segments to process.
      * @returns {void}
      */
     makeOutdated(segments) {
-        const vars = new Set();
-
         for (const segment of segments) {
             const info = this.info.get(segment);
 
             if (info) {
-                info.freshReadVariables.forEach(Set.prototype.add, info.outdatedReadVariables);
-                info.freshReadVariables.forEach(Set.prototype.add, vars);
-                info.freshReadVariables.clear();
+                info.freshReadVariableNames.forEach(Set.prototype.add, info.outdatedReadVariableNames);
+                info.freshReadVariableNames.clear();
             }
         }
     }
@@ -100,14 +136,14 @@ class SegmentInfo {
     /**
      * Check if a given variable is outdated on the current segments.
      * @param {PathSegment[]} segments The current segments.
-     * @param {escope.Variable} variable The variable to check.
+     * @param {string} variableName The variable name to check.
      * @returns {boolean} `true` if the variable is outdated on the segments.
      */
-    isOutdated(segments, variable) {
+    isOutdated(segments, variableName) {
         for (const segment of segments) {
             const info = this.info.get(segment);
 
-            if (info && info.outdatedReadVariables.has(variable)) {
+            if (info && info.outdatedReadVariableNames.has(variableName)) {
                 return true;
             }
         }
@@ -140,69 +176,10 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.getSourceCode();
-        const globalScope = context.getScope();
-        const dummyVariables = new Map();
         const assignmentReferences = new Map();
         const segmentInfo = new SegmentInfo();
         let stack = null;
 
-        /**
-         * Get the variable of a given reference.
-         * If it's not defined, returns a dummy object.
-         * @param {escope.Reference} reference The reference to get.
-         * @returns {escope.Variable} The variable of the reference.
-         */
-        function getVariable(reference) {
-            if (reference.resolved) {
-                return reference.resolved;
-            }
-
-            // Get or create a dummy.
-            const name = reference.identifier.name;
-            let variable = dummyVariables.get(name);
-
-            if (!variable) {
-                variable = {
-                    name,
-                    scope: globalScope,
-                    references: []
-                };
-                dummyVariables.set(name, variable);
-            }
-            variable.references.push(reference);
-
-            return variable;
-        }
-
-        /**
-         * Get `reference.writeExpr` of a given reference.
-         * If it's the read reference of MemberExpression in LHS, returns RHS in order to address `a.b = await a`
-         * @param {escope.Reference} reference The reference to get.
-         * @returns {Expression|null} The `reference.writeExpr`.
-         */
-        function getWriteExpr(reference) {
-            if (reference.writeExpr) {
-                return reference.writeExpr;
-            }
-            let node = reference.identifier;
-
-            while (node) {
-                const t = node.parent.type;
-
-                if (t === "AssignmentExpression" && node.parent.left === node) {
-                    return node.parent.right;
-                }
-                if (t === "MemberExpression" && node.parent.object === node) {
-                    node = node.parent;
-                    continue;
-                }
-
-                break;
-            }
-
-            return null;
-        }
-
         return {
             onCodePathStart(codePath) {
                 const scope = context.getScope();
@@ -234,12 +211,14 @@ module.exports = {
                 if (!reference) {
                     return;
                 }
-                const variable = getVariable(reference);
+                const name = reference.identifier.name;
+                const variable = reference.resolved;
                 const writeExpr = getWriteExpr(reference);
+                const isMemberAccess = reference.identifier.parent.type === "MemberExpression";
 
                 // Add a fresh read variable.
                 if (reference.isRead() && !(writeExpr && writeExpr.parent.operator === "=")) {
-                    segmentInfo.markAsRead(codePath.currentSegments, variable);
+                    segmentInfo.markAsRead(codePath.currentSegments, name);
                 }
 
                 /*
@@ -248,7 +227,7 @@ module.exports = {
                  */
                 if (writeExpr &&
                     writeExpr.parent.right === writeExpr && // ← exclude variable declarations.
-                    !isLocalVariableWithoutEscape(variable)
+                    !isLocalVariableWithoutEscape(variable, isMemberAccess)
                 ) {
                     let refs = assignmentReferences.get(writeExpr);
 
@@ -263,7 +242,7 @@ module.exports = {
 
             /*
              * Verify assignments.
-             * If the reference exists in `outdatedReadVariables` list, report it.
+             * If the reference exists in `outdatedReadVariableNames` list, report it.
              */
             ":expression:exit"(node) {
                 const { codePath, referenceMap } = stack;
@@ -285,9 +264,9 @@ module.exports = {
                     assignmentReferences.delete(node);
 
                     for (const reference of references) {
-                        const variable = getVariable(reference);
+                        const name = reference.identifier.name;
 
-                        if (segmentInfo.isOutdated(codePath.currentSegments, variable)) {
+                        if (segmentInfo.isOutdated(codePath.currentSegments, name)) {
                             context.report({
                                 node: node.parent,
                                 messageId: "nonAtomicUpdate",

package/lib/rules/require-await.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers

package/lib/rules/semi-spacing.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/semi-style.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/semi.js

@@ -8,8 +8,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const FixTracker = require("../util/fix-tracker");
-const astUtils = require("../util/ast-utils");
+const FixTracker = require("./utils/fix-tracker");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/sort-keys.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils"),
+const astUtils = require("./utils/ast-utils"),
     naturalCompare = require("natural-compare");
 
 //------------------------------------------------------------------------------
@@ -96,6 +96,11 @@ module.exports = {
                     natural: {
                         type: "boolean",
                         default: false
+                    },
+                    minKeys: {
+                        type: "integer",
+                        minimum: 2,
+                        default: 2
                     }
                 },
                 additionalProperties: false
@@ -110,6 +115,7 @@ module.exports = {
         const options = context.options[1];
         const insensitive = options && options.caseSensitive === false;
         const natual = options && options.natural;
+        const minKeys = options && options.minKeys;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natual ? "N" : "")
         ];
@@ -118,10 +124,11 @@ module.exports = {
         let stack = null;
 
         return {
-            ObjectExpression() {
+            ObjectExpression(node) {
                 stack = {
                     upper: stack,
-                    prevName: null
+                    prevName: null,
+                    numKeys: node.properties.length
                 };
             },
 
@@ -141,11 +148,12 @@ module.exports = {
                 }
 
                 const prevName = stack.prevName;
+                const numKeys = stack.numKeys;
                 const thisName = getPropertyName(node);
 
                 stack.prevName = thisName || prevName;
 
-                if (!prevName || !thisName) {
+                if (!prevName || !thisName || numKeys < minKeys) {
                     return;
                 }
 

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

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

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

@@ -8,7 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

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

@@ -4,7 +4,7 @@
  */
 "use strict";
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

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

@@ -8,7 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/spaced-comment.js

@@ -5,7 +5,7 @@
 "use strict";
 
 const lodash = require("lodash");
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers

package/lib/rules/strict.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers

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

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/symbol-description.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

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

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers

package/lib/{util → rules/utils}/ast-utils.js

@@ -12,6 +12,12 @@
 const esutils = require("esutils");
 const espree = require("espree");
 const lodash = require("lodash");
+const {
+    breakableTypePattern,
+    createGlobalLinebreakMatcher,
+    lineBreakPattern,
+    shebangPattern
+} = require("../../shared/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -22,14 +28,11 @@ const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
 const arrayOrTypedArrayPattern = /Array$/u;
 const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;
 const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
-const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
 const thisTagPattern = /^[\s*]*@this/mu;
 
 
 const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
 const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
-const LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/u;
-const SHEBANG_MATCHER = /^#!([^\r\n]+)/u;
 
 // A set of node types that can contain a list of statements
 const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);
@@ -393,15 +396,6 @@ function getOpeningParenOfParams(node, sourceCode) {
         : sourceCode.getFirstToken(node, isOpeningParenToken);
 }
 
-/**
- * Creates a version of the LINEBREAK_MATCHER regex with the global flag.
- * Global regexes are mutable, so this needs to be a function instead of a constant.
- * @returns {RegExp} A global regular expression that matches line terminators
- */
-function createGlobalLinebreakMatcher() {
-    return new RegExp(LINEBREAK_MATCHER.source, "gu");
-}
-
 /**
  * Checks whether or not the tokens of two given nodes are same.
  * @param {ASTNode} left - A node 1 to compare.
@@ -434,8 +428,8 @@ function equalTokens(left, right, sourceCode) {
 module.exports = {
     COMMENTS_IGNORE_PATTERN,
     LINEBREAKS,
-    LINEBREAK_MATCHER,
-    SHEBANG_MATCHER,
+    LINEBREAK_MATCHER: lineBreakPattern,
+    SHEBANG_MATCHER: shebangPattern,
     STATEMENT_LIST_PARENTS,
 
     /**
@@ -513,19 +507,6 @@ module.exports = {
         return breakableTypePattern.test(node.type);
     },
 
-    /**
-     * Gets the label if the parent node of a given node is a LabeledStatement.
-     *
-     * @param {ASTNode} node - A node to get.
-     * @returns {string|null} The label or `null`.
-     */
-    getLabel(node) {
-        if (node.parent.type === "LabeledStatement") {
-            return node.parent.label.name;
-        }
-        return null;
-    },
-
     /**
      * Gets references which are non initializer and writable.
      * @param {Reference[]} references - An array of references.

package/lib/{util → rules/utils}/fix-tracker.js

@@ -8,7 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./ast-utils");
 
 //------------------------------------------------------------------------------
 // Public Interface

package/lib/rules/valid-typeof.js

@@ -39,7 +39,7 @@ module.exports = {
 
     create(context) {
 
-        const VALID_TYPES = ["symbol", "undefined", "object", "boolean", "number", "string", "function"],
+        const VALID_TYPES = ["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"],
             OPERATORS = ["==", "===", "!=", "!=="];
 
         const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;

package/lib/rules/wrap-iife.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/yoda.js

@@ -8,7 +8,7 @@
 // Requirements
 //--------------------------------------------------------------------------
 
-const astUtils = require("../util/ast-utils");
+const astUtils = require("./utils/ast-utils");
 
 //--------------------------------------------------------------------------
 // Helpers

package/lib/shared/ast-utils.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Common utils for AST.
+ *
+ * This file contains only shared items for core and rules.
+ * If you make a utility for rules, please see `../rules/utils/ast-utils.js`.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
+const lineBreakPattern = /\r\n|[\r\n\u2028\u2029]/u;
+const shebangPattern = /^#!([^\r\n]+)/u;
+
+/**
+ * Creates a version of the `lineBreakPattern` regex with the global flag.
+ * Global regexes are mutable, so this needs to be a function instead of a constant.
+ * @returns {RegExp} A global regular expression that matches line terminators
+ */
+function createGlobalLinebreakMatcher() {
+    return new RegExp(lineBreakPattern.source, "gu");
+}
+
+module.exports = {
+    breakableTypePattern,
+    lineBreakPattern,
+    createGlobalLinebreakMatcher,
+    shebangPattern
+};