eslint 3.13.1 → 3.16.0

package/lib/rules/no-whitespace-before-property.js

@@ -4,6 +4,10 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
@@ -29,21 +33,6 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        /**
-         * Finds opening bracket token of node's computed property
-         * @param {ASTNode} node - the node to check
-         * @returns {Token} opening bracket token of node's computed property
-         * @private
-         */
-        function findOpeningBracket(node) {
-            let token = sourceCode.getTokenBefore(node.property);
-
-            while (token.value !== "[") {
-                token = sourceCode.getTokenBefore(token);
-            }
-            return token;
-        }
-
         /**
          * Reports whitespace before property token
          * @param {ASTNode} node - the node to report in the event of an error
@@ -87,7 +76,7 @@ module.exports = {
                 }
 
                 if (node.computed) {
-                    rightToken = findOpeningBracket(node);
+                    rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken);
                     leftToken = sourceCode.getTokenBefore(rightToken);
                 } else {
                     rightToken = sourceCode.getFirstToken(node.property);

package/lib/rules/object-curly-newline.js

@@ -128,8 +128,8 @@ module.exports = {
             const options = normalizedOptions[node.type];
             const openBrace = sourceCode.getFirstToken(node);
             const closeBrace = sourceCode.getLastToken(node);
-            let first = sourceCode.getTokenOrCommentAfter(openBrace);
-            let last = sourceCode.getTokenOrCommentBefore(closeBrace);
+            let first = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+            let last = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
             const needsLinebreaks = (
                 node.properties.length >= options.minProperties ||
                 (

package/lib/rules/object-curly-spacing.js

@@ -206,14 +206,8 @@ module.exports = {
          */
         function getClosingBraceOfObject(node) {
             const lastProperty = node.properties[node.properties.length - 1];
-            let token = sourceCode.getTokenAfter(lastProperty);
 
-            // skip ')' and trailing commas.
-            while (token.type !== "Punctuator" || token.value !== "}") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
         }
 
         /**
@@ -254,15 +248,9 @@ module.exports = {
                 firstSpecifier = node.specifiers[1];
             }
 
-            const first = sourceCode.getTokenBefore(firstSpecifier);
-            let last = sourceCode.getTokenAfter(lastSpecifier);
-
-            // to support a trailing comma.
-            if (last.value === ",") {
-                last = sourceCode.getTokenAfter(last);
-            }
-
-            const second = sourceCode.getTokenAfter(first),
+            const first = sourceCode.getTokenBefore(firstSpecifier),
+                last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
+                second = sourceCode.getTokenAfter(first),
                 penultimate = sourceCode.getTokenBefore(last);
 
             validateBraceSpacing(node, first, second, penultimate, last);
@@ -280,15 +268,9 @@ module.exports = {
 
             const firstSpecifier = node.specifiers[0],
                 lastSpecifier = node.specifiers[node.specifiers.length - 1],
-                first = sourceCode.getTokenBefore(firstSpecifier);
-            let last = sourceCode.getTokenAfter(lastSpecifier);
-
-            // to support a trailing comma.
-            if (last.value === ",") {
-                last = sourceCode.getTokenAfter(last);
-            }
-
-            const second = sourceCode.getTokenAfter(first),
+                first = sourceCode.getTokenBefore(firstSpecifier),
+                last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
+                second = sourceCode.getTokenAfter(first),
                 penultimate = sourceCode.getTokenBefore(last);
 
             validateBraceSpacing(node, first, second, penultimate, last);

package/lib/rules/object-property-newline.js

@@ -34,9 +34,9 @@ module.exports = {
 
     create(context) {
         const allowSameLine = context.options[0] && Boolean(context.options[0].allowMultiplePropertiesPerLine);
-        const errorMessage = allowSameLine ?
-            "Object properties must go on a new line if they aren't all on the same line." :
-            "Object properties must go on a new line.";
+        const errorMessage = allowSameLine
+            ? "Object properties must go on a new line if they aren't all on the same line."
+            : "Object properties must go on a new line.";
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/object-shorthand.js

@@ -215,8 +215,8 @@ module.exports = {
         * @returns {Object} A fix for this node
         */
         function makeFunctionShorthand(fixer, node) {
-            const firstKeyToken = node.computed ? sourceCode.getTokens(node).find(token => token.value === "[") : sourceCode.getFirstToken(node.key);
-            const lastKeyToken = node.computed ? sourceCode.getTokensBetween(node.key, node.value).find(token => token.value === "]") : sourceCode.getLastToken(node.key);
+            const firstKeyToken = node.computed ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) : sourceCode.getFirstToken(node.key);
+            const lastKeyToken = node.computed ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken) : sourceCode.getLastToken(node.key);
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 
@@ -231,15 +231,15 @@ module.exports = {
                 const tokenBeforeParams = node.value.generator ? sourceCode.getTokenAfter(functionToken) : functionToken;
 
                 return fixer.replaceTextRange([firstKeyToken.range[0], tokenBeforeParams.range[1]], keyPrefix + keyText);
-            } else {
-                const arrowToken = sourceCode.getTokens(node.value).find(token => token.value === "=>");
-                const tokenBeforeArrow = sourceCode.getTokenBefore(arrowToken);
-                const hasParensAroundParameters = tokenBeforeArrow.type === "Punctuator" && tokenBeforeArrow.value === ")";
-                const oldParamText = sourceCode.text.slice(sourceCode.getFirstToken(node.value, node.value.async ? 1 : 0).range[0], tokenBeforeArrow.range[1]);
-                const newParamText = hasParensAroundParameters ? oldParamText : `(${oldParamText})`;
-
-                return fixer.replaceTextRange([firstKeyToken.range[0], arrowToken.range[1]], keyPrefix + keyText + newParamText);
             }
+            const arrowToken = sourceCode.getTokens(node.value).find(token => token.value === "=>");
+            const tokenBeforeArrow = sourceCode.getTokenBefore(arrowToken);
+            const hasParensAroundParameters = tokenBeforeArrow.type === "Punctuator" && tokenBeforeArrow.value === ")";
+            const oldParamText = sourceCode.text.slice(sourceCode.getFirstToken(node.value, node.value.async ? 1 : 0).range[0], tokenBeforeArrow.range[1]);
+            const newParamText = hasParensAroundParameters ? oldParamText : `(${oldParamText})`;
+
+            return fixer.replaceTextRange([firstKeyToken.range[0], arrowToken.range[1]], keyPrefix + keyText + newParamText);
+
         }
 
         /**

package/lib/rules/operator-assignment.js

@@ -27,7 +27,7 @@ function isCommutativeOperatorWithShorthand(operator) {
  *     a shorthand form.
  */
 function isNonCommutativeOperatorWithShorthand(operator) {
-    return ["+", "-", "/", "%", "<<", ">>", ">>>"].indexOf(operator) >= 0;
+    return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].indexOf(operator) >= 0;
 }
 
 //------------------------------------------------------------------------------
@@ -108,7 +108,7 @@ module.exports = {
         * @returns {Token} The operator token in the node
         */
         function getOperatorToken(node) {
-            return sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+            return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
         }
 
         /**

package/lib/rules/operator-linebreak.js

@@ -5,14 +5,16 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const LINEBREAK_REGEX = /\r\n|\r|\n|\u2028|\u2029/g;
-
 module.exports = {
     meta: {
         docs: {
@@ -85,7 +87,7 @@ module.exports = {
                 if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {
 
                     // If there is a comment before and after the operator, don't do a fix.
-                    if (sourceCode.getTokenOrCommentBefore(operatorToken) !== tokenBefore && sourceCode.getTokenOrCommentAfter(operatorToken) !== tokenAfter) {
+                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore && sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
                         return null;
                     }
 
@@ -100,6 +102,7 @@ module.exports = {
                     newTextBefore = textAfter;
                     newTextAfter = textBefore;
                 } else {
+                    const LINEBREAK_REGEX = astUtils.createGlobalLinebreakMatcher();
 
                     // Otherwise, if no linebreak is desired and no comments interfere, replace the linebreaks with empty strings.
                     newTextBefore = desiredStyle === "before" || textBefore.trim() ? textBefore : textBefore.replace(LINEBREAK_REGEX, "");
@@ -129,19 +132,14 @@ module.exports = {
          * @returns {void}
          */
         function validateNode(node, leftSide) {
-            let leftToken = sourceCode.getLastToken(leftSide);
-            let operatorToken = sourceCode.getTokenAfter(leftToken);
 
             // When the left part of a binary expression is a single expression wrapped in
             // parentheses (ex: `(a) + b`), leftToken will be the last token of the expression
             // and operatorToken will be the closing parenthesis.
             // The leftToken should be the last closing parenthesis, and the operatorToken
             // should be the token right after that.
-            while (operatorToken.value === ")") {
-                leftToken = operatorToken;
-                operatorToken = sourceCode.getTokenAfter(operatorToken);
-            }
-
+            const operatorToken = sourceCode.getTokenAfter(leftSide, astUtils.isNotClosingParenToken);
+            const leftToken = sourceCode.getTokenBefore(operatorToken);
             const rightToken = sourceCode.getTokenAfter(operatorToken);
             const operator = operatorToken.value;
             const operatorStyleOverride = styleOverrides[operator];

package/lib/rules/padded-blocks.js

@@ -101,7 +101,7 @@ module.exports = {
             let first = token;
 
             do {
-                first = sourceCode.getTokenOrCommentAfter(first);
+                first = sourceCode.getTokenAfter(first, { includeComments: true });
             } while (isComment(first) && first.loc.start.line === tokenStartLine);
 
             const firstLine = first.loc.start.line;
@@ -120,7 +120,7 @@ module.exports = {
             let last = token;
 
             do {
-                last = sourceCode.getTokenOrCommentBefore(last);
+                last = sourceCode.getTokenBefore(last, { includeComments: true });
             } while (isComment(last) && last.loc.end.line === blockEnd);
 
             const lastLine = last.loc.end.line;
@@ -182,7 +182,7 @@ module.exports = {
                 }
             } else {
                 if (blockHasTopPadding) {
-                    const nextToken = sourceCode.getTokenOrCommentAfter(openBrace);
+                    const nextToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });
 
                     context.report({
                         node,
@@ -195,7 +195,7 @@ module.exports = {
                 }
 
                 if (blockHasBottomPadding) {
-                    const previousToken = sourceCode.getTokenOrCommentBefore(closeBrace);
+                    const previousToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
 
                     context.report({
                         node,

package/lib/rules/prefer-promise-reject-errors.js

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview restrict values that can be used as Promise rejection reasons
+ * @author Teddy Katz
+ */
+"use strict";
+
+const astUtils = require("../ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "require using Error objects as Promise rejection reasons",
+            category: "Best Practices",
+            recommended: false
+        },
+        fixable: null,
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowEmptyReject: { type: "boolean" }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+
+        const ALLOW_EMPTY_REJECT = context.options.length && context.options[0].allowEmptyReject;
+
+        //----------------------------------------------------------------------
+        // Helpers
+        //----------------------------------------------------------------------
+
+        /**
+        * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
+        * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
+        * @returns {void}
+        */
+        function checkRejectCall(callExpression) {
+            if (!callExpression.arguments.length && ALLOW_EMPTY_REJECT) {
+                return;
+            }
+            if (
+                !callExpression.arguments.length ||
+                !astUtils.couldBeError(callExpression.arguments[0]) ||
+                callExpression.arguments[0].type === "Identifier" && callExpression.arguments[0].name === "undefined"
+            ) {
+                context.report({
+                    node: callExpression,
+                    message: "Expected the Promise rejection reason to be an Error."
+                });
+            }
+        }
+
+        /**
+        * Determines whether a function call is a Promise.reject() call
+        * @param {ASTNode} node A CallExpression node
+        * @returns {boolean} `true` if the call is a Promise.reject() call
+        */
+        function isPromiseRejectCall(node) {
+            return node.callee.type === "MemberExpression" &&
+                node.callee.object.type === "Identifier" && node.callee.object.name === "Promise" &&
+                node.callee.property.type === "Identifier" && node.callee.property.name === "reject";
+        }
+
+        //----------------------------------------------------------------------
+        // Public
+        //----------------------------------------------------------------------
+
+        return {
+
+            // Check `Promise.reject(value)` calls.
+            CallExpression(node) {
+                if (isPromiseRejectCall(node)) {
+                    checkRejectCall(node);
+                }
+            },
+
+            /*
+             * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
+             * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
+             * the nodes in the expression already have the `parent` property.
+             */
+            "NewExpression:exit"(node) {
+                if (
+                    node.callee.type === "Identifier" && node.callee.name === "Promise" &&
+                    node.arguments.length && astUtils.isFunction(node.arguments[0]) &&
+                    node.arguments[0].params.length > 1 && node.arguments[0].params[1].type === "Identifier"
+                ) {
+                    context.getDeclaredVariables(node.arguments[0])
+
+                        /*
+                        * Find the first variable that matches the second parameter's name.
+                        * If the first parameter has the same name as the second parameter, then the variable will actually
+                        * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
+                        * by the second parameter. It's not possible for an expression with the variable to be evaluated before
+                        * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
+                        * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
+                        * this case.
+                        */
+                        .find(variable => variable.name === node.arguments[0].params[1].name)
+
+                        // Get the references to that variable.
+                        .references
+
+                        // Only check the references that read the parameter's value.
+                        .filter(ref => ref.isRead())
+
+                        // Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
+                        .filter(ref => ref.identifier.parent.type === "CallExpression" && ref.identifier === ref.identifier.parent.callee)
+
+                        // Check the argument of the function call to determine whether it's an Error.
+                        .forEach(ref => checkRejectCall(ref.identifier.parent));
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-spread.js

@@ -108,7 +108,7 @@ module.exports = {
                                 return null;
                             }
 
-                            const propertyDot = sourceCode.getTokensBetween(applied, node.callee.property).find(token => token.value === ".");
+                            const propertyDot = sourceCode.getFirstTokenBetween(applied, node.callee.property, token => token.value === ".");
 
                             return fixer.replaceTextRange([propertyDot.range[0], node.range[1]], `(...${sourceCode.getText(node.arguments[1])})`);
                         }

package/lib/rules/prefer-template.js

@@ -157,7 +157,7 @@ module.exports = {
             }
 
             if (isConcatenation(currentNode) && hasStringLiteral(currentNode) && hasNonStringLiteral(currentNode)) {
-                const plusSign = sourceCode.getTokensBetween(currentNode.left, currentNode.right).find(token => token.value === "+");
+                const plusSign = sourceCode.getFirstTokenBetween(currentNode.left, currentNode.right, token => token.value === "+");
                 const textBeforePlus = getTextBetween(currentNode.left, plusSign);
                 const textAfterPlus = getTextBetween(plusSign, currentNode.right);
                 const leftEndsWithCurly = endsWithTemplateCurly(currentNode.left);

package/lib/rules/quotes.js

@@ -33,6 +33,9 @@ const QUOTE_SETTINGS = {
     }
 };
 
+// An unescaped newline is a newline preceded by an even number of backslashes.
+const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`);
+
 /**
  * Switches quoting of javascript string between ' " and `
  * escaping and unescaping as necessary.
@@ -254,22 +257,23 @@ module.exports = {
             TemplateLiteral(node) {
 
                 // If backticks are expected or it's a tagged template, then this shouldn't throw an errors
-                if (allowTemplateLiterals || quoteOption === "backtick" || node.parent.type === "TaggedTemplateExpression") {
+                if (
+                    allowTemplateLiterals ||
+                    quoteOption === "backtick" ||
+                    node.parent.type === "TaggedTemplateExpression" && node === node.parent.quasi
+                ) {
                     return;
                 }
 
-                /*
-                 * A warning should be produced if the template literal only has one TemplateElement, and has no unescaped newlines.
-                 * An unescaped newline is a newline preceded by an even number of backslashes.
-                 */
-                const shouldWarn = node.quasis.length === 1 && !/(^|[^\\])(\\\\)*[\r\n\u2028\u2029]/.test(node.quasis[0].value.raw);
+                // A warning should be produced if the template literal only has one TemplateElement, and has no unescaped newlines.
+                const shouldWarn = node.quasis.length === 1 && !UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw);
 
                 if (shouldWarn) {
                     context.report({
                         node,
                         message: "Strings must use {{description}}.",
                         data: {
-                            description: settings.description,
+                            description: settings.description
                         },
                         fix(fixer) {
                             if (isPartOfDirectivePrologue(node)) {

package/lib/rules/require-await.js

@@ -51,7 +51,7 @@ module.exports = {
         function enterFunction() {
             scopeInfo = {
                 upper: scopeInfo,
-                hasAwait: false,
+                hasAwait: false
             };
         }
 

package/lib/rules/semi-spacing.js

@@ -206,6 +206,10 @@ module.exports = {
             DebuggerStatement: checkNode,
             ReturnStatement: checkNode,
             ThrowStatement: checkNode,
+            ImportDeclaration: checkNode,
+            ExportNamedDeclaration: checkNode,
+            ExportAllDeclaration: checkNode,
+            ExportDefaultDeclaration: checkNode,
             ForStatement(node) {
                 if (node.init) {
                     checkSemicolonSpacing(sourceCode.getTokenAfter(node.init), node);

package/lib/rules/sort-imports.js

@@ -71,9 +71,9 @@ module.exports = {
                 return "all";
             } else if (node.specifiers.length === 1) {
                 return "single";
-            } else {
-                return "multiple";
             }
+            return "multiple";
+
         }
 
         /**
@@ -93,9 +93,9 @@ module.exports = {
         function getFirstLocalMemberName(node) {
             if (node.specifiers[0]) {
                 return node.specifiers[0].local.name;
-            } else {
-                return null;
             }
+            return null;
+
         }
 
         return {

package/lib/rules/sort-keys.js

@@ -64,7 +64,7 @@ const isValidOrders = {
     },
     descIN(a, b) {
         return isValidOrders.ascIN(b, a);
-    },
+    }
 };
 
 //------------------------------------------------------------------------------
@@ -147,7 +147,7 @@ module.exports = {
                             prevName,
                             order,
                             insensitive: insensitive ? "insensitive " : "",
-                            natual: natual ? "natural " : "",
+                            natual: natual ? "natural " : ""
                         }
                     });
                 }

package/lib/rules/sort-vars.js

@@ -53,9 +53,9 @@ module.exports = {
                     if (currenVariableName < lastVariableName) {
                         context.report({ node: decl, message: "Variables within the same declaration block should be sorted alphabetically." });
                         return memo;
-                    } else {
-                        return decl;
                     }
+                    return decl;
+
                 }, node.declarations[0]);
             }
         };

package/lib/rules/space-before-function-paren.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -104,7 +110,7 @@ module.exports = {
             const isAnonymousGenerator = node.generator && !isNamed;
             const isNormalArrow = isArrow && !node.async;
             const isArrowWithoutParens = isArrow && sourceCode.getFirstToken(node, 1).value !== "(";
-            let forbidSpacing, requireSpacing, rightToken;
+            let forbidSpacing, requireSpacing;
 
             // isAnonymousGenerator → `generator-star-spacing` should warn it. E.g. `function* () {}`
             // isNormalArrow → ignore always.
@@ -124,10 +130,7 @@ module.exports = {
                 requireSpacing = requireAnonymousFunctionSpacing;
             }
 
-            rightToken = sourceCode.getFirstToken(node);
-            while (rightToken.value !== "(") {
-                rightToken = sourceCode.getTokenAfter(rightToken);
-            }
+            const rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
             const leftToken = sourceCode.getTokenBefore(rightToken);
             const location = leftToken.loc.end;
 
@@ -159,7 +162,7 @@ module.exports = {
         return {
             FunctionDeclaration: validateSpacingBeforeParentheses,
             FunctionExpression: validateSpacingBeforeParentheses,
-            ArrowFunctionExpression: validateSpacingBeforeParentheses,
+            ArrowFunctionExpression: validateSpacingBeforeParentheses
         };
     }
 };

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

@@ -132,9 +132,9 @@ module.exports = {
                     return false;
                 }
                 return !isOpenerException(right);
-            } else {
-                return isOpenerException(right);
             }
+            return isOpenerException(right);
+
         }
 
         /**
@@ -154,9 +154,9 @@ module.exports = {
 
             if (ALWAYS) {
                 return !isCloserException(left);
-            } else {
-                return isCloserException(left);
             }
+            return isCloserException(left);
+
         }
 
         /**
@@ -180,9 +180,9 @@ module.exports = {
 
             if (ALWAYS) {
                 return isOpenerException(right);
-            } else {
-                return !isOpenerException(right);
             }
+            return !isOpenerException(right);
+
         }
 
         /**
@@ -206,9 +206,9 @@ module.exports = {
 
             if (ALWAYS) {
                 return isCloserException(left);
-            } else {
-                return !isCloserException(left);
             }
+            return !isCloserException(left);
+
         }
 
         //--------------------------------------------------------------------------