eslint 7.0.0 → 7.3.1

package/lib/linter/code-path-analysis/code-path-state.js

@@ -201,6 +201,7 @@ function finalizeTestSegmentsOfFor(context, choiceContext, head) {
     if (!choiceContext.processed) {
         choiceContext.trueForkContext.add(head);
         choiceContext.falseForkContext.add(head);
+        choiceContext.qqForkContext.add(head);
     }
 
     if (context.test !== true) {
@@ -351,6 +352,7 @@ class CodePathState {
             isForkingAsResult,
             trueForkContext: ForkContext.newEmpty(this.forkContext),
             falseForkContext: ForkContext.newEmpty(this.forkContext),
+            qqForkContext: ForkContext.newEmpty(this.forkContext),
             processed: false
         };
     }
@@ -370,6 +372,7 @@ class CodePathState {
         switch (context.kind) {
             case "&&":
             case "||":
+            case "??":
 
                 /*
                  * If any result were not transferred from child contexts,
@@ -379,6 +382,7 @@ class CodePathState {
                 if (!context.processed) {
                     context.trueForkContext.add(headSegments);
                     context.falseForkContext.add(headSegments);
+                    context.qqForkContext.add(headSegments);
                 }
 
                 /*
@@ -390,6 +394,7 @@ class CodePathState {
 
                     parentContext.trueForkContext.addAll(context.trueForkContext);
                     parentContext.falseForkContext.addAll(context.falseForkContext);
+                    parentContext.qqForkContext.addAll(context.qqForkContext);
                     parentContext.processed = true;
 
                     return context;
@@ -456,13 +461,24 @@ class CodePathState {
              * This got segments already from the child choice context.
              * Creates the next path from own true/false fork context.
              */
-            const prevForkContext =
-                context.kind === "&&" ? context.trueForkContext
-                /* kind === "||" */ : context.falseForkContext;
+            let prevForkContext;
+
+            switch (context.kind) {
+                case "&&": // if true then go to the right-hand side.
+                    prevForkContext = context.trueForkContext;
+                    break;
+                case "||": // if false then go to the right-hand side.
+                    prevForkContext = context.falseForkContext;
+                    break;
+                case "??": // Both true/false can short-circuit, so needs the third path to go to the right-hand side. That's qqForkContext.
+                    prevForkContext = context.qqForkContext;
+                    break;
+                default:
+                    throw new Error("unreachable");
+            }
 
             forkContext.replaceHead(prevForkContext.makeNext(0, -1));
             prevForkContext.clear();
-
             context.processed = false;
         } else {
 
@@ -471,14 +487,19 @@ class CodePathState {
              * So addresses the head segments.
              * The head segments are the path of the left-hand operand.
              */
-            if (context.kind === "&&") {
-
-                // The path does short-circuit if false.
-                context.falseForkContext.add(forkContext.head);
-            } else {
-
-                // The path does short-circuit if true.
-                context.trueForkContext.add(forkContext.head);
+            switch (context.kind) {
+                case "&&": // the false path can short-circuit.
+                    context.falseForkContext.add(forkContext.head);
+                    break;
+                case "||": // the true path can short-circuit.
+                    context.trueForkContext.add(forkContext.head);
+                    break;
+                case "??": // both can short-circuit.
+                    context.trueForkContext.add(forkContext.head);
+                    context.falseForkContext.add(forkContext.head);
+                    break;
+                default:
+                    throw new Error("unreachable");
             }
 
             forkContext.replaceHead(forkContext.makeNext(-1, -1));
@@ -501,6 +522,7 @@ class CodePathState {
         if (!context.processed) {
             context.trueForkContext.add(forkContext.head);
             context.falseForkContext.add(forkContext.head);
+            context.qqForkContext.add(forkContext.head);
         }
 
         context.processed = false;

package/lib/linter/config-comment-parser.js

@@ -78,7 +78,7 @@ module.exports = class ConfigCommentParser {
                     config: items
                 };
             }
-        } catch (ex) {
+        } catch {
 
             debug("Levn parsing failed; falling back to manual parsing.");
 

package/lib/linter/linter.js

@@ -938,7 +938,8 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parser
         });
     });
 
-    const eventGenerator = new CodePathAnalyzer(new NodeEventGenerator(emitter));
+    // only run code path analyzer if the top level node is "Program", skip otherwise
+    const eventGenerator = nodeQueue[0].node.type === "Program" ? new CodePathAnalyzer(new NodeEventGenerator(emitter)) : new NodeEventGenerator(emitter);
 
     nodeQueue.forEach(traversalInfo => {
         currentNode = traversalInfo.node;

package/lib/rule-tester/rule-tester.js

@@ -644,6 +644,10 @@ class RuleTester {
             assert.ok(item.errors || item.errors === 0,
                 `Did not specify errors for an invalid test of ${ruleName}`);
 
+            if (Array.isArray(item.errors) && item.errors.length === 0) {
+                assert.fail("Invalid cases must have at least one error");
+            }
+
             const ruleHasMetaMessages = hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages");
             const friendlyIDList = ruleHasMetaMessages ? `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]` : null;
 
@@ -651,6 +655,11 @@ class RuleTester {
             const messages = result.messages;
 
             if (typeof item.errors === "number") {
+
+                if (item.errors === 0) {
+                    assert.fail("Invalid cases must have 'error' value greater than 0");
+                }
+
                 assert.strictEqual(messages.length, item.errors, util.format("Should have %d error%s but had %d: %s",
                     item.errors, item.errors === 1 ? "" : "s", messages.length, util.inspect(messages)));
             } else {

package/lib/rules/accessor-pairs.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Rule to flag wrapping non-iife in parens
+ * @fileoverview Rule to enforce getter and setter pairs in objects and classes.
  * @author Gyandeep Singh
  */
 

package/lib/rules/arrow-parens.js

@@ -105,10 +105,27 @@ module.exports = {
                 ], `${shouldAddSpaceForAsync ? " " : ""}${paramToken.value}`);
             }
 
+            /**
+             * Checks whether there are comments inside the params or not.
+             * @returns {boolean} `true` if there are comments inside of parens, else `false`
+             */
+            function hasCommentsInParens() {
+                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
+                    const closingParenToken = sourceCode.getTokenAfter(node.params[0], astUtils.isClosingParenToken);
+
+                    return closingParenToken && sourceCode.commentsExistBetween(firstTokenOfParam, closingParenToken);
+                }
+                return false;
+
+            }
+
+            if (hasCommentsInParens()) {
+                return;
+            }
+
             // "as-needed", { "requireForBlockBody": true }: x => x
             if (
                 requireForBlockBody &&
-                node.params.length === 1 &&
                 node.params[0].type === "Identifier" &&
                 !node.params[0].typeAnnotation &&
                 node.body.type !== "BlockStatement" &&
@@ -144,7 +161,6 @@ module.exports = {
 
             // "as-needed": x => x
             if (asNeeded &&
-                node.params.length === 1 &&
                 node.params[0].type === "Identifier" &&
                 !node.params[0].typeAnnotation &&
                 !node.returnType
@@ -178,7 +194,7 @@ module.exports = {
         }
 
         return {
-            ArrowFunctionExpression: parens
+            "ArrowFunctionExpression[params.length=1]": parens
         };
     }
 };

package/lib/rules/block-spacing.js

@@ -102,9 +102,18 @@ module.exports = {
 
             // Check.
             if (!isValid(openBrace, firstToken)) {
+                let loc = openBrace.loc;
+
+                if (messageId === "extra") {
+                    loc = {
+                        start: openBrace.loc.end,
+                        end: firstToken.loc.start
+                    };
+                }
+
                 context.report({
                     node,
-                    loc: openBrace.loc.start,
+                    loc,
                     messageId,
                     data: {
                         location: "after",
@@ -120,9 +129,17 @@ module.exports = {
                 });
             }
             if (!isValid(lastToken, closeBrace)) {
+                let loc = closeBrace.loc;
+
+                if (messageId === "extra") {
+                    loc = {
+                        start: lastToken.loc.end,
+                        end: closeBrace.loc.start
+                    };
+                }
                 context.report({
                     node,
-                    loc: closeBrace.loc.start,
+                    loc,
                     messageId,
                     data: {
                         location: "before",

package/lib/rules/callback-return.js

@@ -12,7 +12,7 @@ module.exports = {
     meta: {
         deprecated: true,
 
-        replacedBy: ["node/callback-return"],
+        replacedBy: [],
 
         type: "suggestion",
 

package/lib/rules/comma-dangle.js

@@ -124,7 +124,8 @@ module.exports = {
                         }
                     ]
                 }
-            ]
+            ],
+            additionalItems: false
         },
 
         messages: {

package/lib/rules/curly.js

@@ -457,11 +457,18 @@ module.exports = {
 
         return {
             IfStatement(node) {
-                if (node.parent.type !== "IfStatement") {
+                const parent = node.parent;
+                const isElseIf = parent.type === "IfStatement" && parent.alternate === node;
+
+                if (!isElseIf) {
+
+                    // This is a top `if`, check the whole `if-else-if` chain
                     prepareIfChecks(node).forEach(preparedCheck => {
                         preparedCheck.check();
                     });
                 }
+
+                // Skip `else if`, it's already checked (when the top `if` was visited)
             },
 
             WhileStatement(node) {

package/lib/rules/func-call-spacing.js

@@ -116,7 +116,13 @@ module.exports = {
             if (never && hasWhitespace) {
                 context.report({
                     node,
-                    loc: leftToken.loc.start,
+                    loc: {
+                        start: leftToken.loc.end,
+                        end: {
+                            line: rightToken.loc.start.line,
+                            column: rightToken.loc.start.column - 1
+                        }
+                    },
                     messageId: "unexpectedWhitespace",
                     fix(fixer) {
 
@@ -134,7 +140,13 @@ module.exports = {
             } else if (!never && !hasWhitespace) {
                 context.report({
                     node,
-                    loc: leftToken.loc.start,
+                    loc: {
+                        start: {
+                            line: leftToken.loc.end.line,
+                            column: leftToken.loc.end.column - 1
+                        },
+                        end: rightToken.loc.start
+                    },
                     messageId: "missing",
                     fix(fixer) {
                         return fixer.insertTextBefore(rightToken, " ");
@@ -143,7 +155,10 @@ module.exports = {
             } else if (!never && !allowNewlines && hasNewline) {
                 context.report({
                     node,
-                    loc: leftToken.loc.start,
+                    loc: {
+                        start: leftToken.loc.end,
+                        end: rightToken.loc.start
+                    },
                     messageId: "unexpectedNewline",
                     fix(fixer) {
                         return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ");

package/lib/rules/global-require.js

@@ -50,7 +50,7 @@ module.exports = {
     meta: {
         deprecated: true,
 
-        replacedBy: ["node/global-require"],
+        replacedBy: [],
 
         type: "suggestion",
 

package/lib/rules/handle-callback-err.js

@@ -13,7 +13,7 @@ module.exports = {
     meta: {
         deprecated: true,
 
-        replacedBy: ["node/handle-callback-err"],
+        replacedBy: [],
 
         type: "suggestion",
 

package/lib/rules/id-match.js

@@ -39,7 +39,8 @@ module.exports = {
                         type: "boolean",
                         default: false
                     }
-                }
+                },
+                additionalProperties: false
             }
         ],
         messages: {

package/lib/rules/index.js

@@ -148,6 +148,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-lone-blocks": () => require("./no-lone-blocks"),
     "no-lonely-if": () => require("./no-lonely-if"),
     "no-loop-func": () => require("./no-loop-func"),
+    "no-loss-of-precision": () => require("./no-loss-of-precision"),
     "no-magic-numbers": () => require("./no-magic-numbers"),
     "no-misleading-character-class": () => require("./no-misleading-character-class"),
     "no-mixed-operators": () => require("./no-mixed-operators"),
@@ -175,6 +176,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-plusplus": () => require("./no-plusplus"),
     "no-process-env": () => require("./no-process-env"),
     "no-process-exit": () => require("./no-process-exit"),
+    "no-promise-executor-return": () => require("./no-promise-executor-return"),
     "no-proto": () => require("./no-proto"),
     "no-prototype-builtins": () => require("./no-prototype-builtins"),
     "no-redeclare": () => require("./no-redeclare"),
@@ -211,6 +213,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-unmodified-loop-condition": () => require("./no-unmodified-loop-condition"),
     "no-unneeded-ternary": () => require("./no-unneeded-ternary"),
     "no-unreachable": () => require("./no-unreachable"),
+    "no-unreachable-loop": () => require("./no-unreachable-loop"),
     "no-unsafe-finally": () => require("./no-unsafe-finally"),
     "no-unsafe-negation": () => require("./no-unsafe-negation"),
     "no-unused-expressions": () => require("./no-unused-expressions"),

package/lib/rules/key-spacing.js

@@ -433,11 +433,15 @@ module.exports = {
                 tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { includeComments: true }),
                 tokenAfterColon = sourceCode.getTokenAfter(nextColon, { includeComments: true }),
                 isKeySide = side === "key",
-                locStart = isKeySide ? tokenBeforeColon.loc.start : tokenAfterColon.loc.start,
                 isExtra = diff > 0,
                 diffAbs = Math.abs(diff),
                 spaces = Array(diffAbs + 1).join(" ");
 
+            const locStart = isKeySide ? tokenBeforeColon.loc.end : nextColon.loc.start;
+            const locEnd = isKeySide ? nextColon.loc.start : tokenAfterColon.loc.start;
+            const missingLoc = isKeySide ? tokenBeforeColon.loc : tokenAfterColon.loc;
+            const loc = isExtra ? { start: locStart, end: locEnd } : missingLoc;
+
             if ((
                 diff && mode === "strict" ||
                 diff < 0 && mode === "minimum" ||
@@ -482,7 +486,7 @@ module.exports = {
 
                 context.report({
                     node: property[side],
-                    loc: locStart,
+                    loc,
                     messageId,
                     data: {
                         computed: property.computed ? "computed " : "",

package/lib/rules/keyword-spacing.js

@@ -152,7 +152,7 @@ module.exports = {
                 sourceCode.isSpaceBetweenTokens(prevToken, token)
             ) {
                 context.report({
-                    loc: token.loc.start,
+                    loc: { start: prevToken.loc.end, end: token.loc.start },
                     messageId: "unexpectedBefore",
                     data: token,
                     fix(fixer) {
@@ -203,8 +203,9 @@ module.exports = {
                 astUtils.isTokenOnSameLine(token, nextToken) &&
                 sourceCode.isSpaceBetweenTokens(token, nextToken)
             ) {
+
                 context.report({
-                    loc: token.loc.start,
+                    loc: { start: token.loc.end, end: nextToken.loc.start },
                     messageId: "unexpectedAfter",
                     data: token,
                     fix(fixer) {
@@ -442,6 +443,12 @@ module.exports = {
                 checkSpacingAround(sourceCode.getTokenAfter(firstToken));
             }
 
+            if (node.type === "ExportAllDeclaration" && node.exported) {
+                const asToken = sourceCode.getTokenBefore(node.exported);
+
+                checkSpacingBefore(asToken, PREV_TOKEN_M);
+            }
+
             if (node.source) {
                 const fromToken = sourceCode.getTokenBefore(node.source);
 

package/lib/rules/linebreak-style.js

@@ -86,8 +86,14 @@ module.exports = {
                     context.report({
                         node,
                         loc: {
-                            line: i,
-                            column: sourceCode.lines[i - 1].length
+                            start: {
+                                line: i,
+                                column: sourceCode.lines[i - 1].length
+                            },
+                            end: {
+                                line: i + 1,
+                                column: 0
+                            }
                         },
                         messageId: expectedLF ? "expectedLF" : "expectedCRLF",
                         fix: createFix(range, expectedLFChars)

package/lib/rules/max-lines-per-function.js

@@ -134,7 +134,7 @@ module.exports = {
          * @returns {boolean} True if it's an IIFE
          */
         function isIIFE(node) {
-            return node.type === "FunctionExpression" && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
+            return (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.parent && node.parent.type === "CallExpression" && node.parent.callee === node;
         }
 
         /**

package/lib/rules/max-lines.js

@@ -53,7 +53,8 @@ module.exports = {
             }
         ],
         messages: {
-            exceed: "File has too many lines ({{actual}}). Maximum allowed is {{max}}."
+            exceed:
+                "File has too many lines ({{actual}}). Maximum allowed is {{max}}."
         }
     },
 
@@ -61,7 +62,10 @@ module.exports = {
         const option = context.options[0];
         let max = 300;
 
-        if (typeof option === "object" && Object.prototype.hasOwnProperty.call(option, "max")) {
+        if (
+            typeof option === "object" &&
+            Object.prototype.hasOwnProperty.call(option, "max")
+        ) {
             max = option.max;
         } else if (typeof option === "number") {
             max = option;
@@ -94,7 +98,9 @@ module.exports = {
 
             token = comment;
             do {
-                token = sourceCode.getTokenBefore(token, { includeComments: true });
+                token = sourceCode.getTokenBefore(token, {
+                    includeComments: true
+                });
             } while (isCommentNodeType(token));
 
             if (token && astUtils.isTokenOnSameLine(token, comment)) {
@@ -103,7 +109,9 @@ module.exports = {
 
             token = comment;
             do {
-                token = sourceCode.getTokenAfter(token, { includeComments: true });
+                token = sourceCode.getTokenAfter(token, {
+                    includeComments: true
+                });
             } while (isCommentNodeType(token));
 
             if (token && astUtils.isTokenOnSameLine(comment, token)) {
@@ -118,7 +126,10 @@ module.exports = {
 
         return {
             "Program:exit"() {
-                let lines = sourceCode.lines.map((text, i) => ({ lineNumber: i + 1, text }));
+                let lines = sourceCode.lines.map((text, i) => ({
+                    lineNumber: i + 1,
+                    text
+                }));
 
                 if (skipBlankLines) {
                     lines = lines.filter(l => l.text.trim() !== "");
@@ -127,14 +138,29 @@ module.exports = {
                 if (skipComments) {
                     const comments = sourceCode.getAllComments();
 
-                    const commentLines = lodash.flatten(comments.map(comment => getLinesWithoutCode(comment)));
+                    const commentLines = lodash.flatten(
+                        comments.map(comment => getLinesWithoutCode(comment))
+                    );
 
-                    lines = lines.filter(l => !lodash.includes(commentLines, l.lineNumber));
+                    lines = lines.filter(
+                        l => !lodash.includes(commentLines, l.lineNumber)
+                    );
                 }
 
                 if (lines.length > max) {
+                    const loc = {
+                        start: {
+                            line: lines[max].lineNumber,
+                            column: 0
+                        },
+                        end: {
+                            line: sourceCode.lines.length,
+                            column: lodash.last(sourceCode.lines).length
+                        }
+                    };
+
                     context.report({
-                        loc: { line: 1, column: 0 },
+                        loc,
                         messageId: "exceed",
                         data: {
                             max,

package/lib/rules/multiline-ternary.js

@@ -39,25 +39,7 @@ module.exports = {
         const option = context.options[0];
         const multiline = option !== "never";
         const allowSingleLine = option === "always-multiline";
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Tests whether node is preceded by supplied tokens
-         * @param {ASTNode} node node to check
-         * @param {ASTNode} parentNode parent of node to report
-         * @param {boolean} expected whether newline was expected or not
-         * @returns {void}
-         * @private
-         */
-        function reportError(node, parentNode, expected) {
-            context.report({
-                node,
-                messageId: `${expected ? "expected" : "unexpected"}${node === parentNode.test ? "TestCons" : "ConsAlt"}`
-            });
-        }
+        const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
         // Public
@@ -65,16 +47,39 @@ module.exports = {
 
         return {
             ConditionalExpression(node) {
-                const areTestAndConsequentOnSameLine = astUtils.isTokenOnSameLine(node.test, node.consequent);
-                const areConsequentAndAlternateOnSameLine = astUtils.isTokenOnSameLine(node.consequent, node.alternate);
+                const questionToken = sourceCode.getTokenAfter(node.test, astUtils.isNotClosingParenToken);
+                const colonToken = sourceCode.getTokenAfter(node.consequent, astUtils.isNotClosingParenToken);
+
+                const firstTokenOfTest = sourceCode.getFirstToken(node);
+                const lastTokenOfTest = sourceCode.getTokenBefore(questionToken);
+                const firstTokenOfConsequent = sourceCode.getTokenAfter(questionToken);
+                const lastTokenOfConsequent = sourceCode.getTokenBefore(colonToken);
+                const firstTokenOfAlternate = sourceCode.getTokenAfter(colonToken);
+
+                const areTestAndConsequentOnSameLine = astUtils.isTokenOnSameLine(lastTokenOfTest, firstTokenOfConsequent);
+                const areConsequentAndAlternateOnSameLine = astUtils.isTokenOnSameLine(lastTokenOfConsequent, firstTokenOfAlternate);
 
                 if (!multiline) {
                     if (!areTestAndConsequentOnSameLine) {
-                        reportError(node.test, node, false);
+                        context.report({
+                            node: node.test,
+                            loc: {
+                                start: firstTokenOfTest.loc.start,
+                                end: lastTokenOfTest.loc.end
+                            },
+                            messageId: "unexpectedTestCons"
+                        });
                     }
 
                     if (!areConsequentAndAlternateOnSameLine) {
-                        reportError(node.consequent, node, false);
+                        context.report({
+                            node: node.consequent,
+                            loc: {
+                                start: firstTokenOfConsequent.loc.start,
+                                end: lastTokenOfConsequent.loc.end
+                            },
+                            messageId: "unexpectedConsAlt"
+                        });
                     }
                 } else {
                     if (allowSingleLine && node.loc.start.line === node.loc.end.line) {
@@ -82,11 +87,25 @@ module.exports = {
                     }
 
                     if (areTestAndConsequentOnSameLine) {
-                        reportError(node.test, node, true);
+                        context.report({
+                            node: node.test,
+                            loc: {
+                                start: firstTokenOfTest.loc.start,
+                                end: lastTokenOfTest.loc.end
+                            },
+                            messageId: "expectedTestCons"
+                        });
                     }
 
                     if (areConsequentAndAlternateOnSameLine) {
-                        reportError(node.consequent, node, true);
+                        context.report({
+                            node: node.consequent,
+                            loc: {
+                                start: firstTokenOfConsequent.loc.start,
+                                end: lastTokenOfConsequent.loc.end
+                            },
+                            messageId: "expectedConsAlt"
+                        });
                     }
                 }
             }