eslint 3.16.0 → 3.18.0

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/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);
             }
         }

package/lib/rules/line-comment-position.js

@@ -4,6 +4,8 @@
  */
 "use strict";
 
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -33,6 +35,9 @@ module.exports = {
                             },
                             applyDefaultPatterns: {
                                 type: "boolean"
+                            },
+                            applyDefaultIgnorePatterns: {
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -43,12 +48,11 @@ module.exports = {
     },
 
     create(context) {
-        const DEFAULT_IGNORE_PATTERN = "^\\s*(?:eslint|jshint\\s+|jslint\\s+|istanbul\\s+|globals?\\s+|exported\\s+|jscs|falls?\\s?through)";
         const options = context.options[0];
 
         let above,
             ignorePattern,
-            applyDefaultPatterns = true;
+            applyDefaultIgnorePatterns = true;
 
         if (!options || typeof options === "string") {
             above = !options || options === "above";
@@ -56,10 +60,16 @@ module.exports = {
         } else {
             above = options.position === "above";
             ignorePattern = options.ignorePattern;
-            applyDefaultPatterns = options.applyDefaultPatterns !== false;
+
+            if (options.hasOwnProperty("applyDefaultIgnorePatterns")) {
+                applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== false;
+            } else {
+                applyDefaultIgnorePatterns = options.applyDefaultPatterns !== false;
+            }
         }
 
-        const defaultIgnoreRegExp = new RegExp(DEFAULT_IGNORE_PATTERN);
+        const defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN;
+        const fallThroughRegExp = /^\s*falls?\s?through/;
         const customIgnoreRegExp = new RegExp(ignorePattern);
         const sourceCode = context.getSourceCode();
 
@@ -69,7 +79,7 @@ module.exports = {
 
         return {
             LineComment(node) {
-                if (applyDefaultPatterns && defaultIgnoreRegExp.test(node.value)) {
+                if (applyDefaultIgnorePatterns && (defaultIgnoreRegExp.test(node.value) || fallThroughRegExp.test(node.value))) {
                     return;
                 }
 

package/lib/rules/lines-around-comment.js

@@ -93,6 +93,12 @@ module.exports = {
                     },
                     allowArrayEnd: {
                         type: "boolean"
+                    },
+                    ignorePattern: {
+                        type: "string"
+                    },
+                    applyDefaultIgnorePatterns: {
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -103,6 +109,11 @@ module.exports = {
     create(context) {
 
         const options = context.options[0] ? Object.assign({}, context.options[0]) : {};
+        const ignorePattern = options.ignorePattern;
+        const defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN;
+        const customIgnoreRegExp = new RegExp(ignorePattern);
+        const applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== false;
+
 
         options.beforeLineComment = options.beforeLineComment || false;
         options.afterLineComment = options.afterLineComment || false;
@@ -270,6 +281,14 @@ module.exports = {
          * @returns {void}
          */
         function checkForEmptyLine(node, opts) {
+            if (applyDefaultIgnorePatterns && defaultIgnoreRegExp.test(node.value)) {
+                return;
+            }
+
+            if (ignorePattern && customIgnoreRegExp.test(node.value)) {
+                return;
+            }
+
             let after = opts.after,
                 before = opts.before;
 

package/lib/rules/max-params.js

@@ -5,6 +5,14 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const lodash = require("lodash");
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -66,10 +74,15 @@ module.exports = {
          */
         function checkFunction(node) {
             if (node.params.length > numParams) {
-                context.report({ node, message: "This function has too many parameters ({{count}}). Maximum allowed is {{max}}.", data: {
-                    count: node.params.length,
-                    max: numParams
-                } });
+                context.report({
+                    node,
+                    message: "{{name}} has too many parameters ({{count}}). Maximum allowed is {{max}}.",
+                    data: {
+                        name: lodash.upperFirst(astUtils.getFunctionNameWithKind(node)),
+                        count: node.params.length,
+                        max: numParams
+                    }
+                });
             }
         }
 

package/lib/rules/max-statements.js

@@ -5,6 +5,14 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const lodash = require("lodash");
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -84,19 +92,12 @@ module.exports = {
          */
         function reportIfTooManyStatements(node, count, max) {
             if (count > max) {
-                const messageEnd = " has too many statements ({{count}}). Maximum allowed is {{max}}.";
-                let name = "This function";
-
-                if (node.id) {
-                    name = `Function '${node.id.name}'`;
-                } else if (node.parent.type === "MethodDefinition" || node.parent.type === "Property") {
-                    name = `Function '${context.getSource(node.parent.key)}'`;
-                }
+                const name = lodash.upperFirst(astUtils.getFunctionNameWithKind(node));
 
                 context.report({
                     node,
-                    message: name + messageEnd,
-                    data: { count, max }
+                    message: "{{name}} has too many statements ({{count}}). Maximum allowed is {{max}}.",
+                    data: { name, count, max }
                 });
             }
         }

package/lib/rules/no-compare-neg-zero.js

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview The rule should warn against code that tries to compare against -0.
+ * @author Aladdin-ADD <hh_2013@foxmail.com>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow comparing against -0",
+            category: "Possible Errors",
+            recommended: false
+        },
+        fixable: null,
+        schema: []
+    },
+
+    create(context) {
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        /**
+         * Checks a given node is -0
+         *
+         * @param {ASTNode} node - A node to check.
+         * @returns {boolean} `true` if the node is -0.
+         */
+        function isNegZero(node) {
+            return node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "Literal" && node.argument.value === 0;
+        }
+        const OPERATORS_TO_CHECK = new Set([">", ">=", "<", "<=", "==", "===", "!=", "!=="]);
+
+        return {
+            BinaryExpression(node) {
+                if (OPERATORS_TO_CHECK.has(node.operator)) {
+                    if (isNegZero(node.left) || isNegZero(node.right)) {
+                        context.report({
+                            node,
+                            message: "Do not use the '{{operator}}' operator to compare against -0.",
+                            data: { operator: node.operator }
+                        });
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-else-return.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const FixTracker = require("../util/fix-tracker");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -86,7 +92,13 @@ module.exports = {
                     } else {
                         fixedSource = source;
                     }
-                    return fixer.replaceTextRange([elseToken.start, node.end], fixedSource);
+
+                    // Extend the replacement range to include the entire
+                    // function to avoid conflicting with no-useless-return.
+                    // https://github.com/eslint/eslint/issues/8026
+                    return new FixTracker(fixer, sourceCode)
+                        .retainEnclosingFunction(node)
+                        .replaceTextRange([elseToken.start, node.end], fixedSource);
                 }
             });
         }

package/lib/rules/no-empty-function.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -19,18 +25,6 @@ const ALLOW_OPTIONS = Object.freeze([
     "setters",
     "constructors"
 ]);
-const SHOW_KIND = Object.freeze({
-    functions: "function",
-    arrowFunctions: "arrow function",
-    generatorFunctions: "generator function",
-    asyncFunctions: "async function",
-    methods: "method",
-    generatorMethods: "generator method",
-    asyncMethods: "async method",
-    getters: "getter",
-    setters: "setter",
-    constructors: "constructor"
-});
 
 /**
  * Gets the kind of a given function node.
@@ -137,6 +131,7 @@ module.exports = {
          */
         function reportIfEmpty(node) {
             const kind = getKind(node);
+            const name = astUtils.getFunctionNameWithKind(node);
 
             if (allowed.indexOf(kind) === -1 &&
                 node.body.type === "BlockStatement" &&
@@ -146,10 +141,8 @@ module.exports = {
                 context.report({
                     node,
                     loc: node.body.loc.start,
-                    message: "Unexpected empty {{kind}}.",
-                    data: {
-                        kind: SHOW_KIND[kind]
-                    }
+                    message: "Unexpected empty {{name}}.",
+                    data: { name }
                 });
             }
         }