eslint 7.0.0-alpha.2 → 7.1.0

package/lib/rules/padded-blocks.js

@@ -203,10 +203,14 @@ module.exports = {
             }
 
             if (requirePaddingFor(node)) {
+
                 if (!blockHasTopPadding) {
                     context.report({
                         node,
-                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },
+                        loc: {
+                            start: tokenBeforeFirst.loc.start,
+                            end: firstBlockToken.loc.start
+                        },
                         fix(fixer) {
                             return fixer.insertTextAfter(tokenBeforeFirst, "\n");
                         },
@@ -216,7 +220,10 @@ module.exports = {
                 if (!blockHasBottomPadding) {
                     context.report({
                         node,
-                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },
+                        loc: {
+                            end: tokenAfterLast.loc.start,
+                            start: lastBlockToken.loc.end
+                        },
                         fix(fixer) {
                             return fixer.insertTextBefore(tokenAfterLast, "\n");
                         },
@@ -228,7 +235,10 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },
+                        loc: {
+                            start: tokenBeforeFirst.loc.start,
+                            end: firstBlockToken.loc.start
+                        },
                         fix(fixer) {
                             return fixer.replaceTextRange([tokenBeforeFirst.range[1], firstBlockToken.range[0] - firstBlockToken.loc.start.column], "\n");
                         },
@@ -240,7 +250,10 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },
+                        loc: {
+                            end: tokenAfterLast.loc.start,
+                            start: lastBlockToken.loc.end
+                        },
                         messageId: "neverPadBlock",
                         fix(fixer) {
                             return fixer.replaceTextRange([lastBlockToken.range[1], tokenAfterLast.range[0] - tokenAfterLast.loc.start.column], "\n");

package/lib/rules/prefer-numeric-literals.js

@@ -79,13 +79,13 @@ module.exports = {
 
             "CallExpression[arguments.length=2]"(node) {
                 const [strNode, radixNode] = node.arguments,
-                    str = strNode.value,
+                    str = astUtils.getStaticStringValue(strNode),
                     radix = radixNode.value;
 
                 if (
-                    strNode.type === "Literal" &&
+                    str !== null &&
+                    astUtils.isStringLiteral(strNode) &&
                     radixNode.type === "Literal" &&
-                    typeof str === "string" &&
                     typeof radix === "number" &&
                     radixMap.has(radix) &&
                     isParseInt(node.callee)

package/lib/rules/prefer-object-spread.js

@@ -181,8 +181,8 @@ function defineFixer(node, sourceCode) {
         const leftParen = sourceCode.getTokenAfter(node.callee, isOpeningParenToken);
         const rightParen = sourceCode.getLastToken(node);
 
-        // Remove the callee `Object.assign`
-        yield fixer.remove(node.callee);
+        // Remove everything before the opening paren: callee `Object.assign`, type arguments, and whitespace between the callee and the paren.
+        yield fixer.removeRange([node.range[0], leftParen.range[0]]);
 
         // Replace the parens of argument list to braces.
         if (needsParens(node, sourceCode)) {

package/lib/rules/require-await.js

@@ -68,7 +68,7 @@ module.exports = {
          * @returns {void}
          */
         function exitFunction(node) {
-            if (node.async && !scopeInfo.hasAwait && !astUtils.isEmptyFunction(node)) {
+            if (!node.generator && node.async && !scopeInfo.hasAwait && !astUtils.isEmptyFunction(node)) {
                 context.report({
                     node,
                     loc: astUtils.getFunctionHeadLoc(node, sourceCode),

package/lib/rules/rest-spread-spacing.js

@@ -79,10 +79,7 @@ module.exports = {
             if (alwaysSpace && !hasWhitespace) {
                 context.report({
                     node,
-                    loc: {
-                        line: operator.loc.end.line,
-                        column: operator.loc.end.column
-                    },
+                    loc: operator.loc,
                     messageId: "expectedWhitespace",
                     data: {
                         type
@@ -95,8 +92,8 @@ module.exports = {
                 context.report({
                     node,
                     loc: {
-                        line: operator.loc.end.line,
-                        column: operator.loc.end.column
+                        start: operator.loc.end,
+                        end: nextToken.loc.start
                     },
                     messageId: "unexpectedWhitespace",
                     data: {

package/lib/rules/semi-spacing.js

@@ -117,6 +117,18 @@ module.exports = {
         }
 
         /**
+         * Report location example :
+         *
+         * for unexpected space `before`
+         *
+         * var a = 'b'   ;
+         *            ^^^
+         *
+         * for unexpected space `after`
+         *
+         * var a = 'b';  c = 10;
+         *             ^^
+         *
          * Reports if the given token has invalid spacing.
          * @param {Token} token The semicolon token to check.
          * @param {ASTNode} node The corresponding node of the token.
@@ -124,16 +136,19 @@ module.exports = {
          */
         function checkSemicolonSpacing(token, node) {
             if (astUtils.isSemicolonToken(token)) {
-                const location = token.loc.start;
-
                 if (hasLeadingSpace(token)) {
                     if (!requireSpaceBefore) {
+                        const tokenBefore = sourceCode.getTokenBefore(token);
+                        const loc = {
+                            start: tokenBefore.loc.end,
+                            end: token.loc.start
+                        };
+
                         context.report({
                             node,
-                            loc: location,
+                            loc,
                             messageId: "unexpectedWhitespaceBefore",
                             fix(fixer) {
-                                const tokenBefore = sourceCode.getTokenBefore(token);
 
                                 return fixer.removeRange([tokenBefore.range[1], token.range[0]]);
                             }
@@ -141,9 +156,11 @@ module.exports = {
                     }
                 } else {
                     if (requireSpaceBefore) {
+                        const loc = token.loc;
+
                         context.report({
                             node,
-                            loc: location,
+                            loc,
                             messageId: "missingWhitespaceBefore",
                             fix(fixer) {
                                 return fixer.insertTextBefore(token, " ");
@@ -155,12 +172,17 @@ module.exports = {
                 if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {
                     if (hasTrailingSpace(token)) {
                         if (!requireSpaceAfter) {
+                            const tokenAfter = sourceCode.getTokenAfter(token);
+                            const loc = {
+                                start: token.loc.end,
+                                end: tokenAfter.loc.start
+                            };
+
                             context.report({
                                 node,
-                                loc: location,
+                                loc,
                                 messageId: "unexpectedWhitespaceAfter",
                                 fix(fixer) {
-                                    const tokenAfter = sourceCode.getTokenAfter(token);
 
                                     return fixer.removeRange([token.range[1], tokenAfter.range[0]]);
                                 }
@@ -168,9 +190,11 @@ module.exports = {
                         }
                     } else {
                         if (requireSpaceAfter) {
+                            const loc = token.loc;
+
                             context.report({
                                 node,
-                                loc: location,
+                                loc,
                                 messageId: "missingWhitespaceAfter",
                                 fix(fixer) {
                                     return fixer.insertTextAfter(token, " ");

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

@@ -127,7 +127,10 @@ module.exports = {
             if (hasSpacing && functionConfig === "never") {
                 context.report({
                     node,
-                    loc: leftToken.loc.end,
+                    loc: {
+                        start: leftToken.loc.end,
+                        end: rightToken.loc.start
+                    },
                     messageId: "unexpectedSpace",
                     fix(fixer) {
                         const comments = sourceCode.getCommentsBefore(rightToken);
@@ -145,7 +148,7 @@ module.exports = {
             } else if (!hasSpacing && functionConfig === "always") {
                 context.report({
                     node,
-                    loc: leftToken.loc.end,
+                    loc: rightToken.loc,
                     messageId: "missingSpace",
                     fix: fixer => fixer.insertTextAfter(leftToken, " ")
                 });

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

@@ -11,13 +11,6 @@
 
 const astUtils = require("./utils/ast-utils");
 
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const OPEN_PAREN = /\$\{$/u;
-const CLOSE_PAREN = /^\}/u;
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -49,7 +42,6 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
         const always = context.options[0] === "always";
-        const prefix = always ? "expected" : "unexpected";
 
         /**
          * Checks spacing before `}` of a given token.
@@ -57,25 +49,39 @@ module.exports = {
          * @returns {void}
          */
         function checkSpacingBefore(token) {
-            const prevToken = sourceCode.getTokenBefore(token, { includeComments: true });
+            if (!token.value.startsWith("}")) {
+                return; // starts with a backtick, this is the first template element in the template literal
+            }
+
+            const prevToken = sourceCode.getTokenBefore(token, { includeComments: true }),
+                hasSpace = sourceCode.isSpaceBetween(prevToken, token);
+
+            if (!astUtils.isTokenOnSameLine(prevToken, token)) {
+                return;
+            }
 
-            if (prevToken &&
-                CLOSE_PAREN.test(token.value) &&
-                astUtils.isTokenOnSameLine(prevToken, token) &&
-                sourceCode.isSpaceBetweenTokens(prevToken, token) !== always
-            ) {
+            if (always && !hasSpace) {
                 context.report({
-                    loc: token.loc.start,
-                    messageId: `${prefix}Before`,
-                    fix(fixer) {
-                        if (always) {
-                            return fixer.insertTextBefore(token, " ");
+                    loc: {
+                        start: token.loc.start,
+                        end: {
+                            line: token.loc.start.line,
+                            column: token.loc.start.column + 1
                         }
-                        return fixer.removeRange([
-                            prevToken.range[1],
-                            token.range[0]
-                        ]);
-                    }
+                    },
+                    messageId: "expectedBefore",
+                    fix: fixer => fixer.insertTextBefore(token, " ")
+                });
+            }
+
+            if (!always && hasSpace) {
+                context.report({
+                    loc: {
+                        start: prevToken.loc.end,
+                        end: token.loc.start
+                    },
+                    messageId: "unexpectedBefore",
+                    fix: fixer => fixer.removeRange([prevToken.range[1], token.range[0]])
                 });
             }
         }
@@ -86,28 +92,39 @@ module.exports = {
          * @returns {void}
          */
         function checkSpacingAfter(token) {
-            const nextToken = sourceCode.getTokenAfter(token, { includeComments: true });
+            if (!token.value.endsWith("${")) {
+                return; // ends with a backtick, this is the last template element in the template literal
+            }
+
+            const nextToken = sourceCode.getTokenAfter(token, { includeComments: true }),
+                hasSpace = sourceCode.isSpaceBetween(token, nextToken);
 
-            if (nextToken &&
-                OPEN_PAREN.test(token.value) &&
-                astUtils.isTokenOnSameLine(token, nextToken) &&
-                sourceCode.isSpaceBetweenTokens(token, nextToken) !== always
-            ) {
+            if (!astUtils.isTokenOnSameLine(token, nextToken)) {
+                return;
+            }
+
+            if (always && !hasSpace) {
                 context.report({
                     loc: {
-                        line: token.loc.end.line,
-                        column: token.loc.end.column - 2
+                        start: {
+                            line: token.loc.end.line,
+                            column: token.loc.end.column - 2
+                        },
+                        end: token.loc.end
                     },
-                    messageId: `${prefix}After`,
-                    fix(fixer) {
-                        if (always) {
-                            return fixer.insertTextAfter(token, " ");
-                        }
-                        return fixer.removeRange([
-                            token.range[1],
-                            nextToken.range[0]
-                        ]);
-                    }
+                    messageId: "expectedAfter",
+                    fix: fixer => fixer.insertTextAfter(token, " ")
+                });
+            }
+
+            if (!always && hasSpace) {
+                context.report({
+                    loc: {
+                        start: token.loc.end,
+                        end: nextToken.loc.start
+                    },
+                    messageId: "unexpectedAfter",
+                    fix: fixer => fixer.removeRange([token.range[1], nextToken.range[0]])
                 });
             }
         }

package/lib/rules/utils/ast-utils.js

@@ -1243,19 +1243,64 @@ module.exports = {
 
     /**
      * Gets next location when the result is not out of bound, otherwise returns null.
+     *
+     * Assumptions:
+     *
+     * - The given location represents a valid location in the given source code.
+     * - Columns are 0-based.
+     * - Lines are 1-based.
+     * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location.
+     * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end.
+     *   The start (column 0) of that extra line is considered to be a valid location.
+     *
+     * Examples of successive locations (line, column):
+     *
+     * code: foo
+     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null
+     *
+     * code: foo<LF>
+     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
+     *
+     * code: foo<CR><LF>
+     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
+     *
+     * code: a<LF>b
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null
+     *
+     * code: a<LF>b<LF>
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
+     *
+     * code: a<CR><LF>b<CR><LF>
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
+     *
+     * code: a<LF><LF>
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null
+     *
+     * code: <LF>
+     * locations: (1, 0) -> (2, 0) -> null
+     *
+     * code:
+     * locations: (1, 0) -> null
      * @param {SourceCode} sourceCode The sourceCode
      * @param {{line: number, column: number}} location The location
      * @returns {{line: number, column: number} | null} Next location
      */
-    getNextLocation(sourceCode, location) {
-        const index = sourceCode.getIndexFromLoc(location);
+    getNextLocation(sourceCode, { line, column }) {
+        if (column < sourceCode.lines[line - 1].length) {
+            return {
+                line,
+                column: column + 1
+            };
+        }
 
-        // Avoid out of bound location
-        if (index + 1 > sourceCode.text.length) {
-            return null;
+        if (line < sourceCode.lines.length) {
+            return {
+                line: line + 1,
+                column: 0
+            };
         }
 
-        return sourceCode.getLocFromIndex(index + 1);
+        return null;
     },
 
     /**
@@ -1357,17 +1402,65 @@ module.exports = {
      * next to each other, behavior is undefined (although it should return `true` in most cases).
      */
     canTokensBeAdjacent(leftValue, rightValue) {
+        const espreeOptions = {
+            ecmaVersion: espree.latestEcmaVersion,
+            comment: true,
+            range: true
+        };
+
         let leftToken;
 
         if (typeof leftValue === "string") {
-            const leftTokens = espree.tokenize(leftValue, { ecmaVersion: 2015 });
+            let tokens;
 
-            leftToken = leftTokens[leftTokens.length - 1];
+            try {
+                tokens = espree.tokenize(leftValue, espreeOptions);
+            } catch (e) {
+                return false;
+            }
+
+            const comments = tokens.comments;
+
+            leftToken = tokens[tokens.length - 1];
+            if (comments.length) {
+                const lastComment = comments[comments.length - 1];
+
+                if (lastComment.range[0] > leftToken.range[0]) {
+                    leftToken = lastComment;
+                }
+            }
         } else {
             leftToken = leftValue;
         }
 
-        const rightToken = typeof rightValue === "string" ? espree.tokenize(rightValue, { ecmaVersion: 2015 })[0] : rightValue;
+        if (leftToken.type === "Shebang") {
+            return false;
+        }
+
+        let rightToken;
+
+        if (typeof rightValue === "string") {
+            let tokens;
+
+            try {
+                tokens = espree.tokenize(rightValue, espreeOptions);
+            } catch (e) {
+                return false;
+            }
+
+            const comments = tokens.comments;
+
+            rightToken = tokens[0];
+            if (comments.length) {
+                const firstComment = comments[0];
+
+                if (firstComment.range[0] < rightToken.range[0]) {
+                    rightToken = firstComment;
+                }
+            }
+        } else {
+            rightToken = rightValue;
+        }
 
         if (leftToken.type === "Punctuator" || rightToken.type === "Punctuator") {
             if (leftToken.type === "Punctuator" && rightToken.type === "Punctuator") {
@@ -1379,6 +1472,9 @@ module.exports = {
                     MINUS_TOKENS.has(leftToken.value) && MINUS_TOKENS.has(rightToken.value)
                 );
             }
+            if (leftToken.type === "Punctuator" && leftToken.value === "/") {
+                return !["Block", "Line", "RegularExpression"].includes(rightToken.type);
+            }
             return true;
         }
 
@@ -1393,6 +1489,10 @@ module.exports = {
             return true;
         }
 
+        if (leftToken.type === "Block" || rightToken.type === "Block" || rightToken.type === "Line") {
+            return true;
+        }
+
         return false;
     },
 
@@ -1413,11 +1513,17 @@ module.exports = {
         const match = namePattern.exec(comment.value);
 
         // Convert the index to loc.
-        return sourceCode.getLocFromIndex(
+        const start = sourceCode.getLocFromIndex(
             comment.range[0] +
             "/*".length +
             (match ? match.index + 1 : 0)
         );
+        const end = {
+            line: start.line,
+            column: start.column + (match ? name.length : 1)
+        };
+
+        return { start, end };
     },
 
     /**