eslint 3.9.0 → 3.10.2

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

@@ -22,9 +22,7 @@ module.exports = {
             type: "array",
             items: [
                 {
-                    enum: Object.keys(nodeTypes).map(function(k) {
-                        return nodeTypes[k];
-                    })
+                    enum: Object.keys(nodeTypes).map(k => nodeTypes[k])
                 }
             ],
             uniqueItems: true,
@@ -43,7 +41,7 @@ module.exports = {
             context.report(node, "Using '{{type}}' is not allowed.", node);
         }
 
-        return context.options.reduce(function(result, nodeType) {
+        return context.options.reduce((result, nodeType) => {
             result[nodeType] = warn;
 
             return result;

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

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Disallows unnecessary `return await`
+ * @author Jordan Harband
+ */
+"use strict";
+
+const astUtils = require("../ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const message = "Redundant use of `await` on a return value.";
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow unnecessary `return await`",
+            category: "Best Practices",
+            recommended: false // TODO: set to true
+        },
+        fixable: false,
+        schema: [
+        ]
+    },
+
+    create(context) {
+
+        /**
+        * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
+        * this function. For example, a statement in a `try` block will always have an error handler. A statement in
+        * a `catch` block will only have an error handler if there is also a `finally` block.
+        * @param {ASTNode} node A node representing a location where an could be thrown
+        * @returns {boolean} `true` if a thrown error will be caught/handled in this function
+        */
+        function hasErrorHandler(node) {
+            let ancestor = node;
+
+            while (!astUtils.isFunction(ancestor) && ancestor.type !== "Program") {
+                if (ancestor.parent.type === "TryStatement" && (ancestor === ancestor.parent.block || ancestor === ancestor.parent.handler && ancestor.parent.finalizer)) {
+                    return true;
+                }
+                ancestor = ancestor.parent;
+            }
+            return false;
+        }
+
+        return {
+            ArrowFunctionExpression(node) {
+                if (node.async && node.body.type === "AwaitExpression") {
+                    const sourceCode = context.getSourceCode();
+                    const loc = node.body.loc;
+
+                    context.report({
+                        node: sourceCode.getFirstToken(node.body),
+                        loc,
+                        message,
+                    });
+                }
+            },
+            ReturnStatement(node) {
+                const argument = node.argument;
+
+                if (argument && argument.type === "AwaitExpression" && !hasErrorHandler(node)) {
+                    const sourceCode = context.getSourceCode();
+                    const loc = argument.loc;
+
+                    context.report({
+                        node: sourceCode.getFirstToken(argument),
+                        loc,
+                        message,
+                    });
+                }
+            },
+        };
+    }
+};

package/lib/rules/no-tabs.js

@@ -17,7 +17,7 @@ const regex = /\t/;
 module.exports = {
     meta: {
         docs: {
-            description: "disallow tabs in file",
+            description: "disallow all tabs",
             category: "Stylistic Issues",
             recommended: false
         },

package/lib/rules/no-this-before-super.js

@@ -179,7 +179,7 @@ module.exports = {
                     return;
                 }
 
-                codePath.traverseSegments(function(segment, controller) {
+                codePath.traverseSegments((segment, controller) => {
                     const info = segInfoMap[segment.id];
 
                     for (let i = 0; i < info.invalidNodes.length; ++i) {
@@ -237,7 +237,7 @@ module.exports = {
                 // Update information inside of the loop.
                 funcInfo.codePath.traverseSegments(
                     {first: toSegment, last: fromSegment},
-                    function(segment, controller) {
+                    (segment, controller) => {
                         const info = segInfoMap[segment.id];
 
                         if (info.superCalled) {

package/lib/rules/no-undef.js

@@ -52,7 +52,7 @@ module.exports = {
             "Program:exit"(/* node */) {
                 const globalScope = context.getScope();
 
-                globalScope.through.forEach(function(ref) {
+                globalScope.through.forEach(ref => {
                     const identifier = ref.identifier;
 
                     if (!considerTypeOf && hasTypeOfOperator(identifier)) {

package/lib/rules/no-underscore-dangle.js

@@ -57,9 +57,7 @@ module.exports = {
          * @private
          */
         function isAllowed(identifier) {
-            return ALLOWED_VARIABLES.some(function(ident) {
-                return ident === identifier;
-            });
+            return ALLOWED_VARIABLES.some(ident => ident === identifier);
         }
 
         /**

package/lib/rules/no-unused-vars.js

@@ -390,15 +390,11 @@ module.exports = {
          * @private
          */
         function isUsedVariable(variable) {
-            const functionNodes = variable.defs.filter(function(def) {
-                    return def.type === "FunctionName";
-                }).map(function(def) {
-                    return def.node;
-                }),
+            const functionNodes = variable.defs.filter(def => def.type === "FunctionName").map(def => def.node),
                 isFunctionDefinition = functionNodes.length > 0;
             let rhsNode = null;
 
-            return variable.references.some(function(ref) {
+            return variable.references.some(ref => {
                 if (isForInRef(ref)) {
                     return true;
                 }

package/lib/rules/no-use-before-define.js

@@ -187,7 +187,7 @@ module.exports = {
          * @private
          */
         function findVariablesInScope(scope) {
-            scope.references.forEach(function(reference) {
+            scope.references.forEach(reference => {
                 const variable = reference.resolved;
 
                 // Skips when the reference is:

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

@@ -22,55 +22,10 @@ function union(setA, setB) {
     }());
 }
 
-const VALID_STRING_ESCAPES = [
-    "\\",
-    "n",
-    "r",
-    "v",
-    "t",
-    "b",
-    "f",
-    "u",
-    "x",
-    "\n",
-    "\r"
-];
-
-const REGEX_GENERAL_ESCAPES = new Set([
-    "\\",
-    "b",
-    "c",
-    "d",
-    "D",
-    "f",
-    "n",
-    "r",
-    "s",
-    "S",
-    "t",
-    "v",
-    "w",
-    "W",
-    "x",
-    "u"
-]);
-const REGEX_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set(["]"]));
-const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set([
-    "^",
-    "/",
-    ".",
-    "$",
-    "*",
-    "+",
-    "?",
-    "[",
-    "{",
-    "}",
-    "|",
-    "(",
-    ")",
-    "B"
-]));
+const VALID_STRING_ESCAPES = new Set("\\nrvtbfux\n\r");
+const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnrsStvwWxu0123456789");
+const REGEX_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("]"));
+const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("^/.$*+?[{}|()B"));
 
 /**
 * Parses a regular expression into a list of characters with character class info.
@@ -150,15 +105,14 @@ module.exports = {
          * Checks if the escape character in given string slice is unnecessary.
          *
          * @private
-         * @param {string[]} escapes - list of valid escapes
          * @param {ASTNode} node - node to validate.
          * @param {string} match - string slice to validate.
          * @returns {void}
          */
-        function validateString(escapes, node, match) {
+        function validateString(node, match) {
             const isTemplateElement = node.type === "TemplateElement";
             const escapedChar = match[0][1];
-            let isUnnecessaryEscape = escapes.indexOf(escapedChar) === -1;
+            let isUnnecessaryEscape = !VALID_STRING_ESCAPES.has(escapedChar);
             let isQuoteEscape;
 
             if (isTemplateElement) {
@@ -208,14 +162,14 @@ module.exports = {
                  * JSXAttribute doesn't have any escape sequence: https://facebook.github.io/jsx/.
                  * In addition, backticks are not supported by JSX yet: https://github.com/facebook/jsx/issues/25.
                  */
-                if (node.parent.type === "JSXAttribute") {
+                if (node.parent.type === "JSXAttribute" || node.parent.type === "JSXElement") {
                     return;
                 }
 
                 let match;
 
                 while ((match = pattern.exec(value))) {
-                    validateString(VALID_STRING_ESCAPES, node, match);
+                    validateString(node, match);
                 }
             } else if (node.regex) {
                 parseRegExp(node.regex.pattern)

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

@@ -107,6 +107,7 @@ module.exports = {
 
     create(context) {
         const segmentInfoMap = new WeakMap();
+        const usedUnreachableSegments = new WeakSet();
         let scopeInfo = null;
 
         /**
@@ -175,8 +176,10 @@ module.exports = {
          */
         function markReturnStatementsOnSegmentAsUsed(segment) {
             if (!segment.reachable) {
+                usedUnreachableSegments.add(segment);
                 segment.allPrevSegments
                     .filter(isReturned)
+                    .filter(prevSegment => !usedUnreachableSegments.has(prevSegment))
                     .forEach(markReturnStatementsOnSegmentAsUsed);
                 return;
             }
@@ -254,6 +257,9 @@ module.exports = {
 
             // Adds ReturnStatement node to check whether it's useless or not.
             ReturnStatement(node) {
+                if (node.argument) {
+                    markReturnStatementsOnCurrentSegmentsAsUsed();
+                }
                 if (node.argument || isInLoop(node) || isInFinally(node)) {
                     return;
                 }

package/lib/rules/no-warning-comments.js

@@ -95,7 +95,7 @@ module.exports = {
         function commentContainsWarningTerm(comment) {
             const matches = [];
 
-            warningRegExps.forEach(function(regex, index) {
+            warningRegExps.forEach((regex, index) => {
                 if (regex.test(comment)) {
                     matches.push(warningTerms[index]);
                 }
@@ -116,7 +116,7 @@ module.exports = {
 
             const matches = commentContainsWarningTerm(node.value);
 
-            matches.forEach(function(matchedTerm) {
+            matches.forEach(matchedTerm => {
                 context.report({
                     node,
                     message: "Unexpected '{{matchedTerm}}' comment.",

package/lib/rules/object-shorthand.js

@@ -100,6 +100,7 @@ module.exports = {
         const PARAMS = context.options[1] || {};
         const IGNORE_CONSTRUCTORS = PARAMS.ignoreConstructors;
         const AVOID_QUOTES = PARAMS.avoidQuotes;
+        const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -296,14 +297,19 @@ module.exports = {
                             node,
                             message: "Expected method shorthand.",
                             fix(fixer) {
+
+                                // NOTE: If this rule is enhanced to handle arrow functions as well, this logic needs to be updated.
+                                const functionToken = sourceCode.getTokens(node).find(token => token.type === "Keyword" && token.value === "function");
+
                                 if (node.value.generator) {
-                                    return fixer.replaceTextRange(
-                                        [node.key.range[0], node.value.range[0] + "function*".length],
-                                        `*[${node.key.name}]`
-                                    );
+                                    return fixer.replaceTextRange([sourceCode.getTokenBefore(node.key).range[0], sourceCode.getTokenAfter(functionToken).range[1]], `*[${sourceCode.getText(node.key)}]`);
+                                }
+
+                                if (node.value.async) {
+                                    return fixer.replaceTextRange([sourceCode.getTokenBefore(node.key).range[0], functionToken.range[1]], `async [${sourceCode.getText(node.key)}]`);
                                 }
 
-                                return fixer.removeRange([node.key.range[1] + 1, node.value.range[0] + "function".length]);
+                                return fixer.removeRange([sourceCode.getTokenAfter(node.key).range[1], functionToken.range[1]]);
                             }
                         });
                         return;
@@ -314,14 +320,19 @@ module.exports = {
                         node,
                         message: "Expected method shorthand.",
                         fix(fixer) {
+
+                            // NOTE: If this rule is enhanced to handle arrow functions as well, this logic needs to be updated.
+                            const functionToken = sourceCode.getTokens(node).find(token => token.type === "Keyword" && token.value === "function");
+
                             if (node.value.generator) {
-                                return fixer.replaceTextRange(
-                                    [node.key.range[0], node.value.range[0] + "function*".length],
-                                    `*${node.key.name}`
-                                );
+                                return fixer.replaceTextRange([node.key.range[0], sourceCode.getTokenAfter(functionToken).range[1]], `*${sourceCode.getText(node.key)}`);
+                            }
+
+                            if (node.value.async) {
+                                return fixer.replaceTextRange([node.key.range[0], functionToken.range[1]], `async ${sourceCode.getText(node.key)}`);
                             }
 
-                            return fixer.removeRange([node.key.range[1], node.value.range[0] + "function".length]);
+                            return fixer.removeRange([node.key.range[1], functionToken.range[1]]);
                         }
                     });
                 } else if (node.value.type === "Identifier" && node.key.name === node.value.name && APPLY_TO_PROPS) {

package/lib/rules/one-var-declaration-per-line.js

@@ -59,7 +59,7 @@ module.exports = {
             const declarations = node.declarations;
             let prev;
 
-            declarations.forEach(function(current) {
+            declarations.forEach(current => {
                 if (prev && prev.loc.end.line === current.loc.start.line) {
                     if (always || prev.init || current.init) {
                         context.report({

package/lib/rules/prefer-const.js

@@ -270,9 +270,7 @@ module.exports = {
                     message: "'{{name}}' is never reassigned. Use 'const' instead.",
                     data: node
                 },
-                varDeclParent = findUp(node, "VariableDeclaration", function(parentNode) {
-                    return lodash.endsWith(parentNode.type, "Statement");
-                }),
+                varDeclParent = findUp(node, "VariableDeclaration", parentNode => lodash.endsWith(parentNode.type, "Statement")),
                 isNormalVarDecl = (node.parent.parent.parent.type === "ForInStatement" ||
                         node.parent.parent.parent.type === "ForOfStatement" ||
                         node.parent.init),

package/lib/rules/prefer-reflect.js

@@ -14,7 +14,8 @@ module.exports = {
         docs: {
             description: "require `Reflect` methods where applicable",
             category: "ECMAScript 6",
-            recommended: false
+            recommended: false,
+            replacedBy: []
         },
 
         deprecated: true,

package/lib/rules/quote-props.js

@@ -213,7 +213,7 @@ module.exports = {
             let keywordKeyName = null,
                 necessaryQuotes = false;
 
-            node.properties.forEach(function(property) {
+            node.properties.forEach(property => {
                 const key = property.key;
                 let tokens;
 

package/lib/rules/quotes.js

@@ -51,7 +51,7 @@ QUOTE_SETTINGS.backtick.convert = function(str) {
     if (newQuote === oldQuote) {
         return str;
     }
-    return newQuote + str.slice(1, -1).replace(/\\(\${|\r\n?|\n|.)|["'`]|\${|(\r\n?|\n)/g, function(match, escaped, newline) {
+    return newQuote + str.slice(1, -1).replace(/\\(\${|\r\n?|\n|.)|["'`]|\${|(\r\n?|\n)/g, (match, escaped, newline) => {
         if (escaped === oldQuote || oldQuote === "`" && escaped === "${") {
             return escaped; // unescape
         }

package/lib/rules/radix.js

@@ -145,7 +145,7 @@ module.exports = {
                 // Check `parseInt()`
                 variable = astUtils.getVariableByName(scope, "parseInt");
                 if (!isShadowed(variable)) {
-                    variable.references.forEach(function(reference) {
+                    variable.references.forEach(reference => {
                         const node = reference.identifier;
 
                         if (astUtils.isCallee(node)) {
@@ -157,7 +157,7 @@ module.exports = {
                 // Check `Number.parseInt()`
                 variable = astUtils.getVariableByName(scope, "Number");
                 if (!isShadowed(variable)) {
-                    variable.references.forEach(function(reference) {
+                    variable.references.forEach(reference => {
                         const node = reference.identifier.parent;
 
                         if (isParseIntMethod(node) && astUtils.isCallee(node)) {

package/lib/rules/require-jsdoc.js

@@ -27,6 +27,9 @@ module.exports = {
                             },
                             FunctionDeclaration: {
                                 type: "boolean"
+                            },
+                            ArrowFunctionExpression: {
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -98,6 +101,11 @@ module.exports = {
                 if (options.ClassDeclaration) {
                     checkJsDoc(node);
                 }
+            },
+            ArrowFunctionExpression(node) {
+                if (options.ArrowFunctionExpression && node.parent.type === "VariableDeclarator") {
+                    checkJsDoc(node);
+                }
             }
         };
     }

package/lib/rules/sort-vars.js

@@ -37,7 +37,7 @@ module.exports = {
 
         return {
             VariableDeclaration(node) {
-                node.declarations.reduce(function(memo, decl) {
+                node.declarations.reduce((memo, decl) => {
                     if (decl.id.type === "ObjectPattern" || decl.id.type === "ArrayPattern") {
                         return memo;
                     }

package/lib/rules/space-in-parens.js

@@ -220,7 +220,7 @@ module.exports = {
                 exceptions = getExceptions();
                 const tokens = sourceCode.tokensAndComments;
 
-                tokens.forEach(function(token, i) {
+                tokens.forEach((token, i) => {
                     const prevToken = tokens[i - 1];
                     const nextToken = tokens[i + 1];
 

package/lib/rules/space-infix-ops.js

@@ -57,7 +57,7 @@ module.exports = {
                 const op = tokens[i];
 
                 if (
-                    op.type === "Punctuator" &&
+                    (op.type === "Punctuator" || op.type === "Keyword") &&
                     OPERATORS.indexOf(op.value) >= 0 &&
                     (tokens[i - 1].range[1] >= op.range[0] || op.range[1] >= tokens[i + 1].range[0])
                 ) {

package/lib/rules/spaced-comment.js

@@ -240,7 +240,7 @@ module.exports = {
         const config = context.options[1] || {};
         const balanced = config.block && config.block.balanced;
 
-        const styleRules = ["block", "line"].reduce(function(rule, type) {
+        const styleRules = ["block", "line"].reduce((rule, type) => {
             const markers = parseMarkersOption(config[type] && config[type].markers || config.markers);
             const exceptions = config[type] && config[type].exceptions || config.exceptions || [];
             const endNeverPattern = "[ \t]+$";

package/lib/rules/symbol-description.js

@@ -51,7 +51,7 @@ module.exports = {
                 const variable = astUtils.getVariableByName(scope, "Symbol");
 
                 if (variable && variable.defs.length === 0) {
-                    variable.references.forEach(function(reference) {
+                    variable.references.forEach(reference => {
                         const node = reference.identifier;
 
                         if (astUtils.isCallee(node)) {

package/lib/rules/valid-jsdoc.js

@@ -202,7 +202,7 @@ module.exports = {
 
             elements.forEach(validateType.bind(null, jsdocNode));
 
-            typesToCheck.forEach(function(typeToCheck) {
+            typesToCheck.forEach(typeToCheck => {
                 if (typeToCheck.expectedType &&
                     typeToCheck.expectedType !== typeToCheck.currentType) {
                     context.report({
@@ -254,7 +254,7 @@ module.exports = {
                     return;
                 }
 
-                jsdoc.tags.forEach(function(tag) {
+                jsdoc.tags.forEach(tag => {
 
                     switch (tag.title.toLowerCase()) {
 
@@ -352,7 +352,7 @@ module.exports = {
                 const jsdocParams = Object.keys(params);
 
                 if (node.params) {
-                    node.params.forEach(function(param, i) {
+                    node.params.forEach((param, i) => {
                         if (param.type === "AssignmentPattern") {
                             param = param.left;
                         }

package/lib/rules.js

@@ -40,7 +40,7 @@ function define(ruleId, ruleModule) {
 function load(rulesDir, cwd) {
     const newRules = loadRules(rulesDir, cwd);
 
-    Object.keys(newRules).forEach(function(ruleId) {
+    Object.keys(newRules).forEach(ruleId => {
         define(ruleId, newRules[ruleId]);
     });
 }
@@ -53,7 +53,7 @@ function load(rulesDir, cwd) {
  */
 function importPlugin(plugin, pluginName) {
     if (plugin.rules) {
-        Object.keys(plugin.rules).forEach(function(ruleId) {
+        Object.keys(plugin.rules).forEach(ruleId => {
             const qualifiedRuleId = `${pluginName}/${ruleId}`,
                 rule = plugin.rules[ruleId];
 

package/lib/testers/event-generator-tester.js

@@ -44,19 +44,19 @@ module.exports = {
      * @returns {void}
      */
     testEventGeneratorInterface(instance) {
-        this.describe("should implement EventGenerator interface", function() {
-            this.it("should have `emitter` property.", function() {
+        this.describe("should implement EventGenerator interface", () => {
+            this.it("should have `emitter` property.", () => {
                 assert.equal(typeof instance.emitter, "object");
                 assert.equal(typeof instance.emitter.emit, "function");
             });
 
-            this.it("should have `enterNode` property.", function() {
+            this.it("should have `enterNode` property.", () => {
                 assert.equal(typeof instance.enterNode, "function");
             });
 
-            this.it("should have `leaveNode` property.", function() {
+            this.it("should have `leaveNode` property.", () => {
                 assert.equal(typeof instance.leaveNode, "function");
             });
-        }.bind(this));
+        });
     }
 };