eslint 7.0.0-alpha.1 → 7.0.0

package/lib/rules/no-plusplus.js

@@ -6,6 +6,41 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the given node is the update node of a `ForStatement`.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is `ForStatement` update.
+ */
+function isForStatementUpdate(node) {
+    const parent = node.parent;
+
+    return parent.type === "ForStatement" && parent.update === node;
+}
+
+/**
+ * Determines whether the given node is considered to be a for loop "afterthought" by the logic of this rule.
+ * In particular, it returns `true` if the given node is either:
+ *   - The update node of a `ForStatement`: for (;; i++) {}
+ *   - An operand of a sequence expression that is the update node: for (;; foo(), i++) {}
+ *   - An operand of a sequence expression that is child of another sequence expression, etc.,
+ *     up to the sequence expression that is the update node: for (;; foo(), (bar(), (baz(), i++))) {}
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a for loop afterthought.
+ */
+function isForLoopAfterthought(node) {
+    const parent = node.parent;
+
+    if (parent.type === "SequenceExpression") {
+        return isForLoopAfterthought(parent);
+    }
+
+    return isForStatementUpdate(node);
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -42,18 +77,19 @@ module.exports = {
     create(context) {
 
         const config = context.options[0];
-        let allowInForAfterthought = false;
+        let allowForLoopAfterthoughts = false;
 
         if (typeof config === "object") {
-            allowInForAfterthought = config.allowForLoopAfterthoughts === true;
+            allowForLoopAfterthoughts = config.allowForLoopAfterthoughts === true;
         }
 
         return {
 
             UpdateExpression(node) {
-                if (allowInForAfterthought && node.parent.type === "ForStatement") {
+                if (allowForLoopAfterthoughts && isForLoopAfterthought(node)) {
                     return;
                 }
+
                 context.report({
                     node,
                     messageId: "unexpectedUnaryOp",

package/lib/rules/no-process-env.js

@@ -10,6 +10,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-process-env"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-process-exit.js

@@ -10,6 +10,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-process-exit"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-prototype-builtins.js

@@ -47,7 +47,7 @@ module.exports = {
             if (DISALLOWED_PROPS.indexOf(propName) > -1) {
                 context.report({
                     messageId: "prototypeBuildIn",
-                    loc: node.callee.property.loc.start,
+                    loc: node.callee.property.loc,
                     data: { prop: propName },
                     node
                 });

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

@@ -40,6 +40,10 @@ const arrayOfStringsOrObjects = {
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-restricted-require"],
+
         type: "suggestion",
 
         docs: {
@@ -106,10 +110,19 @@ module.exports = {
          * @param {ASTNode} node The node to check.
          * @returns {boolean} If the node is a string literal.
          */
-        function isString(node) {
+        function isStringLiteral(node) {
             return node && node.type === "Literal" && typeof node.value === "string";
         }
 
+        /**
+         * Function to check if a node is a static string template literal.
+         * @param {ASTNode} node The node to check.
+         * @returns {boolean} If the node is a string template literal.
+         */
+        function isStaticTemplateLiteral(node) {
+            return node && node.type === "TemplateLiteral" && node.expressions.length === 0;
+        }
+
         /**
          * Function to check if a node is a require call.
          * @param {ASTNode} node The node to check.
@@ -119,14 +132,31 @@ module.exports = {
             return node.callee.type === "Identifier" && node.callee.name === "require";
         }
 
+        /**
+         * Extract string from Literal or TemplateLiteral node
+         * @param {ASTNode} node The node to extract from
+         * @returns {string|null} Extracted string or null if node doesn't represent a string
+         */
+        function getFirstArgumentString(node) {
+            if (isStringLiteral(node)) {
+                return node.value.trim();
+            }
+
+            if (isStaticTemplateLiteral(node)) {
+                return node.quasis[0].value.cooked.trim();
+            }
+
+            return null;
+        }
+
         /**
          * Report a restricted path.
          * @param {node} node representing the restricted path reference
+         * @param {string} name restricted path
          * @returns {void}
          * @private
          */
-        function reportPath(node) {
-            const name = node.arguments[0].value.trim();
+        function reportPath(node, name) {
             const customMessage = restrictedPathMessages[name];
             const messageId = customMessage
                 ? "customMessage"
@@ -156,21 +186,25 @@ module.exports = {
             CallExpression(node) {
                 if (isRequireCall(node)) {
 
-                    // node has arguments and first argument is string
-                    if (node.arguments.length && isString(node.arguments[0])) {
-                        const name = node.arguments[0].value.trim();
-
-                        // check if argument value is in restricted modules array
-                        if (isRestrictedPath(name)) {
-                            reportPath(node);
-                        }
-
-                        if (restrictedPatterns.length > 0 && ig.ignores(name)) {
-                            context.report({
-                                node,
-                                messageId: "patternMessage",
-                                data: { name }
-                            });
+                    // node has arguments
+                    if (node.arguments.length) {
+                        const name = getFirstArgumentString(node.arguments[0]);
+
+                        // if first argument is a string literal or a static string template literal
+                        if (name) {
+
+                            // check if argument value is in restricted modules array
+                            if (isRestrictedPath(name)) {
+                                reportPath(node, name);
+                            }
+
+                            if (restrictedPatterns.length > 0 && ig.ignores(name)) {
+                                context.report({
+                                    node,
+                                    messageId: "patternMessage",
+                                    data: { name }
+                                });
+                            }
                         }
                     }
                 }

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

@@ -145,7 +145,7 @@ module.exports = {
         docs: {
             description: "disallow returning values from setters",
             category: "Possible Errors",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/rules/no-setter-return"
         },
 

package/lib/rules/no-sync.js

@@ -13,6 +13,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-sync"],
+
         type: "suggestion",
 
         docs: {

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

@@ -205,7 +205,7 @@ module.exports = {
             const identifier = node.key.name;
             const isMethod = node.type === "MethodDefinition" || node.type === "Property" && node.method;
 
-            if (typeof identifier !== "undefined" && enforceInMethodNames && isMethod && hasTrailingUnderscore(identifier)) {
+            if (typeof identifier !== "undefined" && enforceInMethodNames && isMethod && hasTrailingUnderscore(identifier) && !isAllowed(identifier)) {
                 context.report({
                     node,
                     messageId: "unexpectedUnderscore",

package/lib/rules/no-unexpected-multiline.js

@@ -53,7 +53,11 @@ module.exports = {
             const nodeExpressionEnd = sourceCode.getTokenBefore(openParen);
 
             if (openParen.loc.start.line !== nodeExpressionEnd.loc.end.line) {
-                context.report({ node, loc: openParen.loc.start, messageId, data: { char: openParen.value } });
+                context.report({
+                    node,
+                    loc: openParen.loc,
+                    messageId
+                });
             }
         }
 
@@ -71,18 +75,24 @@ module.exports = {
             },
 
             TaggedTemplateExpression(node) {
-                if (node.tag.loc.end.line === node.quasi.loc.start.line) {
-                    return;
-                }
-
-                // handle generics type parameters on template tags
-                const tokenBefore = sourceCode.getTokenBefore(node.quasi);
-
-                if (tokenBefore.loc.end.line === node.quasi.loc.start.line) {
-                    return;
+                const { quasi } = node;
+
+                // handles common tags, parenthesized tags, and typescript's generic type arguments
+                const tokenBefore = sourceCode.getTokenBefore(quasi);
+
+                if (tokenBefore.loc.end.line !== quasi.loc.start.line) {
+                    context.report({
+                        node,
+                        loc: {
+                            start: quasi.loc.start,
+                            end: {
+                                line: quasi.loc.start.line,
+                                column: quasi.loc.start.column + 1
+                            }
+                        },
+                        messageId: "taggedTemplate"
+                    });
                 }
-
-                context.report({ node, loc: node.loc.start, messageId: "taggedTemplate" });
             },
 
             CallExpression(node) {

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

@@ -105,7 +105,7 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: operatorToken.loc.start,
+                        loc: operatorToken.loc,
                         messageId: "unexpectedConcat"
                     });
                 }

package/lib/rules/operator-assignment.js

@@ -214,12 +214,12 @@ module.exports = {
                             ) {
                                 rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
                             } else {
-                                const firstRightToken = sourceCode.getFirstToken(node.right);
+                                const tokenAfterOperator = sourceCode.getTokenAfter(operatorToken, { includeComments: true });
                                 let rightTextPrefix = "";
 
                                 if (
-                                    operatorToken.range[1] === firstRightToken.range[0] &&
-                                    !astUtils.canTokensBeAdjacent({ type: "Punctuator", value: newOperator }, firstRightToken)
+                                    operatorToken.range[1] === tokenAfterOperator.range[0] &&
+                                    !astUtils.canTokensBeAdjacent({ type: "Punctuator", value: newOperator }, tokenAfterOperator)
                                 ) {
                                     rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
                                 }

package/lib/rules/operator-linebreak.js

@@ -172,10 +172,7 @@ module.exports = {
                 // lone operator
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "badLinebreak",
                     data: {
                         operator
@@ -187,10 +184,7 @@ module.exports = {
 
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "operatorAtBeginning",
                     data: {
                         operator
@@ -202,10 +196,7 @@ module.exports = {
 
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "operatorAtEnd",
                     data: {
                         operator
@@ -217,10 +208,7 @@ module.exports = {
 
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "noLinebreak",
                     data: {
                         operator

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/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

@@ -1357,17 +1357,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;
+
+            try {
+                tokens = espree.tokenize(leftValue, espreeOptions);
+            } catch (e) {
+                return false;
+            }
+
+            const comments = tokens.comments;
 
-            leftToken = leftTokens[leftTokens.length - 1];
+            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 +1427,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 +1444,10 @@ module.exports = {
             return true;
         }
 
+        if (leftToken.type === "Block" || rightToken.type === "Block" || rightToken.type === "Line") {
+            return true;
+        }
+
         return false;
     },
 
@@ -1413,11 +1468,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 };
     },
 
     /**