eslint 3.15.0 → 3.17.1

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");
 
@@ -300,8 +300,8 @@ class Registry {
                     // (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] &&
+                        lintedRegistry.rules[result.ruleId][ruleSetIdx]
                     ) {
                         lintedRegistry.rules[result.ruleId][ruleSetIdx].errorCount += 1;
                     }

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

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");

package/lib/config.js

@@ -234,8 +234,9 @@ class Config {
     }
 
     /**
-     * Build a config object merging the base config (conf/eslint.json), the
-     * environments config (conf/environments.js) and eventually the user config.
+     * Build a config object merging the base config (conf/eslint-recommended),
+     * the environments config (conf/environments.js) and eventually the user
+     * config.
      * @param {string} filePath a file in whose directory we start looking for a local config
      * @returns {Object} config object
      */

package/lib/eslint.js

@@ -14,7 +14,7 @@ const assert = require("assert"),
     escope = require("escope"),
     levn = require("levn"),
     blankScriptAST = require("../conf/blank-script.json"),
-    DEFAULT_PARSER = require("../conf/eslint.json").parser,
+    DEFAULT_PARSER = require("../conf/eslint-recommended").parser,
     replacements = require("../conf/replacements.json"),
     CodePathAnalyzer = require("./code-path-analysis/code-path-analyzer"),
     ConfigOps = require("./config/config-ops"),
@@ -864,8 +864,8 @@ module.exports = (function() {
                         (parseResult && parseResult.services ? parseResult.services : {})
                     );
 
-                    const rule = ruleCreator.create ? ruleCreator.create(ruleContext) :
-                        ruleCreator(ruleContext);
+                    const rule = ruleCreator.create ? ruleCreator.create(ruleContext)
+                        : ruleCreator(ruleContext);
 
                     // add all the node types as listeners
                     Object.keys(rule).forEach(nodeType => {
@@ -1192,7 +1192,7 @@ module.exports = (function() {
      * @returns {Object} Object mapping rule IDs to their default configurations
      */
     api.defaults = function() {
-        return require("../conf/eslint.json");
+        return require("../conf/eslint-recommended");
     };
 
     /**

package/lib/internal-rules/internal-no-invalid-meta.js

@@ -94,16 +94,6 @@ function hasMetaSchema(metaPropertyNode) {
     return getPropertyFromObject("schema", metaPropertyNode.value);
 }
 
-/**
- * Whether this `meta` ObjectExpression has a `fixable` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `fixable` property exists.
- */
-function hasMetaFixable(metaPropertyNode) {
-    return getPropertyFromObject("fixable", metaPropertyNode.value);
-}
-
 /**
  * Checks the validity of the meta definition of this rule and reports any errors found.
  *
@@ -112,7 +102,7 @@ function hasMetaFixable(metaPropertyNode) {
  * @param {boolean} ruleIsFixable whether the rule is fixable or not.
  * @returns {void}
  */
-function checkMetaValidity(context, exportsNode, ruleIsFixable) {
+function checkMetaValidity(context, exportsNode) {
     const metaProperty = getMetaPropertyFromExportsNode(exportsNode);
 
     if (!metaProperty) {
@@ -142,11 +132,6 @@ function checkMetaValidity(context, exportsNode, ruleIsFixable) {
 
     if (!hasMetaSchema(metaProperty)) {
         context.report(metaProperty, "Rule is missing a meta.schema property.");
-        return;
-    }
-
-    if (ruleIsFixable && !hasMetaFixable(metaProperty)) {
-        context.report(metaProperty, "Rule is fixable, but is missing a meta.fixable property.");
     }
 }
 
@@ -177,7 +162,6 @@ module.exports = {
 
     create(context) {
         let exportsNode;
-        let ruleIsFixable = false;
 
         return {
             AssignmentExpression(node) {
@@ -191,35 +175,13 @@ module.exports = {
                 }
             },
 
-            CallExpression(node) {
-
-                // If the rule has a call for `context.report` and a property `fix`
-                // is being passed in, then we consider that the rule is fixable.
-                //
-                // Note that we only look for context.report() calls in the new
-                // style (with single MessageDescriptor argument), because only
-                // calls in the new style can specify a fix.
-                if (node.callee.type === "MemberExpression" &&
-                    node.callee.object.type === "Identifier" &&
-                    node.callee.object.name === "context" &&
-                    node.callee.property.type === "Identifier" &&
-                    node.callee.property.name === "report" &&
-                    node.arguments.length === 1 &&
-                    node.arguments[0].type === "ObjectExpression") {
-
-                    if (getPropertyFromObject("fix", node.arguments[0])) {
-                        ruleIsFixable = true;
-                    }
-                }
-            },
-
             "Program:exit"() {
                 if (!isCorrectExportsFormat(exportsNode)) {
                     context.report({ node: exportsNode, message: "Rule does not export an Object. Make sure the rule follows the new rule format." });
                     return;
                 }
 
-                checkMetaValidity(context, exportsNode, ruleIsFixable);
+                checkMetaValidity(context, exportsNode);
             }
         };
     }

package/lib/rules/array-callback-return.js

@@ -9,6 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const lodash = require("lodash");
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
@@ -147,7 +149,8 @@ module.exports = {
             upper: null,
             codePath: null,
             hasReturn: false,
-            shouldCheck: false
+            shouldCheck: false,
+            node: null
         };
 
         /**
@@ -168,8 +171,11 @@ module.exports = {
                     node,
                     loc: getLocation(node, context.getSourceCode()).loc.start,
                     message: funcInfo.hasReturn
-                        ? "Expected to return a value at the end of this function."
-                        : "Expected to return a value in this function."
+                        ? "Expected to return a value at the end of {{name}}."
+                        : "Expected to return a value in {{name}}.",
+                    data: {
+                        name: astUtils.getFunctionNameWithKind(funcInfo.node)
+                    }
                 });
             }
         }
@@ -187,7 +193,8 @@ module.exports = {
                         node.body.type === "BlockStatement" &&
                         isCallbackOfArrayMethod(node) &&
                         !node.async &&
-                        !node.generator
+                        !node.generator,
+                    node
                 };
             },
 
@@ -204,7 +211,10 @@ module.exports = {
                     if (!node.argument) {
                         context.report({
                             node,
-                            message: "Expected a return value."
+                            message: "{{name}} expected a return value.",
+                            data: {
+                                name: lodash.upperFirst(astUtils.getFunctionNameWithKind(funcInfo.node))
+                            }
                         });
                     }
                 }

package/lib/rules/arrow-body-style.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -136,10 +142,7 @@ module.exports = {
                         loc: arrowBody.loc.start,
                         message: "Expected block statement surrounding arrow body.",
                         fix(fixer) {
-                            const lastTokenBeforeBody = sourceCode.getTokensBetween(sourceCode.getFirstToken(node), arrowBody)
-                                .reverse()
-                                .find(token => token.value !== "(");
-
+                            const lastTokenBeforeBody = sourceCode.getLastTokenBetween(sourceCode.getFirstToken(node), arrowBody, astUtils.isNotOpeningParenToken);
                             const firstBodyToken = sourceCode.getTokenAfter(lastTokenBeforeBody);
 
                             return fixer.replaceTextRange(

package/lib/rules/arrow-spacing.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -51,12 +57,7 @@ module.exports = {
          * @returns {Object} Tokens of arrow and before/after arrow.
          */
         function getTokens(node) {
-            let arrow = sourceCode.getTokenBefore(node.body);
-
-            // skip '(' tokens.
-            while (arrow.value !== "=>") {
-                arrow = sourceCode.getTokenBefore(arrow);
-            }
+            const arrow = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
 
             return {
                 before: sourceCode.getTokenBefore(arrow),

package/lib/rules/block-spacing.js

@@ -74,8 +74,8 @@ module.exports = {
             // Gets braces and the first/last token of content.
             const openBrace = getOpenBrace(node);
             const closeBrace = sourceCode.getLastToken(node);
-            const firstToken = sourceCode.getTokenOrCommentAfter(openBrace);
-            const lastToken = sourceCode.getTokenOrCommentBefore(closeBrace);
+            const firstToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+            const lastToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
 
             // Skip if the node is invalid or empty.
             if (openBrace.type !== "Punctuator" ||

package/lib/rules/brace-style.js

@@ -62,7 +62,7 @@ module.exports = {
         function removeNewlineBetween(firstToken, secondToken) {
             const textRange = [firstToken.range[1], secondToken.range[0]];
             const textBetween = sourceCode.text.slice(textRange[0], textRange[1]);
-            const NEWLINE_REGEX = /\r\n|\r|\n|\u2028|\u2029/g;
+            const NEWLINE_REGEX = astUtils.createGlobalLinebreakMatcher();
 
             // Don't do a fix if there is a comment between the tokens
             return fixer => fixer.replaceTextRange(textRange, textBetween.trim() ? null : textBetween.replace(NEWLINE_REGEX, ""));
@@ -144,11 +144,7 @@ module.exports = {
 
         return {
             BlockStatement(node) {
-                if (
-                    node.parent.type !== "BlockStatement" &&
-                    node.parent.type !== "SwitchCase" &&
-                    node.parent.type !== "Program"
-                ) {
+                if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
                     validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
                 }
             },

package/lib/rules/capitalized-comments.js

@@ -9,6 +9,7 @@
 //------------------------------------------------------------------------------
 
 const LETTER_PATTERN = require("../util/patterns/letters");
+const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -16,7 +17,7 @@ const LETTER_PATTERN = require("../util/patterns/letters");
 
 const ALWAYS_MESSAGE = "Comments should not begin with a lowercase character",
     NEVER_MESSAGE = "Comments should not begin with an uppercase character",
-    DEFAULT_IGNORE_PATTERN = /^\s*(?:eslint|istanbul|jscs|jshint|globals?|exported)\b/,
+    DEFAULT_IGNORE_PATTERN = astUtils.COMMENTS_IGNORE_PATTERN,
     WHITESPACE = /\s/g,
     MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/,    // TODO: Combine w/ max-len pattern?
     DEFAULTS = {
@@ -163,8 +164,8 @@ module.exports = {
          * otherwise.
          */
         function isInlineComment(comment) {
-            const previousToken = sourceCode.getTokenOrCommentBefore(comment),
-                nextToken = sourceCode.getTokenOrCommentAfter(comment);
+            const previousToken = sourceCode.getTokenBefore(comment, { includeComments: true }),
+                nextToken = sourceCode.getTokenAfter(comment, { includeComments: true });
 
             return Boolean(
                 previousToken &&
@@ -181,7 +182,7 @@ module.exports = {
          * @returns {boolean} True if the comment follows a valid comment.
          */
         function isConsecutiveComment(comment) {
-            const previousTokenOrComment = sourceCode.getTokenOrCommentBefore(comment);
+            const previousTokenOrComment = sourceCode.getTokenBefore(comment, { includeComments: true });
 
             return Boolean(
                 previousTokenOrComment &&
@@ -264,9 +265,9 @@ module.exports = {
                 commentValid = isCommentValid(comment, options);
 
             if (!commentValid) {
-                const message = capitalize === "always" ?
-                    ALWAYS_MESSAGE :
-                    NEVER_MESSAGE;
+                const message = capitalize === "always"
+                    ? ALWAYS_MESSAGE
+                    : NEVER_MESSAGE;
 
                 context.report({
                     node: null,         // Intentionally using loc instead

package/lib/rules/comma-spacing.js

@@ -96,9 +96,9 @@ module.exports = {
                     return fixer.replaceTextRange([start, end], newText);
 
                 },
-                message: options[dir] ?
-                  "A space is required {{dir}} ','." :
-                  "There should be no space {{dir}} ','.",
+                message: options[dir]
+                  ? "A space is required {{dir}} ','."
+                  : "There should be no space {{dir}} ','.",
                 data: {
                     dir
                 }

package/lib/rules/complexity.js

@@ -6,6 +6,14 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const lodash = require("lodash");
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -81,17 +89,15 @@ module.exports = {
          * @private
          */
         function endFunction(node) {
+            const name = lodash.upperFirst(astUtils.getFunctionNameWithKind(node));
             const complexity = fns.pop();
-            let name = "anonymous";
-
-            if (node.id) {
-                name = node.id.name;
-            } else if (node.parent.type === "MethodDefinition" || node.parent.type === "Property") {
-                name = node.parent.key.name;
-            }
 
             if (complexity > THRESHOLD) {
-                context.report({ node, message: "Function '{{name}}' has a complexity of {{complexity}}.", data: { name, complexity } });
+                context.report({
+                    node,
+                    message: "{{name}} has a complexity of {{complexity}}.",
+                    data: { name, complexity }
+                });
             }
         }
 

package/lib/rules/consistent-return.js

@@ -8,6 +8,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const lodash = require("lodash");
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
@@ -81,7 +83,7 @@ module.exports = {
          * @returns {void}
          */
         function checkLastSegment(node) {
-            let loc, type;
+            let loc, name;
 
             /*
              * Skip if it expected no return value or unreachable.
@@ -100,12 +102,11 @@ module.exports = {
 
                 // The head of program.
                 loc = { line: 1, column: 0 };
-                type = "program";
+                name = "program";
             } else if (node.type === "ArrowFunctionExpression") {
 
                 // `=>` token
-                loc = context.getSourceCode().getTokenBefore(node.body).loc.start;
-                type = "function";
+                loc = context.getSourceCode().getTokenBefore(node.body, astUtils.isArrowToken).loc.start;
             } else if (
                 node.parent.type === "MethodDefinition" ||
                 (node.parent.type === "Property" && node.parent.method)
@@ -113,33 +114,36 @@ module.exports = {
 
                 // Method name.
                 loc = node.parent.key.loc.start;
-                type = "method";
             } else {
 
                 // Function name or `function` keyword.
                 loc = (node.id || node).loc.start;
-                type = "function";
+            }
+
+            if (!name) {
+                name = astUtils.getFunctionNameWithKind(node);
             }
 
             // Reports.
             context.report({
                 node,
                 loc,
-                message: "Expected to return a value at the end of this {{type}}.",
-                data: { type }
+                message: "Expected to return a value at the end of {{name}}.",
+                data: { name }
             });
         }
 
         return {
 
             // Initializes/Disposes state of each code path.
-            onCodePathStart(codePath) {
+            onCodePathStart(codePath, node) {
                 funcInfo = {
                     upper: funcInfo,
                     codePath,
                     hasReturn: false,
                     hasReturnValue: false,
-                    message: ""
+                    message: "",
+                    node
                 };
             },
             onCodePathEnd() {
@@ -158,8 +162,11 @@ module.exports = {
                 if (!funcInfo.hasReturn) {
                     funcInfo.hasReturn = true;
                     funcInfo.hasReturnValue = hasReturnValue;
-                    funcInfo.message = "Expected {{which}} return value.";
+                    funcInfo.message = "{{name}} expected {{which}} return value.";
                     funcInfo.data = {
+                        name: funcInfo.node.type === "Program"
+                            ? "Program"
+                            : lodash.upperFirst(astUtils.getFunctionNameWithKind(funcInfo.node)),
                         which: hasReturnValue ? "a" : "no"
                     };
                 } else if (funcInfo.hasReturnValue !== hasReturnValue) {

package/lib/rules/constructor-super.js

@@ -209,9 +209,9 @@ module.exports = {
 
                 if (!calledInEveryPaths) {
                     context.report({
-                        message: calledInSomePaths ?
-                            "Lacked a call of 'super()' in some code paths." :
-                            "Expected to call 'super()'.",
+                        message: calledInSomePaths
+                            ? "Lacked a call of 'super()' in some code paths."
+                            : "Expected to call 'super()'.",
                         node: node.parent
                     });
                 }

package/lib/rules/curly.js

@@ -94,19 +94,23 @@ module.exports = {
             return first.loc.start.line === last.loc.end.line;
         }
 
+        /**
+         * Checks if the given token is an `else` token or not.
+         *
+         * @param {Token} token - The token to check.
+         * @returns {boolean} `true` if the token is an `else` token.
+         */
+        function isElseKeywordToken(token) {
+            return token.value === "else" && token.type === "Keyword";
+        }
+
         /**
          * Gets the `else` keyword token of a given `IfStatement` node.
          * @param {ASTNode} node - A `IfStatement` node to get.
          * @returns {Token} The `else` keyword token.
          */
         function getElseKeyword(node) {
-            let token = sourceCode.getTokenAfter(node.consequent);
-
-            while (token.type !== "Keyword" || token.value !== "else") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return node.alternate && sourceCode.getFirstTokenBetween(node.consequent, node.alternate, isElseKeywordToken);
         }
 
         /**

package/lib/rules/default-case.js

@@ -31,9 +31,9 @@ module.exports = {
 
     create(context) {
         const options = context.options[0] || {};
-        const commentPattern = options.commentPattern ?
-            new RegExp(options.commentPattern) :
-            DEFAULT_COMMENT_PATTERN;
+        const commentPattern = options.commentPattern
+            ? new RegExp(options.commentPattern)
+            : DEFAULT_COMMENT_PATTERN;
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/eqeqeq.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -57,9 +63,9 @@ module.exports = {
         const options = context.options[1] || {};
         const sourceCode = context.getSourceCode();
 
-        const nullOption = (config === "always") ?
-            options.null || "always" :
-            "ignore";
+        const nullOption = (config === "always")
+            ? options.null || "always"
+            : "ignore";
         const enforceRuleForNull = (nullOption === "always");
         const enforceInverseRuleForNull = (nullOption === "never");
 
@@ -100,8 +106,7 @@ module.exports = {
          * @private
          */
         function isNullCheck(node) {
-            return (node.right.type === "Literal" && node.right.value === null) ||
-                    (node.left.type === "Literal" && node.left.value === null);
+            return astUtils.isNullLiteral(node.right) || astUtils.isNullLiteral(node.left);
         }
 
         /**
@@ -134,7 +139,11 @@ module.exports = {
 
                     // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
                     if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
-                        const operatorToken = sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+                        const operatorToken = sourceCode.getFirstTokenBetween(
+                            node.left,
+                            node.right,
+                            token => token.value === node.operator
+                        );
 
                         return fixer.replaceText(operatorToken, expectedOperator);
                     }