eslint 3.13.1 → 3.16.0

package/lib/ast-utils.js

@@ -24,6 +24,12 @@ const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/;
 const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/;
 const thisTagPattern = /^[\s*]*@this/m;
 
+const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
+const LINEBREAK_MATCHER = /\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"]);
+
 /**
  * Checks reference if is non initializer and writable.
  * @param {Reference} reference - A reference to check.
@@ -142,7 +148,7 @@ function isInLoop(node) {
  */
 function isNullOrUndefined(node) {
     return (
-        (node.type === "Literal" && node.value === null) ||
+        module.exports.isNullLiteral(node) ||
         (node.type === "Identifier" && node.name === "undefined") ||
         (node.type === "UnaryExpression" && node.operator === "void")
     );
@@ -158,9 +164,9 @@ function isCallee(node) {
 }
 
 /**
- * Checks whether or not a node is `Reclect.apply`.
+ * Checks whether or not a node is `Reflect.apply`.
  * @param {ASTNode} node - A node to check.
- * @returns {boolean} Whether or not the node is a `Reclect.apply`.
+ * @returns {boolean} Whether or not the node is a `Reflect.apply`.
  */
 function isReflectApply(node) {
     return (
@@ -210,6 +216,15 @@ function isMethodWhichHasThisArg(node) {
     return false;
 }
 
+/**
+ * Creates the negate function of the given function.
+ * @param {Function} f - The function to negate.
+ * @returns {Function} Negated function.
+ */
+function negate(f) {
+    return token => !f(token);
+}
+
 /**
  * Checks whether or not a node has a `@this` tag in its comments.
  * @param {ASTNode} node - A node to check.
@@ -247,20 +262,123 @@ function isParenthesised(sourceCode, node) {
 }
 
 /**
- * Gets the `=>` token of the given arrow function node.
+ * Checks if the given token is an arrow token or not.
  *
- * @param {ASTNode} node - The arrow function node to get.
- * @param {SourceCode} sourceCode - The source code object to get tokens.
- * @returns {Token} `=>` token.
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is an arrow token.
  */
-function getArrowToken(node, sourceCode) {
-    let token = sourceCode.getTokenBefore(node.body);
+function isArrowToken(token) {
+    return token.value === "=>" && token.type === "Punctuator";
+}
 
-    while (token.value !== "=>") {
-        token = sourceCode.getTokenBefore(token);
-    }
+/**
+ * Checks if the given token is a comma token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a comma token.
+ */
+function isCommaToken(token) {
+    return token.value === "," && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is a semicolon token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a semicolon token.
+ */
+function isSemicolonToken(token) {
+    return token.value === ";" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is a colon token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a colon token.
+ */
+function isColonToken(token) {
+    return token.value === ":" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is an opening parenthesis token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is an opening parenthesis token.
+ */
+function isOpeningParenToken(token) {
+    return token.value === "(" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is a closing parenthesis token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a closing parenthesis token.
+ */
+function isClosingParenToken(token) {
+    return token.value === ")" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is an opening square bracket token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is an opening square bracket token.
+ */
+function isOpeningBracketToken(token) {
+    return token.value === "[" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is a closing square bracket token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a closing square bracket token.
+ */
+function isClosingBracketToken(token) {
+    return token.value === "]" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is an opening brace token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is an opening brace token.
+ */
+function isOpeningBraceToken(token) {
+    return token.value === "{" && token.type === "Punctuator";
+}
+
+/**
+ * Checks if the given token is a closing brace token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a closing brace token.
+ */
+function isClosingBraceToken(token) {
+    return token.value === "}" && token.type === "Punctuator";
+}
 
-    return token;
+/**
+ * Checks if the given token is a comment token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a comment token.
+ */
+function isCommentToken(token) {
+    return token.type === "Line" || token.type === "Block" || token.type === "Shebang";
+}
+
+/**
+ * Checks if the given token is a keyword token or not.
+ *
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a keyword token.
+ */
+function isKeywordToken(token) {
+    return token.type === "Keyword";
 }
 
 /**
@@ -271,13 +389,18 @@ function getArrowToken(node, sourceCode) {
  * @returns {Token} `(` token.
  */
 function getOpeningParenOfParams(node, sourceCode) {
-    let token = node.id ? sourceCode.getTokenAfter(node.id) : sourceCode.getFirstToken(node);
-
-    while (token.value !== "(") {
-        token = sourceCode.getTokenAfter(token);
-    }
+    return node.id
+        ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
+        : sourceCode.getFirstToken(node, isOpeningParenToken);
+}
 
-    return token;
+/**
+ * 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, "g");
 }
 
 const lineIndexCache = new WeakMap();
@@ -290,8 +413,23 @@ const lineIndexCache = new WeakMap();
 function getLineIndices(sourceCode) {
 
     if (!lineIndexCache.has(sourceCode)) {
-        const lineIndices = (sourceCode.text.match(/[^\r\n\u2028\u2029]*(\r\n|\r|\n|\u2028|\u2029)/g) || [])
-            .reduce((indices, line) => indices.concat(indices[indices.length - 1] + line.length), [0]);
+        const lineIndices = [0];
+        const lineEndingPattern = createGlobalLinebreakMatcher();
+        let match;
+
+        /*
+         * Previously, this function was implemented using a regex that
+         * matched a sequence of non-linebreak characters followed by a
+         * linebreak, then adding the lengths of the matches. However,
+         * this caused a catastrophic backtracking issue when the end
+         * of a file contained a large number of non-newline characters.
+         * To avoid this, the current implementation just matches newlines
+         * and uses match.index to get the correct line start indices.
+         */
+
+        while ((match = lineEndingPattern.exec(sourceCode.text))) {
+            lineIndices.push(match.index + match[0].length);
+        }
 
         // Store the sourceCode object in a WeakMap to avoid iterating over all of the lines every time a sourceCode object is passed in.
         lineIndexCache.set(sourceCode, lineIndices);
@@ -304,6 +442,9 @@ function getLineIndices(sourceCode) {
 //------------------------------------------------------------------------------
 
 module.exports = {
+    LINEBREAKS,
+    LINEBREAK_MATCHER,
+    STATEMENT_LIST_PARENTS,
 
     /**
      * Determines whether two adjacent tokens are on the same line.
@@ -325,6 +466,29 @@ module.exports = {
     isInLoop,
     isArrayFromMethod,
     isParenthesised,
+    createGlobalLinebreakMatcher,
+
+    isArrowToken,
+    isClosingBraceToken,
+    isClosingBracketToken,
+    isClosingParenToken,
+    isColonToken,
+    isCommaToken,
+    isCommentToken,
+    isKeywordToken,
+    isNotClosingBraceToken: negate(isClosingBraceToken),
+    isNotClosingBracketToken: negate(isClosingBracketToken),
+    isNotClosingParenToken: negate(isClosingParenToken),
+    isNotColonToken: negate(isColonToken),
+    isNotCommaToken: negate(isCommaToken),
+    isNotOpeningBraceToken: negate(isOpeningBraceToken),
+    isNotOpeningBracketToken: negate(isOpeningBracketToken),
+    isNotOpeningParenToken: negate(isOpeningParenToken),
+    isNotSemicolonToken: negate(isSemicolonToken),
+    isOpeningBraceToken,
+    isOpeningBracketToken,
+    isOpeningParenToken,
+    isSemicolonToken,
 
     /**
      * Checks whether or not a given node is a string literal.
@@ -658,6 +822,8 @@ module.exports = {
                     case "/":
                     case "%":
                         return 13;
+                    case "**":
+                        return 15;
 
                     // no default
                 }
@@ -666,10 +832,10 @@ module.exports = {
 
             case "UnaryExpression":
             case "AwaitExpression":
-                return 14;
+                return 16;
 
             case "UpdateExpression":
-                return 15;
+                return 17;
 
             case "CallExpression":
 
@@ -677,14 +843,14 @@ module.exports = {
                 if (node.callee.type === "FunctionExpression") {
                     return -1;
                 }
-                return 16;
+                return 18;
 
             case "NewExpression":
-                return 17;
+                return 19;
 
             // no default
         }
-        return 18;
+        return 20;
     },
 
     /**
@@ -1023,7 +1189,7 @@ module.exports = {
         let end = null;
 
         if (node.type === "ArrowFunctionExpression") {
-            const arrowToken = getArrowToken(node, sourceCode);
+            const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);
 
             start = arrowToken.loc.start;
             end = arrowToken.loc.end;
@@ -1037,7 +1203,7 @@ module.exports = {
 
         return {
             start: Object.assign({}, start),
-            end: Object.assign({}, end),
+            end: Object.assign({}, end)
         };
     },
 
@@ -1097,5 +1263,58 @@ module.exports = {
         }
 
         return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]);
+    },
+
+    /*
+     * Determine if a node has a possiblity to be an Error object
+     * @param  {ASTNode} node  ASTNode to check
+     * @returns {boolean} True if there is a chance it contains an Error obj
+     */
+    couldBeError(node) {
+        switch (node.type) {
+            case "Identifier":
+            case "CallExpression":
+            case "NewExpression":
+            case "MemberExpression":
+            case "TaggedTemplateExpression":
+            case "YieldExpression":
+            case "AwaitExpression":
+                return true; // possibly an error object.
+
+            case "AssignmentExpression":
+                return module.exports.couldBeError(node.right);
+
+            case "SequenceExpression": {
+                const exprs = node.expressions;
+
+                return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]);
+            }
+
+            case "LogicalExpression":
+                return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
+
+            case "ConditionalExpression":
+                return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate);
+
+            default:
+                return false;
+        }
+    },
+
+    /**
+     * Determines whether the given node is a `null` literal.
+     * @param {ASTNode} node The node to check
+     * @returns {boolean} `true` if the node is a `null` literal
+     */
+    isNullLiteral(node) {
+
+        /*
+         * Checking `node.value === null` does not guarantee that a literal is a null literal.
+         * When parsing values that cannot be represented in the current environment (e.g. unicode
+         * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to
+         * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check
+         * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020
+         */
+        return node.type === "Literal" && node.value === null && !node.regex;
     }
 };

package/lib/cli.js

@@ -188,9 +188,9 @@ const cli = {
                 }
 
                 return (report.errorCount || tooManyWarnings) ? 1 : 0;
-            } else {
-                return 1;
             }
+            return 1;
+
 
         }
 

package/lib/code-path-analysis/code-path-state.js

@@ -467,8 +467,8 @@ class CodePathState {
              * Creates the next path from own true/false fork context.
              */
             const prevForkContext =
-                context.kind === "&&" ? context.trueForkContext :
-                /* kind === "||" */ context.falseForkContext;
+                context.kind === "&&" ? context.trueForkContext
+                /* kind === "||" */ : context.falseForkContext;
 
             forkContext.replaceHead(prevForkContext.makeNext(0, -1));
             prevForkContext.clear();

package/lib/config/autoconfig.js

@@ -13,7 +13,7 @@ const lodash = require("lodash"),
     eslint = require("../eslint"),
     configRule = require("./config-rule"),
     ConfigOps = require("./config-ops"),
-    recConfig = require("../../conf/eslint.json");
+    recConfig = require("../../conf/eslint-recommended");
 
 const debug = require("debug")("eslint:autoconfig");
 
@@ -65,17 +65,16 @@ function makeRegistryItems(rulesConfig) {
 * Unless a rulesConfig is provided at construction, the registry will not contain
 * any rules, only methods.  This will be useful for building up registries manually.
 *
-* @constructor
-* @class   Registry
-* @param   {rulesConfig} [rulesConfig] Hash of rule names and arrays of possible configurations
+* Registry class
 */
-function Registry(rulesConfig) {
-    this.rules = (rulesConfig) ? makeRegistryItems(rulesConfig) : {};
-}
-
-Registry.prototype = {
+class Registry {
 
-    constructor: Registry,
+    /**
+     * @param {rulesConfig} [rulesConfig] Hash of rule names and arrays of possible configurations
+     */
+    constructor(rulesConfig) {
+        this.rules = (rulesConfig) ? makeRegistryItems(rulesConfig) : {};
+    }
 
     /**
      * Populate the registry with core rule configs.
@@ -89,7 +88,7 @@ Registry.prototype = {
         const rulesConfig = configRule.createCoreRuleConfigs();
 
         this.rules = makeRegistryItems(rulesConfig);
-    },
+    }
 
     /**
      * Creates sets of rule configurations which can be used for linting
@@ -156,7 +155,7 @@ Registry.prototype = {
         }
 
         return ruleSets;
-    },
+    }
 
     /**
      * Remove all items from the registry with a non-zero number of errors
@@ -182,7 +181,7 @@ Registry.prototype = {
         });
 
         return newRegistry;
-    },
+    }
 
     /**
      * Removes rule configurations which were not included in a ruleSet
@@ -199,7 +198,7 @@ Registry.prototype = {
         });
 
         return newRegistry;
-    },
+    }
 
     /**
      * Creates a registry of rules which had no error-free configs.
@@ -221,7 +220,7 @@ Registry.prototype = {
         });
 
         return failingRegistry;
-    },
+    }
 
     /**
      * Create an eslint config for any rules which only have one configuration
@@ -240,7 +239,7 @@ Registry.prototype = {
         });
 
         return config;
-    },
+    }
 
     /**
      * Return a cloned registry containing only configs with a desired specificity
@@ -258,7 +257,7 @@ Registry.prototype = {
         });
 
         return newRegistry;
-    },
+    }
 
     /**
      * Lint SourceCodes against all configurations in the registry, and record results
@@ -297,8 +296,13 @@ Registry.prototype = {
 
                     // It is possible that the error is from a configuration comment
                     // in a linted file, in which case there may not be a config
-                    // set in this ruleSetIdx. (https://github.com/eslint/eslint/issues/5992)
-                    if (lintedRegistry.rules[result.ruleId][ruleSetIdx]) {
+                    // set in this ruleSetIdx.
+                    // (https://github.com/eslint/eslint/issues/5992)
+                    // (https://github.com/eslint/eslint/issues/7860)
+                    if (
+                        lintedRegistry.rules[result.ruleId] &&
+                        lintedRegistry.rules[result.ruleId][ruleSetIdx]
+                    ) {
                         lintedRegistry.rules[result.ruleId][ruleSetIdx].errorCount += 1;
                     }
                 });
@@ -316,7 +320,7 @@ Registry.prototype = {
 
         return lintedRegistry;
     }
-};
+}
 
 /**
  * Extract rule configuration into eslint:recommended where possible.

package/lib/config/config-file.js

@@ -23,7 +23,7 @@ const fs = require("fs"),
     stripBom = require("strip-bom"),
     stripComments = require("strip-json-comments"),
     stringify = require("json-stable-stringify"),
-    defaultOptions = require("../../conf/eslint.json"),
+    defaultOptions = require("../../conf/eslint-recommended"),
     requireUncached = require("require-uncached");
 
 const debug = require("debug")("eslint:config-file");
@@ -364,10 +364,10 @@ function applyExtends(config, filePath, relativeTo) {
         if (parentPath === "eslint:recommended") {
 
             /*
-             * Add an explicit substitution for eslint:recommended to conf/eslint.json
-             * this lets us use the eslint.json file as the recommended rules
+             * Add an explicit substitution for eslint:recommended to
+             * conf/eslint-recommended.js.
              */
-            parentPath = path.resolve(__dirname, "../../conf/eslint.json");
+            parentPath = path.resolve(__dirname, "../../conf/eslint-recommended.js");
         } else if (parentPath === "eslint:all") {
 
             /*
@@ -380,9 +380,9 @@ function applyExtends(config, filePath, relativeTo) {
              * If the `extends` path is relative, use the directory of the current configuration
              * file as the reference point. Otherwise, use as-is.
              */
-            parentPath = (!path.isAbsolute(parentPath) ?
-                path.join(relativeTo || path.dirname(filePath), parentPath) :
-                parentPath
+            parentPath = (!path.isAbsolute(parentPath)
+                ? path.join(relativeTo || path.dirname(filePath), parentPath)
+                : parentPath
             );
         }
 
@@ -390,6 +390,13 @@ function applyExtends(config, filePath, relativeTo) {
             debug(`Loading ${parentPath}`);
             return ConfigOps.merge(load(parentPath, false, relativeTo), previousValue);
         } catch (e) {
+            if (parentPath.indexOf("plugin:") === 0 || parentPath.indexOf("eslint:") === 0) {
+                e.message = `Failed to load config "${parentPath}" to extend from.`;
+                e.messageTemplate = "extend-config-missing";
+                e.messageData = {
+                    configName: parentPath
+                };
+            }
 
             /*
              * If the file referenced by `extends` failed to load, add the path
@@ -461,24 +468,24 @@ function normalizePackageName(name, prefix) {
 function resolve(filePath, relativeTo) {
     if (isFilePath(filePath)) {
         return { filePath: path.resolve(relativeTo || "", filePath) };
-    } else {
-        let normalizedPackageName;
-
-        if (filePath.indexOf("plugin:") === 0) {
-            const packagePath = filePath.substr(7, filePath.lastIndexOf("/") - 7);
-            const configName = filePath.substr(filePath.lastIndexOf("/") + 1, filePath.length - filePath.lastIndexOf("/") - 1);
-
-            normalizedPackageName = normalizePackageName(packagePath, "eslint-plugin");
-            debug(`Attempting to resolve ${normalizedPackageName}`);
-            filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
-            return { filePath, configName };
-        } else {
-            normalizedPackageName = normalizePackageName(filePath, "eslint-config");
-            debug(`Attempting to resolve ${normalizedPackageName}`);
-            filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
-            return { filePath };
-        }
     }
+    let normalizedPackageName;
+
+    if (filePath.indexOf("plugin:") === 0) {
+        const packagePath = filePath.substr(7, filePath.lastIndexOf("/") - 7);
+        const configName = filePath.substr(filePath.lastIndexOf("/") + 1, filePath.length - filePath.lastIndexOf("/") - 1);
+
+        normalizedPackageName = normalizePackageName(packagePath, "eslint-plugin");
+        debug(`Attempting to resolve ${normalizedPackageName}`);
+        filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
+        return { filePath, configName };
+    }
+    normalizedPackageName = normalizePackageName(filePath, "eslint-config");
+    debug(`Attempting to resolve ${normalizedPackageName}`);
+    filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
+    return { filePath };
+
+
 
 }
 

package/lib/config/config-initializer.js

@@ -17,7 +17,7 @@ const util = require("util"),
     ConfigOps = require("./config-ops"),
     getSourceCodeOfFiles = require("../util/source-code-util").getSourceCodeOfFiles,
     npmUtil = require("../util/npm-util"),
-    recConfig = require("../../conf/eslint.json"),
+    recConfig = require("../../conf/eslint-recommended"),
     log = require("../logging");
 
 const debug = require("debug")("eslint:config-initializer");
@@ -317,7 +317,7 @@ function promptUser(callback) {
             default: false,
             when(answers) {
                 return answers.styleguide === "airbnb";
-            },
+            }
         },
         {
             type: "input",