eslint 3.16.1 → 3.19.0

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

@@ -100,7 +100,7 @@ module.exports = {
                             const firstValueToken = sourceCode.getTokenAfter(returnKeyword);
                             let lastValueToken = sourceCode.getLastToken(blockBody[0]);
 
-                            if (lastValueToken.type === "Punctuator" && lastValueToken.value === ";") {
+                            if (astUtils.isSemicolonToken(lastValueToken)) {
 
                                 /* The last token of the returned value is the last token of the ReturnExpression (if
                                  * the ReturnExpression has no semicolon), or the second-to-last token (if the ReturnExpression
@@ -120,7 +120,7 @@ module.exports = {
                             const textBeforeReturn = sourceText.slice(arrowBody.range[0] + 1, returnKeyword.range[0]);
                             const textBetweenReturnAndValue = sourceText.slice(returnKeyword.range[1], firstValueToken.range[0]);
                             const rawReturnValueText = sourceText.slice(firstValueToken.range[0], lastValueToken.range[1]);
-                            const returnValueText = firstValueToken.value === "{" ? `(${rawReturnValueText})` : rawReturnValueText;
+                            const returnValueText = astUtils.isOpeningBraceToken(firstValueToken) ? `(${rawReturnValueText})` : rawReturnValueText;
                             const textAfterValue = sourceText.slice(lastValueToken.range[1], blockBody[0].range[1] - 1);
                             const textAfterReturnStatement = sourceText.slice(blockBody[0].range[1], arrowBody.range[1] - 1);
 

package/lib/rules/arrow-parens.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -62,7 +68,7 @@ module.exports = {
                 node.body.type !== "BlockStatement" &&
                 !node.returnType
             ) {
-                if (token.type === "Punctuator" && token.value === "(") {
+                if (astUtils.isOpeningParenToken(token)) {
                     context.report({
                         node,
                         message: requireForBlockBodyMessage,
@@ -84,7 +90,7 @@ module.exports = {
                 requireForBlockBody &&
                 node.body.type === "BlockStatement"
             ) {
-                if (token.type !== "Punctuator" || token.value !== "(") {
+                if (!astUtils.isOpeningParenToken(token)) {
                     context.report({
                         node,
                         message: requireForBlockBodyNoParensMessage,
@@ -103,7 +109,7 @@ module.exports = {
                 !node.params[0].typeAnnotation &&
                 !node.returnType
             ) {
-                if (token.type === "Punctuator" && token.value === "(") {
+                if (astUtils.isOpeningParenToken(token)) {
                     context.report({
                         node,
                         message: asNeededMessage,

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 = {

package/lib/rules/comma-dangle.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const lodash = require("lodash");
+const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -178,7 +179,7 @@ module.exports = {
                 default: {
                     const nextToken = sourceCode.getTokenAfter(lastItem);
 
-                    if (nextToken.value === ",") {
+                    if (astUtils.isCommaToken(nextToken)) {
                         return nextToken;
                     }
                     return sourceCode.getLastToken(lastItem);
@@ -224,7 +225,7 @@ module.exports = {
 
             const trailingToken = getTrailingToken(node, lastItem);
 
-            if (trailingToken.value === ",") {
+            if (astUtils.isCommaToken(trailingToken)) {
                 context.report({
                     node: lastItem,
                     loc: trailingToken.loc.start,

package/lib/rules/comma-spacing.js

@@ -53,16 +53,6 @@ module.exports = {
         // list of comma tokens to ignore for the check of leading whitespace
         const commaTokensToIgnore = [];
 
-        /**
-         * Determines if a given token is a comma operator.
-         * @param {ASTNode} token The token to check.
-         * @returns {boolean} True if the token is a comma, false if not.
-         * @private
-         */
-        function isComma(token) {
-            return !!token && (token.type === "Punctuator") && (token.value === ",");
-        }
-
         /**
          * Reports a spacing error with an appropriate message.
          * @param {ASTNode} node The binary expression node to report.
@@ -147,7 +137,7 @@ module.exports = {
                 if (element === null) {
                     token = sourceCode.getTokenAfter(previousToken);
 
-                    if (isComma(token)) {
+                    if (astUtils.isCommaToken(token)) {
                         commaTokensToIgnore.push(token);
                     }
                 } else {
@@ -166,7 +156,7 @@ module.exports = {
             "Program:exit"() {
                 tokensAndComments.forEach((token, i) => {
 
-                    if (!isComma(token)) {
+                    if (!astUtils.isCommaToken(token)) {
                         return;
                     }
 
@@ -179,8 +169,8 @@ module.exports = {
 
                     validateCommaItemSpacing({
                         comma: token,
-                        left: isComma(previousToken) || commaTokensToIgnore.indexOf(token) > -1 ? null : previousToken,
-                        right: isComma(nextToken) ? null : nextToken
+                        left: astUtils.isCommaToken(previousToken) || commaTokensToIgnore.indexOf(token) > -1 ? null : previousToken,
+                        right: astUtils.isCommaToken(nextToken) ? null : nextToken
                     }, token);
                 });
             },

package/lib/rules/comma-style.js

@@ -63,16 +63,6 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        /**
-         * Determines if a given token is a comma operator.
-         * @param {ASTNode} token The token to check.
-         * @returns {boolean} True if the token is a comma, false if not.
-         * @private
-         */
-        function isComma(token) {
-            return !!token && (token.type === "Punctuator") && (token.value === ",");
-        }
-
         /**
          * Modified text based on the style
          * @param {string} styleType Style type
@@ -192,7 +182,7 @@ module.exports = {
                         tokenBeforeComma = sourceCode.getTokenBefore(commaToken);
 
                     // Check if previous token is wrapped in parentheses
-                    if (tokenBeforeComma && tokenBeforeComma.value === ")") {
+                    if (tokenBeforeComma && astUtils.isClosingParenToken(tokenBeforeComma)) {
                         previousItemToken = tokenBeforeComma;
                     }
 
@@ -210,12 +200,16 @@ module.exports = {
                      * All comparisons are done based on these tokens directly, so
                      * they are always valid regardless of an undefined item.
                      */
-                    if (isComma(commaToken)) {
+                    if (astUtils.isCommaToken(commaToken)) {
                         validateCommaItemSpacing(previousItemToken, commaToken,
                                 currentItemToken, reportItem);
                     }
 
-                    previousItemToken = item ? sourceCode.getLastToken(item) : previousItemToken;
+                    if (item) {
+                        const tokenAfterItem = sourceCode.getTokenAfter(item, astUtils.isNotClosingParenToken);
+
+                        previousItemToken = tokenAfterItem ? sourceCode.getTokenBefore(tokenAfterItem) : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
+                    }
                 });
 
                 /*
@@ -229,7 +223,7 @@ module.exports = {
                     const lastToken = sourceCode.getLastToken(node),
                         nextToLastToken = sourceCode.getTokenBefore(lastToken);
 
-                    if (isComma(nextToLastToken)) {
+                    if (astUtils.isCommaToken(nextToLastToken)) {
                         validateCommaItemSpacing(
                             sourceCode.getTokenBefore(nextToLastToken),
                             nextToLastToken,

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, astUtils.isArrowToken).loc.start;
-                type = "function";
             } 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/curly.js

@@ -76,7 +76,7 @@ module.exports = {
         function isCollapsedOneLiner(node) {
             const before = sourceCode.getTokenBefore(node);
             const last = sourceCode.getLastToken(node);
-            const lastExcludingSemicolon = last.type === "Punctuator" && last.value === ";" ? sourceCode.getTokenBefore(last) : last;
+            const lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
 
             return before.loc.start.line === lastExcludingSemicolon.loc.end.line;
         }
@@ -174,7 +174,7 @@ module.exports = {
             const tokenAfter = sourceCode.getTokenAfter(closingBracket);
             const lastBlockNode = sourceCode.getNodeByRangeIndex(tokenBefore.range[0]);
 
-            if (tokenBefore.value === ";") {
+            if (astUtils.isSemicolonToken(tokenBefore)) {
 
                 // If the last statement already has a semicolon, don't add another one.
                 return false;

package/lib/rules/dot-notation.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -64,20 +70,20 @@ module.exports = {
                                 propertyValue: JSON.stringify(node.property.value)
                             },
                             fix(fixer) {
-                                const leftBracket = sourceCode.getTokenBefore(node.property);
-                                const rightBracket = sourceCode.getTokenAfter(node.property);
-                                const textBeforeProperty = sourceCode.text.slice(leftBracket.range[1], node.property.range[0]);
-                                const textAfterProperty = sourceCode.text.slice(node.property.range[1], rightBracket.range[0]);
+                                const leftBracket = sourceCode.getTokenAfter(node.object, astUtils.isOpeningBracketToken);
+                                const rightBracket = sourceCode.getLastToken(node);
 
-                                if (textBeforeProperty.trim() || textAfterProperty.trim()) {
+                                if (sourceCode.getFirstTokenBetween(leftBracket, rightBracket, { includeComments: true, filter: astUtils.isCommentToken })) {
 
                                     // Don't perform any fixes if there are comments inside the brackets.
                                     return null;
                                 }
 
+                                const textBeforeDot = astUtils.isDecimalInteger(node.object) ? " " : "";
+
                                 return fixer.replaceTextRange(
                                     [leftBracket.range[0], rightBracket.range[1]],
-                                    `.${node.property.value}`
+                                    `${textBeforeDot}.${node.property.value}`
                                 );
                             }
                         });

package/lib/rules/func-name-matching.js

@@ -132,6 +132,15 @@ module.exports = {
             });
         }
 
+        /**
+         * Determines whether a given node is a string literal
+         * @param {ASTNode} node The node to check
+         * @returns {boolean} `true` if the node is a string literal
+         */
+        function isStringLiteral(node) {
+            return node.type === "Literal" && typeof node.value === "string";
+        }
+
         //--------------------------------------------------------------------------
         // Public
         //--------------------------------------------------------------------------
@@ -139,7 +148,7 @@ module.exports = {
         return {
 
             VariableDeclarator(node) {
-                if (!node.init || node.init.type !== "FunctionExpression") {
+                if (!node.init || node.init.type !== "FunctionExpression" || node.id.type !== "Identifier") {
                     return;
                 }
                 if (node.init.id && shouldWarn(node.id.name, node.init.id.name)) {
@@ -148,10 +157,12 @@ module.exports = {
             },
 
             AssignmentExpression(node) {
-                if (node.right.type !== "FunctionExpression" ||
-                   (node.left.computed && node.left.property.type !== "Literal") ||
-                    (!includeModuleExports && isModuleExports(node.left))
-                   ) {
+                if (
+                    node.right.type !== "FunctionExpression" ||
+                    (node.left.computed && node.left.property.type !== "Literal") ||
+                    (!includeModuleExports && isModuleExports(node.left)) ||
+                    (node.left.type !== "Identifier" && node.left.type !== "MemberExpression")
+                ) {
                     return;
                 }
 
@@ -164,13 +175,13 @@ module.exports = {
             },
 
             Property(node) {
-                if (node.value.type !== "FunctionExpression" || !node.value.id || node.computed && node.key.type !== "Literal") {
+                if (node.value.type !== "FunctionExpression" || !node.value.id || node.computed && !isStringLiteral(node.key)) {
                     return;
                 }
                 if (node.key.type === "Identifier" && shouldWarn(node.key.name, node.value.id.name)) {
                     report(node, node.key.name, node.value.id.name, true);
                 } else if (
-                    node.key.type === "Literal" &&
+                    isStringLiteral(node.key) &&
                     isIdentifier(node.key.value, ecmaVersion) &&
                     shouldWarn(node.key.value, node.value.id.name)
                 ) {

package/lib/rules/func-names.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 /**
  * Checks whether or not a given variable is a function name.
  * @param {escope.Variable} variable - A variable to check.
@@ -82,15 +88,24 @@ module.exports = {
                     return;
                 }
 
-                const name = node.id && node.id.name;
+                const hasName = Boolean(node.id && node.id.name);
+                const name = astUtils.getFunctionNameWithKind(node);
 
                 if (never) {
-                    if (name) {
-                        context.report({ node, message: "Unexpected function expression name." });
+                    if (hasName) {
+                        context.report({
+                            node,
+                            message: "Unexpected named {{name}}.",
+                            data: { name }
+                        });
                     }
                 } else {
-                    if (!name && (asNeeded ? !hasInferredName(node) : !isObjectOrClassMethod(node))) {
-                        context.report({ node, message: "Missing function expression name." });
+                    if (!hasName && (asNeeded ? !hasInferredName(node) : !isObjectOrClassMethod(node))) {
+                        context.report({
+                            node,
+                            message: "Unexpected unnamed {{name}}.",
+                            data: { name }
+                        });
                     }
                 }
             }

package/lib/rules/keyword-spacing.js

@@ -359,7 +359,8 @@ module.exports = {
             const firstToken = node && sourceCode.getFirstToken(node);
 
             if (firstToken &&
-                (firstToken.type === "Keyword" || firstToken.value === "async")
+                ((firstToken.type === "Keyword" && firstToken.value === "function") ||
+                firstToken.value === "async")
             ) {
                 checkSpacingBefore(firstToken);
             }
@@ -495,11 +496,25 @@ module.exports = {
                     node.value.async
                 )
             ) {
-                const token = sourceCode.getFirstToken(
-                    node,
-                    node.static ? 1 : 0
+                const token = sourceCode.getTokenBefore(
+                    node.key,
+                    tok => {
+                        switch (tok.value) {
+                            case "get":
+                            case "set":
+                            case "async":
+                                return true;
+                            default:
+                                return false;
+                        }
+                    }
                 );
 
+                if (!token) {
+                    throw new Error("Failed to find token get, set, or async beside method name");
+                }
+
+
                 checkSpacingAround(token);
             }
         }