eslint 6.0.0-alpha.2 → 6.1.0

package/lib/rules/no-restricted-imports.js

@@ -4,13 +4,6 @@
  */
 "use strict";
 
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const DEFAULT_MESSAGE_TEMPLATE = "'{{importSource}}' import is restricted from being used.";
-const CUSTOM_MESSAGE_TEMPLATE = "'{{importSource}}' import is restricted from being used. {{customMessage}}";
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -62,6 +55,18 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-restricted-imports"
         },
 
+        messages: {
+            path: "'{{importSource}}' import is restricted from being used.",
+            // eslint-disable-next-line eslint-plugin/report-message-format
+            pathWithCustomMessage: "'{{importSource}}' import is restricted from being used. {{customMessage}}",
+
+            patterns: "'{{importSource}}' import is restricted from being used by a pattern.",
+
+            everything: "* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted.",
+            // eslint-disable-next-line eslint-plugin/report-message-format
+            everythingWithCustomMessage: "* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted. {{customMessage}}"
+        },
+
         schema: {
             anyOf: [
                 arrayOfStringsOrObjects,
@@ -127,13 +132,10 @@ module.exports = {
         function reportPath(node) {
             const importSource = node.source.value.trim();
             const customMessage = restrictedPathMessages[importSource] && restrictedPathMessages[importSource].message;
-            const message = customMessage
-                ? CUSTOM_MESSAGE_TEMPLATE
-                : DEFAULT_MESSAGE_TEMPLATE;
 
             context.report({
                 node,
-                message,
+                messageId: customMessage ? "pathWithCustomMessage" : "path",
                 data: {
                     importSource,
                     customMessage
@@ -152,7 +154,7 @@ module.exports = {
 
             context.report({
                 node,
-                message: "'{{importSource}}' import is restricted from being used by a pattern.",
+                messageId: "patterns",
                 data: {
                     importSource
                 }
@@ -168,13 +170,15 @@ module.exports = {
          */
         function reportPathForEverythingImported(importSource, node) {
             const importNames = restrictedPathMessages[importSource].importNames;
+            const customMessage = restrictedPathMessages[importSource] && restrictedPathMessages[importSource].message;
 
             context.report({
                 node,
-                message: "* import is invalid because '{{importNames}}' from '{{importSource}}' is restricted.",
+                messageId: customMessage ? "everythingWithCustomMessage" : "everything",
                 data: {
                     importSource,
-                    importNames
+                    importNames,
+                    customMessage
                 }
             });
         }

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

@@ -102,9 +102,14 @@ module.exports = {
          * @returns {void}
          */
         function report(node, startOffset, character) {
+            const start = sourceCode.getLocFromIndex(sourceCode.getIndexFromLoc(node.loc.start) + startOffset);
+
             context.report({
                 node,
-                loc: sourceCode.getLocFromIndex(sourceCode.getIndexFromLoc(node.loc.start) + startOffset),
+                loc: {
+                    start,
+                    end: { line: start.line, column: start.column + 1 }
+                },
                 message: "Unnecessary escape character: \\{{character}}.",
                 data: { character }
             });

package/lib/rules/no-var.js

@@ -174,6 +174,17 @@ function hasReferenceInTDZ(node) {
     };
 }
 
+/**
+ * Checks whether a given variable has name that is allowed for 'var' declarations,
+ * but disallowed for `let` declarations.
+ *
+ * @param {eslint-scope.Variable} variable The variable to check.
+ * @returns {boolean} `true` if the variable has a disallowed name.
+ */
+function hasNameDisallowedForLetDeclarations(variable) {
+    return variable.name === "let";
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -223,6 +234,7 @@ module.exports = {
          * - A variable might be used before it is assigned within a loop.
          * - A variable might be used in TDZ.
          * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
+         * - A variable has name that is disallowed for `let` declarations.
          *
          * ## A variable is declared on a SwitchCase node.
          *
@@ -271,7 +283,8 @@ module.exports = {
                 node.declarations.some(hasSelfReferenceInTDZ) ||
                 variables.some(isGlobal) ||
                 variables.some(isRedeclared) ||
-                variables.some(isUsedFromOutsideOf(scopeNode))
+                variables.some(isUsedFromOutsideOf(scopeNode)) ||
+                variables.some(hasNameDisallowedForLetDeclarations)
             ) {
                 return false;
             }

package/lib/rules/prefer-const.js

@@ -420,8 +420,9 @@ module.exports = {
 
                 let shouldFix = varDeclParent &&
 
-                    // Don't do a fix unless the variable is initialized (or it's in a for-in or for-of loop)
-                    (varDeclParent.parent.type === "ForInStatement" || varDeclParent.parent.type === "ForOfStatement" || varDeclParent.declarations[0].init) &&
+                    // Don't do a fix unless all variables in the declarations are initialized (or it's in a for-in or for-of loop)
+                    (varDeclParent.parent.type === "ForInStatement" || varDeclParent.parent.type === "ForOfStatement" ||
+                        varDeclParent.declarations.every(declaration => declaration.init)) &&
 
                     /*
                      * If options.destructuring is "all", then this warning will not occur unless
@@ -450,7 +451,12 @@ module.exports = {
                         node,
                         messageId: "useConst",
                         data: node,
-                        fix: shouldFix ? fixer => fixer.replaceText(sourceCode.getFirstToken(varDeclParent), "const") : null
+                        fix: shouldFix
+                            ? fixer => fixer.replaceText(
+                                sourceCode.getFirstToken(varDeclParent, t => t.value === varDeclParent.kind),
+                                "const"
+                            )
+                            : null
                     });
                 });
             }

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/sort-keys.js

@@ -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/utils/ast-utils.js

@@ -37,6 +37,8 @@ const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
 // A set of node types that can contain a list of statements
 const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);
 
+const DECIMAL_INTEGER_PATTERN = /^(0|[1-9]\d*)$/u;
+
 /**
  * Checks reference if is non initializer and writable.
  * @param {Reference} reference - A reference to check.
@@ -283,6 +285,16 @@ function isCommaToken(token) {
     return token.value === "," && token.type === "Punctuator";
 }
 
+/**
+ * Checks if the given token is a dot token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a dot token.
+ */
+function isDotToken(token) {
+    return token.value === "." && token.type === "Punctuator";
+}
+
 /**
  * Checks if the given token is a semicolon token or not.
  *
@@ -462,12 +474,14 @@ module.exports = {
     isColonToken,
     isCommaToken,
     isCommentToken,
+    isDotToken,
     isKeywordToken,
     isNotClosingBraceToken: negate(isClosingBraceToken),
     isNotClosingBracketToken: negate(isClosingBracketToken),
     isNotClosingParenToken: negate(isClosingParenToken),
     isNotColonToken: negate(isColonToken),
     isNotCommaToken: negate(isCommaToken),
+    isNotDotToken: negate(isDotToken),
     isNotOpeningBraceToken: negate(isOpeningBraceToken),
     isNotOpeningBracketToken: negate(isOpeningBracketToken),
     isNotOpeningParenToken: negate(isOpeningParenToken),
@@ -988,7 +1002,18 @@ module.exports = {
      * '5'     // false
      */
     isDecimalInteger(node) {
-        return node.type === "Literal" && typeof node.value === "number" && /^(0|[1-9]\d*)$/u.test(node.raw);
+        return node.type === "Literal" && typeof node.value === "number" &&
+            DECIMAL_INTEGER_PATTERN.test(node.raw);
+    },
+
+    /**
+     * Determines whether this token is a decimal integer numeric token.
+     * This is similar to isDecimalInteger(), but for tokens.
+     * @param {Token} token - The token to check.
+     * @returns {boolean} `true` if this token is a decimal integer.
+     */
+    isDecimalIntegerNumericToken(token) {
+        return token.type === "Numeric" && DECIMAL_INTEGER_PATTERN.test(token.value);
     },
 
     /**

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/messages/extend-config-missing.txt

@@ -1,3 +1,5 @@
 ESLint couldn't find the config "<%- configName %>" to extend from. Please check that the name of the config is correct.
 
+The config "<%- configName %>" was referenced from the config file in "<%- importerName %>".
+
 If you still have problems, please stop by https://gitter.im/eslint/eslint to chat with the team.

package/messages/print-config-with-directory-path.txt

@@ -0,0 +1,2 @@
+The '--print-config' CLI option requires a path to a source code file rather than a directory.
+See also: https://eslint.org/docs/user-guide/command-line-interface#--print-config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "6.0.0-alpha.2",
+  "version": "6.1.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -19,9 +19,7 @@
     "docs": "node Makefile.js docs",
     "gensite": "node Makefile.js gensite",
     "webpack": "node Makefile.js webpack",
-    "perf": "node Makefile.js perf",
-    "profile": "beefy tests/bench/bench.js --open -- -t brfs -t ./tests/bench/xform-rules.js -r espree",
-    "coveralls": "cat ./coverage/lcov.info | coveralls"
+    "perf": "node Makefile.js perf"
   },
   "gitHooks": {
     "pre-commit": "lint-staged"
@@ -51,49 +49,47 @@
     "cross-spawn": "^6.0.5",
     "debug": "^4.0.1",
     "doctrine": "^3.0.0",
-    "eslint-scope": "^4.0.3",
+    "eslint-scope": "^5.0.0",
     "eslint-utils": "^1.3.1",
     "eslint-visitor-keys": "^1.0.0",
-    "espree": "^6.0.0-alpha.0",
+    "espree": "^6.0.0",
     "esquery": "^1.0.1",
     "esutils": "^2.0.2",
     "file-entry-cache": "^5.0.1",
     "functional-red-black-tree": "^1.0.1",
-    "glob-parent": "^3.1.0",
+    "glob-parent": "^5.0.0",
     "globals": "^11.7.0",
     "ignore": "^4.0.6",
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
-    "inquirer": "^6.2.2",
+    "inquirer": "^6.4.1",
     "is-glob": "^4.0.0",
     "js-yaml": "^3.13.1",
     "json-stable-stringify-without-jsonify": "^1.0.1",
     "levn": "^0.3.0",
-    "lodash": "^4.17.11",
+    "lodash": "^4.17.14",
     "minimatch": "^3.0.4",
     "mkdirp": "^0.5.1",
     "natural-compare": "^1.4.0",
     "optionator": "^0.8.2",
     "progress": "^2.0.0",
     "regexpp": "^2.0.1",
-    "semver": "^5.5.1",
-    "strip-ansi": "^4.0.0",
-    "strip-json-comments": "^2.0.1",
+    "semver": "^6.1.2",
+    "strip-ansi": "^5.2.0",
+    "strip-json-comments": "^3.0.1",
     "table": "^5.2.3",
-    "text-table": "^0.2.0"
+    "text-table": "^0.2.0",
+    "v8-compile-cache": "^2.0.3"
   },
   "devDependencies": {
     "@babel/core": "^7.4.3",
-    "@babel/polyfill": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
     "acorn": "^6.1.1",
     "babel-loader": "^8.0.5",
-    "beefy": "^2.1.8",
-    "brfs": "^2.0.2",
     "chai": "^4.0.1",
     "cheerio": "^0.22.0",
     "common-tags": "^1.8.0",
-    "coveralls": "^3.0.3",
+    "core-js": "^3.1.3",
     "dateformat": "^3.0.3",
     "ejs": "^2.6.1",
     "eslint": "file:.",
@@ -114,21 +110,22 @@
     "leche": "^2.2.3",
     "lint-staged": "^8.1.5",
     "load-perf": "^0.2.0",
-    "markdownlint": "^0.13.0",
-    "markdownlint-cli": "^0.15.0",
-    "metro-memory-fs": "^0.53.1",
+    "markdownlint": "^0.15.0",
+    "markdownlint-cli": "^0.17.0",
+    "metro-memory-fs": "^0.54.1",
     "mocha": "^6.1.2",
+    "mocha-junit-reporter": "^1.23.0",
     "npm-license": "^0.3.3",
-    "nyc": "^13.3.0",
+    "nyc": "^14.1.1",
     "proxyquire": "^2.0.1",
-    "puppeteer": "^1.14.0",
-    "recast": "^0.17.6",
+    "puppeteer": "^1.18.0",
+    "recast": "^0.18.1",
+    "regenerator-runtime": "^0.13.2",
     "shelljs": "^0.8.2",
-    "sinon": "^3.3.0",
+    "sinon": "^7.3.2",
     "temp": "^0.9.0",
-    "through": "^2.3.8",
-    "webpack": "^4.29.6",
-    "webpack-cli": "^3.3.0",
+    "webpack": "^4.35.0",
+    "webpack-cli": "^3.3.5",
     "yorkie": "^2.0.0"
   },
   "keywords": [