eslint 3.16.1 → 3.19.0

package/lib/rules/padded-blocks.js

@@ -90,23 +90,32 @@ module.exports = {
             return node.type === "Line" || node.type === "Block";
         }
 
+        /**
+         * Checks if there is padding between two tokens
+         * @param {Token} first The first token
+         * @param {Token} second The second token
+         * @returns {boolean} True if there is at least a line between the tokens
+         */
+        function isPaddingBetweenTokens(first, second) {
+            return second.loc.start.line - first.loc.end.line >= 2;
+        }
+
+
         /**
          * Checks if the given token has a blank line after it.
          * @param {Token} token The token to check.
          * @returns {boolean} Whether or not the token is followed by a blank line.
          */
-        function isTokenTopPadded(token) {
-            const tokenStartLine = token.loc.start.line,
-                expectedFirstLine = tokenStartLine + 2;
-            let first = token;
+        function getFirstBlockToken(token) {
+            let prev = token,
+                first = token;
 
             do {
+                prev = first;
                 first = sourceCode.getTokenAfter(first, { includeComments: true });
-            } while (isComment(first) && first.loc.start.line === tokenStartLine);
-
-            const firstLine = first.loc.start.line;
+            } while (isComment(first) && first.loc.start.line === prev.loc.end.line);
 
-            return expectedFirstLine <= firstLine;
+            return first;
         }
 
         /**
@@ -114,18 +123,16 @@ module.exports = {
          * @param {Token} token The token to check
          * @returns {boolean} Whether or not the token is preceeded by a blank line
          */
-        function isTokenBottomPadded(token) {
-            const blockEnd = token.loc.end.line,
-                expectedLastLine = blockEnd - 2;
-            let last = token;
+        function getLastBlockToken(token) {
+            let last = token,
+                next = token;
 
             do {
+                next = last;
                 last = sourceCode.getTokenBefore(last, { includeComments: true });
-            } while (isComment(last) && last.loc.end.line === blockEnd);
+            } while (isComment(last) && last.loc.end.line === next.loc.start.line);
 
-            const lastLine = last.loc.end.line;
-
-            return lastLine <= expectedLastLine;
+            return last;
         }
 
         /**
@@ -155,17 +162,21 @@ module.exports = {
          */
         function checkPadding(node) {
             const openBrace = getOpenBrace(node),
+                firstBlockToken = getFirstBlockToken(openBrace),
+                tokenBeforeFirst = sourceCode.getTokenBefore(firstBlockToken, { includeComments: true }),
                 closeBrace = sourceCode.getLastToken(node),
-                blockHasTopPadding = isTokenTopPadded(openBrace),
-                blockHasBottomPadding = isTokenBottomPadded(closeBrace);
+                lastBlockToken = getLastBlockToken(closeBrace),
+                tokenAfterLast = sourceCode.getTokenAfter(lastBlockToken, { includeComments: true }),
+                blockHasTopPadding = isPaddingBetweenTokens(tokenBeforeFirst, firstBlockToken),
+                blockHasBottomPadding = isPaddingBetweenTokens(lastBlockToken, tokenAfterLast);
 
             if (requirePaddingFor(node)) {
                 if (!blockHasTopPadding) {
                     context.report({
                         node,
-                        loc: { line: openBrace.loc.start.line, column: openBrace.loc.start.column },
+                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },
                         fix(fixer) {
-                            return fixer.insertTextAfter(openBrace, "\n");
+                            return fixer.insertTextAfter(tokenBeforeFirst, "\n");
                         },
                         message: ALWAYS_MESSAGE
                     });
@@ -173,39 +184,34 @@ module.exports = {
                 if (!blockHasBottomPadding) {
                     context.report({
                         node,
-                        loc: { line: closeBrace.loc.end.line, column: closeBrace.loc.end.column - 1 },
+                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },
                         fix(fixer) {
-                            return fixer.insertTextBefore(closeBrace, "\n");
+                            return fixer.insertTextBefore(tokenAfterLast, "\n");
                         },
                         message: ALWAYS_MESSAGE
                     });
                 }
             } else {
                 if (blockHasTopPadding) {
-                    const nextToken = sourceCode.getTokenAfter(openBrace, { includeComments: true });
 
                     context.report({
                         node,
-                        loc: { line: openBrace.loc.start.line, column: openBrace.loc.start.column },
+                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },
                         fix(fixer) {
-
-                            // FIXME: The start of this range is sometimes larger than the end.
-                            // https://github.com/eslint/eslint/issues/8116
-                            return fixer.replaceTextRange([openBrace.end, nextToken.start - nextToken.loc.start.column], "\n");
+                            return fixer.replaceTextRange([tokenBeforeFirst.end, firstBlockToken.start - firstBlockToken.loc.start.column], "\n");
                         },
                         message: NEVER_MESSAGE
                     });
                 }
 
                 if (blockHasBottomPadding) {
-                    const previousToken = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
 
                     context.report({
                         node,
-                        loc: { line: closeBrace.loc.end.line, column: closeBrace.loc.end.column - 1 },
+                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },
                         message: NEVER_MESSAGE,
                         fix(fixer) {
-                            return fixer.replaceTextRange([previousToken.end, closeBrace.start - closeBrace.loc.start.column], "\n");
+                            return fixer.replaceTextRange([lastBlockToken.end, tokenAfterLast.start - tokenAfterLast.loc.start.column], "\n");
                         }
                     });
                 }

package/lib/rules/prefer-const.js

@@ -9,7 +9,7 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|Property)$/;
+const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/;
 const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/;
 const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/;
 

package/lib/rules/prefer-destructuring.js

@@ -89,7 +89,7 @@ module.exports = {
          * @returns {void}
          */
         function report(reportNode, type) {
-            context.report({ node: reportNode, message: `Use ${type} destructuring` });
+            context.report({ node: reportNode, message: "Use {{type}} destructuring.", data: { type } });
         }
 
         /**

package/lib/rules/quotes.js

@@ -209,6 +209,7 @@ module.exports = {
 
                 // LiteralPropertyName.
                 case "Property":
+                case "MethodDefinition":
                     return parent.key === node && !parent.computed;
 
                 // ModuleSpecifier.

package/lib/rules/semi-spacing.js

@@ -105,20 +105,7 @@ module.exports = {
         function isBeforeClosingParen(token) {
             const nextToken = sourceCode.getTokenAfter(token);
 
-            return (
-                nextToken &&
-                nextToken.type === "Punctuator" &&
-                (nextToken.value === "}" || nextToken.value === ")")
-            );
-        }
-
-        /**
-         * Checks if the given token is a semicolon.
-         * @param {Token} token The token to check.
-         * @returns {boolean} Whether or not the given token is a semicolon.
-         */
-        function isSemicolon(token) {
-            return token.type === "Punctuator" && token.value === ";";
+            return (nextToken && astUtils.isClosingBraceToken(nextToken) || astUtils.isClosingParenToken(nextToken));
         }
 
         /**
@@ -128,7 +115,7 @@ module.exports = {
          * @returns {void}
          */
         function checkSemicolonSpacing(token, node) {
-            if (isSemicolon(token)) {
+            if (astUtils.isSemicolonToken(token)) {
                 const location = token.loc.start;
 
                 if (hasLeadingSpace(token)) {

package/lib/rules/semi.js

@@ -4,6 +4,13 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const FixTracker = require("../util/fix-tracker");
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -85,7 +92,13 @@ module.exports = {
                 message = "Extra semicolon.";
                 loc = loc.start;
                 fix = function(fixer) {
-                    return fixer.remove(lastToken);
+
+                    // Expand the replacement range to include the surrounding
+                    // tokens to avoid conflicting with no-extra-semi.
+                    // https://github.com/eslint/eslint/issues/7928
+                    return new FixTracker(fixer, sourceCode)
+                        .retainSurroundingTokens(lastToken)
+                        .remove(lastToken);
                 };
             }
 
@@ -98,15 +111,6 @@ module.exports = {
 
         }
 
-        /**
-         * Checks whether a token is a semicolon punctuator.
-         * @param {Token} token The token.
-         * @returns {boolean} True if token is a semicolon punctuator.
-         */
-        function isSemicolon(token) {
-            return (token.type === "Punctuator" && token.value === ";");
-        }
-
         /**
          * Check if a semicolon is unnecessary, only true if:
          *   - next token is on a new line and is not one of the opt-out tokens
@@ -115,7 +119,7 @@ module.exports = {
          * @returns {boolean} whether the semicolon is unnecessary.
          */
         function isUnnecessarySemicolon(lastToken) {
-            if (!isSemicolon(lastToken)) {
+            if (!astUtils.isSemicolonToken(lastToken)) {
                 return false;
             }
 
@@ -128,7 +132,7 @@ module.exports = {
             const lastTokenLine = lastToken.loc.end.line;
             const nextTokenLine = nextToken.loc.start.line;
             const isOptOutToken = OPT_OUT_PATTERN.test(nextToken.value) && nextToken.value !== "++" && nextToken.value !== "--";
-            const isDivider = (nextToken.value === "}" || nextToken.value === ";");
+            const isDivider = (astUtils.isClosingBraceToken(nextToken) || astUtils.isSemicolonToken(nextToken));
 
             return (lastTokenLine !== nextTokenLine && !isOptOutToken) || isDivider;
         }
@@ -164,7 +168,7 @@ module.exports = {
                     report(node, true);
                 }
             } else {
-                if (!isSemicolon(lastToken)) {
+                if (!astUtils.isSemicolonToken(lastToken)) {
                     if (!exceptOneLine || !isOneLinerBlock(node)) {
                         report(node);
                     }

package/lib/rules/sort-vars.js

@@ -37,11 +37,9 @@ module.exports = {
 
         return {
             VariableDeclaration(node) {
-                node.declarations.reduce((memo, decl) => {
-                    if (decl.id.type === "ObjectPattern" || decl.id.type === "ArrayPattern") {
-                        return memo;
-                    }
+                const idDeclarations = node.declarations.filter(decl => decl.id.type === "Identifier");
 
+                idDeclarations.slice(1).reduce((memo, decl) => {
                     let lastVariableName = memo.id.name,
                         currenVariableName = decl.id.name;
 
@@ -56,7 +54,7 @@ module.exports = {
                     }
                     return decl;
 
-                }, node.declarations[0]);
+                }, idDeclarations[0]);
             }
         };
     }

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

@@ -51,31 +51,9 @@ module.exports = {
     },
 
     create(context) {
-
-        const configuration = context.options[0],
-            sourceCode = context.getSourceCode();
-        let requireAnonymousFunctionSpacing = true,
-            forbidAnonymousFunctionSpacing = false,
-            requireNamedFunctionSpacing = true,
-            forbidNamedFunctionSpacing = false,
-            requireArrowFunctionSpacing = false,
-            forbidArrowFunctionSpacing = false;
-
-        if (typeof configuration === "object") {
-            requireAnonymousFunctionSpacing = (
-                !configuration.anonymous || configuration.anonymous === "always");
-            forbidAnonymousFunctionSpacing = configuration.anonymous === "never";
-            requireNamedFunctionSpacing = (
-                !configuration.named || configuration.named === "always");
-            forbidNamedFunctionSpacing = configuration.named === "never";
-            requireArrowFunctionSpacing = configuration.asyncArrow === "always";
-            forbidArrowFunctionSpacing = configuration.asyncArrow === "never";
-        } else if (configuration === "never") {
-            requireAnonymousFunctionSpacing = false;
-            forbidAnonymousFunctionSpacing = true;
-            requireNamedFunctionSpacing = false;
-            forbidNamedFunctionSpacing = true;
-        }
+        const sourceCode = context.getSourceCode();
+        const baseConfig = typeof context.options[0] === "string" ? context.options[0] : "always";
+        const overrideConfig = typeof context.options[0] === "object" ? context.options[0] : {};
 
         /**
          * Determines whether a function has a name.
@@ -100,69 +78,67 @@ module.exports = {
         }
 
         /**
-         * Validates the spacing before function parentheses.
-         * @param {ASTNode} node The node to be validated.
-         * @returns {void}
+         * Gets the config for a given function
+         * @param {ASTNode} node The function node
+         * @returns {string} "always", "never", or "ignore"
          */
-        function validateSpacingBeforeParentheses(node) {
-            const isArrow = node.type === "ArrowFunctionExpression";
-            const isNamed = !isArrow && isNamedFunction(node);
-            const isAnonymousGenerator = node.generator && !isNamed;
-            const isNormalArrow = isArrow && !node.async;
-            const isArrowWithoutParens = isArrow && sourceCode.getFirstToken(node, 1).value !== "(";
-            let forbidSpacing, requireSpacing;
-
-            // isAnonymousGenerator → `generator-star-spacing` should warn it. E.g. `function* () {}`
-            // isNormalArrow → ignore always.
-            // isArrowWithoutParens → ignore always. E.g. `async a => a`
-            if (isAnonymousGenerator || isNormalArrow || isArrowWithoutParens) {
-                return;
+        function getConfigForFunction(node) {
+            if (node.type === "ArrowFunctionExpression") {
+
+                // Always ignore non-async functions and arrow functions without parens, e.g. async foo => bar
+                if (node.async && astUtils.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {
+
+                    // For backwards compatibility, the base config does not apply to async arrow functions.
+                    return overrideConfig.asyncArrow || "ignore";
+                }
+            } else if (isNamedFunction(node)) {
+                return overrideConfig.named || baseConfig;
+
+            // `generator-star-spacing` should warn anonymous generators. E.g. `function* () {}`
+            } else if (!node.generator) {
+                return overrideConfig.anonymous || baseConfig;
             }
 
-            if (isArrow) {
-                forbidSpacing = forbidArrowFunctionSpacing;
-                requireSpacing = requireArrowFunctionSpacing;
-            } else if (isNamed) {
-                forbidSpacing = forbidNamedFunctionSpacing;
-                requireSpacing = requireNamedFunctionSpacing;
-            } else {
-                forbidSpacing = forbidAnonymousFunctionSpacing;
-                requireSpacing = requireAnonymousFunctionSpacing;
+            return "ignore";
+        }
+
+        /**
+         * Checks the parens of a function node
+         * @param {ASTNode} node A function node
+         * @returns {void}
+         */
+        function checkFunction(node) {
+            const functionConfig = getConfigForFunction(node);
+
+            if (functionConfig === "ignore") {
+                return;
             }
 
             const rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
             const leftToken = sourceCode.getTokenBefore(rightToken);
-            const location = leftToken.loc.end;
-
-            if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken)) {
-                if (forbidSpacing) {
-                    context.report({
-                        node,
-                        loc: location,
-                        message: "Unexpected space before function parentheses.",
-                        fix(fixer) {
-                            return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
-                        }
-                    });
-                }
-            } else {
-                if (requireSpacing) {
-                    context.report({
-                        node,
-                        loc: location,
-                        message: "Missing space before function parentheses.",
-                        fix(fixer) {
-                            return fixer.insertTextAfter(leftToken, " ");
-                        }
-                    });
-                }
+            const hasSpacing = sourceCode.isSpaceBetweenTokens(leftToken, rightToken);
+
+            if (hasSpacing && functionConfig === "never") {
+                context.report({
+                    node,
+                    loc: leftToken.loc.end,
+                    message: "Unexpected space before function parentheses.",
+                    fix: fixer => fixer.removeRange([leftToken.range[1], rightToken.range[0]])
+                });
+            } else if (!hasSpacing && functionConfig === "always") {
+                context.report({
+                    node,
+                    loc: leftToken.loc.end,
+                    message: "Missing space before function parentheses.",
+                    fix: fixer => fixer.insertTextAfter(leftToken, " ")
+                });
             }
         }
 
         return {
-            FunctionDeclaration: validateSpacingBeforeParentheses,
-            FunctionExpression: validateSpacingBeforeParentheses,
-            ArrowFunctionExpression: validateSpacingBeforeParentheses
+            ArrowFunctionExpression: checkFunction,
+            FunctionDeclaration: checkFunction,
+            FunctionExpression: checkFunction
         };
     }
 };

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

@@ -128,7 +128,7 @@ module.exports = {
             }
 
             if (ALWAYS) {
-                if (right.type === "Punctuator" && right.value === ")") {
+                if (astUtils.isClosingParenToken(right)) {
                     return false;
                 }
                 return !isOpenerException(right);
@@ -144,7 +144,7 @@ module.exports = {
          * @returns {boolean} True if the paren should have a space
          */
         function shouldCloserHaveSpace(left, right) {
-            if (left.type === "Punctuator" && left.value === "(") {
+            if (astUtils.isOpeningParenToken(left)) {
                 return false;
             }
 
@@ -192,7 +192,7 @@ module.exports = {
          * @returns {boolean} True if the paren should reject the space
          */
         function shouldCloserRejectSpace(left, right) {
-            if (left.type === "Punctuator" && left.value === "(") {
+            if (astUtils.isOpeningParenToken(left)) {
                 return false;
             }
 
@@ -224,11 +224,7 @@ module.exports = {
                     const prevToken = tokens[i - 1];
                     const nextToken = tokens[i + 1];
 
-                    if (token.type !== "Punctuator") {
-                        return;
-                    }
-
-                    if (token.value !== "(" && token.value !== ")") {
+                    if (!astUtils.isOpeningParenToken(token) && !astUtils.isClosingParenToken(token)) {
                         return;
                     }
 

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

@@ -68,6 +68,21 @@ module.exports = {
             return node.argument && node.argument.type && node.argument.type === "ObjectExpression";
         }
 
+        /**
+         * Check if it is safe to remove the spaces between the two tokens in
+         * the context of a non-word prefix unary operator. For example, `+ +1`
+         * cannot safely be changed to `++1`.
+         * @param {Token} firstToken The operator for a non-word prefix unary operator
+         * @param {Token} secondToken The first token of its operand
+         * @returns {boolean} Whether or not the spacing between the tokens can be removed
+         */
+        function canRemoveSpacesBetween(firstToken, secondToken) {
+            return !(
+                (firstToken.value === "+" && secondToken.value[0] === "+") ||
+                (firstToken.value === "-" && secondToken.value[0] === "-")
+            );
+        }
+
         /**
         * Checks if an override exists for a given operator.
         * @param {ASTnode} node AST node
@@ -244,7 +259,10 @@ module.exports = {
                             operator: firstToken.value
                         },
                         fix(fixer) {
-                            return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
+                            if (canRemoveSpacesBetween(firstToken, secondToken)) {
+                                return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);
+                            }
+                            return null;
                         }
                     });
                 }

package/lib/rules/strict.js

@@ -9,6 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -23,7 +25,7 @@ const messages = {
     implied: "'use strict' is unnecessary when implied strict mode is enabled.",
     unnecessaryInClasses: "'use strict' is unnecessary inside of classes.",
     nonSimpleParameterList: "'use strict' directive inside a function with non-simple parameter list throws a syntax error since ES2016.",
-    wrap: "Wrap this function in a function with 'use strict' directive."
+    wrap: "Wrap {{name}} in a function with 'use strict' directive."
 };
 
 /**
@@ -188,7 +190,11 @@ module.exports = {
                 if (isSimpleParameterList(node.params)) {
                     context.report({ node, message: messages.function });
                 } else {
-                    context.report({ node, message: messages.wrap });
+                    context.report({
+                        node,
+                        message: messages.wrap,
+                        data: { name: astUtils.getFunctionNameWithKind(node) }
+                    });
                 }
             }
 

package/lib/rules/yoda.js

@@ -267,8 +267,8 @@ module.exports = {
             const operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
             const textBeforeOperator = sourceCode.getText().slice(sourceCode.getTokenBefore(operatorToken).range[1], operatorToken.range[0]);
             const textAfterOperator = sourceCode.getText().slice(operatorToken.range[1], sourceCode.getTokenAfter(operatorToken).range[0]);
-            const leftText = sourceCode.getText().slice(sourceCode.getFirstToken(node).range[0], sourceCode.getTokenBefore(operatorToken).range[1]);
-            const rightText = sourceCode.getText().slice(sourceCode.getTokenAfter(operatorToken).range[0], sourceCode.getLastToken(node).range[1]);
+            const leftText = sourceCode.getText().slice(node.range[0], sourceCode.getTokenBefore(operatorToken).range[1]);
+            const rightText = sourceCode.getText().slice(sourceCode.getTokenAfter(operatorToken).range[0], node.range[1]);
 
             return rightText + textBeforeOperator + OPERATOR_FLIP_MAP[operatorToken.value] + textAfterOperator + leftText;
         }