eslint 8.47.0 → 8.49.0

package/lib/rules/lines-between-class-members.js

@@ -10,6 +10,21 @@
 
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Types of class members.
+ * Those have `test` method to check it matches to the given class member.
+ * @private
+ */
+const ClassMemberTypes = {
+    "*": { test: () => true },
+    field: { test: node => node.type === "PropertyDefinition" },
+    method: { test: node => node.type === "MethodDefinition" }
+};
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -29,7 +44,32 @@ module.exports = {
 
         schema: [
             {
-                enum: ["always", "never"]
+                anyOf: [
+                    {
+                        type: "object",
+                        properties: {
+                            enforce: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        blankLine: { enum: ["always", "never"] },
+                                        prev: { enum: ["method", "field", "*"] },
+                                        next: { enum: ["method", "field", "*"] }
+                                    },
+                                    additionalProperties: false,
+                                    required: ["blankLine", "prev", "next"]
+                                },
+                                minItems: 1
+                            }
+                        },
+                        additionalProperties: false,
+                        required: ["enforce"]
+                    },
+                    {
+                        enum: ["always", "never"]
+                    }
+                ]
             },
             {
                 type: "object",
@@ -55,6 +95,7 @@ module.exports = {
         options[0] = context.options[0] || "always";
         options[1] = context.options[1] || { exceptAfterSingleLine: false };
 
+        const configureList = typeof options[0] === "object" ? options[0].enforce : [{ blankLine: options[0], prev: "*", next: "*" }];
         const sourceCode = context.sourceCode;
 
         /**
@@ -144,6 +185,38 @@ module.exports = {
             return sourceCode.getTokensBetween(before, after, { includeComments: true }).length !== 0;
         }
 
+        /**
+         * Checks whether the given node matches the given type.
+         * @param {ASTNode} node The class member node to check.
+         * @param {string} type The class member type to check.
+         * @returns {boolean} `true` if the class member node matched the type.
+         * @private
+         */
+        function match(node, type) {
+            return ClassMemberTypes[type].test(node);
+        }
+
+        /**
+         * Finds the last matched configuration from the configureList.
+         * @param {ASTNode} prevNode The previous node to match.
+         * @param {ASTNode} nextNode The current node to match.
+         * @returns {string|null} Padding type or `null` if no matches were found.
+         * @private
+         */
+        function getPaddingType(prevNode, nextNode) {
+            for (let i = configureList.length - 1; i >= 0; --i) {
+                const configure = configureList[i];
+                const matched =
+                    match(prevNode, configure.prev) &&
+                    match(nextNode, configure.next);
+
+                if (matched) {
+                    return configure.blankLine;
+                }
+            }
+            return null;
+        }
+
         return {
             ClassBody(node) {
                 const body = node.body;
@@ -158,22 +231,34 @@ module.exports = {
                     const isPadded = afterPadding.loc.start.line - beforePadding.loc.end.line > 1;
                     const hasTokenInPadding = hasTokenOrCommentBetween(beforePadding, afterPadding);
                     const curLineLastToken = findLastConsecutiveTokenAfter(curLast, nextFirst, 0);
+                    const paddingType = getPaddingType(body[i], body[i + 1]);
+
+                    if (paddingType === "never" && isPadded) {
+                        context.report({
+                            node: body[i + 1],
+                            messageId: "never",
 
-                    if ((options[0] === "always" && !skip && !isPadded) ||
-                        (options[0] === "never" && isPadded)) {
+                            fix(fixer) {
+                                if (hasTokenInPadding) {
+                                    return null;
+                                }
+                                return fixer.replaceTextRange([beforePadding.range[1], afterPadding.range[0]], "\n");
+                            }
+                        });
+                    } else if (paddingType === "always" && !skip && !isPadded) {
                         context.report({
                             node: body[i + 1],
-                            messageId: isPadded ? "never" : "always",
+                            messageId: "always",
+
                             fix(fixer) {
                                 if (hasTokenInPadding) {
                                     return null;
                                 }
-                                return isPadded
-                                    ? fixer.replaceTextRange([beforePadding.range[1], afterPadding.range[0]], "\n")
-                                    : fixer.insertTextAfter(curLineLastToken, "\n");
+                                return fixer.insertTextAfter(curLineLastToken, "\n");
                             }
                         });
                     }
+
                 }
             }
         };

package/lib/rules/no-fallthrough.js

@@ -16,6 +16,22 @@ const { directivesPattern } = require("../shared/directives");
 
 const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
 
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ * @param {Set<CodePathSegment>} segments The segments to check.
+ * @returns {boolean} True if any segment is reachable; false otherwise.
+ */
+function isAnySegmentReachable(segments) {
+
+    for (const segment of segments) {
+        if (segment.reachable) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
  * @param {string} comment The comment string to check.
@@ -51,15 +67,6 @@ function hasFallthroughComment(caseWhichFallsThrough, subsequentCase, context, f
     return Boolean(comment && isFallThroughComment(comment.value, fallthroughCommentPattern));
 }
 
-/**
- * Checks whether or not a given code path segment is reachable.
- * @param {CodePathSegment} segment A CodePathSegment to check.
- * @returns {boolean} `true` if the segment is reachable.
- */
-function isReachable(segment) {
-    return segment.reachable;
-}
-
 /**
  * Checks whether a node and a token are separated by blank lines
  * @param {ASTNode} node The node to check
@@ -109,7 +116,8 @@ module.exports = {
 
     create(context) {
         const options = context.options[0] || {};
-        let currentCodePath = null;
+        const codePathSegments = [];
+        let currentCodePathSegments = new Set();
         const sourceCode = context.sourceCode;
         const allowEmptyCase = options.allowEmptyCase || false;
 
@@ -126,13 +134,33 @@ module.exports = {
             fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;
         }
         return {
-            onCodePathStart(codePath) {
-                currentCodePath = codePath;
+
+            onCodePathStart() {
+                codePathSegments.push(currentCodePathSegments);
+                currentCodePathSegments = new Set();
             },
+
             onCodePathEnd() {
-                currentCodePath = currentCodePath.upper;
+                currentCodePathSegments = codePathSegments.pop();
+            },
+
+            onUnreachableCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
+
+            onUnreachableCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+            onCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
             },
 
+            onCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+
             SwitchCase(node) {
 
                 /*
@@ -157,7 +185,7 @@ module.exports = {
                  * `break`, `return`, or `throw` are unreachable.
                  * And allows empty cases and the last case.
                  */
-                if (currentCodePath.currentSegments.some(isReachable) &&
+                if (isAnySegmentReachable(currentCodePathSegments) &&
                     (node.consequent.length > 0 || (!allowEmptyCase && hasBlankLinesBetween(node, nextToken))) &&
                     node.parent.cases[node.parent.cases.length - 1] !== node) {
                     fallthroughCase = node;

package/lib/rules/no-promise-executor-return.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const { findVariable } = require("@eslint-community/eslint-utils");
+const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -59,6 +60,78 @@ function isPromiseExecutor(node, scope) {
         isGlobalReference(parent.callee, getOuterScope(scope));
 }
 
+/**
+ * Checks if the given node is a void expression.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} - `true` if the node is a void expression
+ */
+function expressionIsVoid(node) {
+    return node.type === "UnaryExpression" && node.operator === "void";
+}
+
+/**
+ * Fixes the linting error by prepending "void " to the given node
+ * @param {Object} sourceCode context given by context.sourceCode
+ * @param {ASTNode} node The node to fix.
+ * @param {Object} fixer The fixer object provided by ESLint.
+ * @returns {Array<Object>} - An array of fix objects to apply to the node.
+ */
+function voidPrependFixer(sourceCode, node, fixer) {
+
+    const requiresParens =
+
+        // prepending `void ` will fail if the node has a lower precedence than void
+        astUtils.getPrecedence(node) < astUtils.getPrecedence({ type: "UnaryExpression", operator: "void" }) &&
+
+        // check if there are parentheses around the node to avoid redundant parentheses
+        !astUtils.isParenthesised(sourceCode, node);
+
+    // avoid parentheses issues
+    const returnOrArrowToken = sourceCode.getTokenBefore(
+        node,
+        node.parent.type === "ArrowFunctionExpression"
+            ? astUtils.isArrowToken
+
+            // isReturnToken
+            : token => token.type === "Keyword" && token.value === "return"
+    );
+
+    const firstToken = sourceCode.getTokenAfter(returnOrArrowToken);
+
+    const prependSpace =
+
+        // is return token, as => allows void to be adjacent
+        returnOrArrowToken.value === "return" &&
+
+        // If two tokens (return and "(") are adjacent
+        returnOrArrowToken.range[1] === firstToken.range[0];
+
+    return [
+        fixer.insertTextBefore(firstToken, `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`),
+        fixer.insertTextAfter(node, requiresParens ? ")" : "")
+    ];
+}
+
+/**
+ * Fixes the linting error by `wrapping {}` around the given node's body.
+ * @param {Object} sourceCode context given by context.sourceCode
+ * @param {ASTNode} node The node to fix.
+ * @param {Object} fixer The fixer object provided by ESLint.
+ * @returns {Array<Object>} - An array of fix objects to apply to the node.
+ */
+function curlyWrapFixer(sourceCode, node, fixer) {
+
+    // https://github.com/eslint/eslint/pull/17282#issuecomment-1592795923
+    const arrowToken = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
+    const firstToken = sourceCode.getTokenAfter(arrowToken);
+    const lastToken = sourceCode.getLastToken(node);
+
+    return [
+        fixer.insertTextBefore(firstToken, "{"),
+        fixer.insertTextAfter(lastToken, "}")
+    ];
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -74,10 +147,27 @@ module.exports = {
             url: "https://eslint.org/docs/latest/rules/no-promise-executor-return"
         },
 
-        schema: [],
+        hasSuggestions: true,
+
+        schema: [{
+            type: "object",
+            properties: {
+                allowVoid: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
 
         messages: {
-            returnsValue: "Return values from promise executor functions cannot be read."
+            returnsValue: "Return values from promise executor functions cannot be read.",
+
+            // arrow and function suggestions
+            prependVoid: "Prepend `void` to the expression.",
+
+            // only arrow suggestions
+            wrapBraces: "Wrap the expression in `{}`."
         }
     },
 
@@ -85,26 +175,52 @@ module.exports = {
 
         let funcInfo = null;
         const sourceCode = context.sourceCode;
-
-        /**
-         * Reports the given node.
-         * @param {ASTNode} node Node to report.
-         * @returns {void}
-         */
-        function report(node) {
-            context.report({ node, messageId: "returnsValue" });
-        }
+        const {
+            allowVoid = false
+        } = context.options[0] || {};
 
         return {
 
             onCodePathStart(_, node) {
                 funcInfo = {
                     upper: funcInfo,
-                    shouldCheck: functionTypesToCheck.has(node.type) && isPromiseExecutor(node, sourceCode.getScope(node))
+                    shouldCheck:
+                        functionTypesToCheck.has(node.type) &&
+                        isPromiseExecutor(node, sourceCode.getScope(node))
                 };
 
-                if (funcInfo.shouldCheck && node.type === "ArrowFunctionExpression" && node.expression) {
-                    report(node.body);
+                if (// Is a Promise executor
+                    funcInfo.shouldCheck &&
+                    node.type === "ArrowFunctionExpression" &&
+                    node.expression &&
+
+                    // Except void
+                    !(allowVoid && expressionIsVoid(node.body))
+                ) {
+                    const suggest = [];
+
+                    // prevent useless refactors
+                    if (allowVoid) {
+                        suggest.push({
+                            messageId: "prependVoid",
+                            fix(fixer) {
+                                return voidPrependFixer(sourceCode, node.body, fixer);
+                            }
+                        });
+                    }
+
+                    suggest.push({
+                        messageId: "wrapBraces",
+                        fix(fixer) {
+                            return curlyWrapFixer(sourceCode, node, fixer);
+                        }
+                    });
+
+                    context.report({
+                        node: node.body,
+                        messageId: "returnsValue",
+                        suggest
+                    });
                 }
             },
 
@@ -113,9 +229,31 @@ module.exports = {
             },
 
             ReturnStatement(node) {
-                if (funcInfo.shouldCheck && node.argument) {
-                    report(node);
+                if (!(funcInfo.shouldCheck && node.argument)) {
+                    return;
                 }
+
+                // node is `return <expression>`
+                if (!allowVoid) {
+                    context.report({ node, messageId: "returnsValue" });
+                    return;
+                }
+
+                if (expressionIsVoid(node.argument)) {
+                    return;
+                }
+
+                // allowVoid && !expressionIsVoid
+                context.report({
+                    node,
+                    messageId: "returnsValue",
+                    suggest: [{
+                        messageId: "prependVoid",
+                        fix(fixer) {
+                            return voidPrependFixer(sourceCode, node.argument, fixer);
+                        }
+                    }]
+                });
             }
         };
     }

package/lib/rules/no-this-before-super.js

@@ -90,6 +90,21 @@ module.exports = {
             return Boolean(funcInfo && funcInfo.isConstructor && funcInfo.hasExtends);
         }
 
+        /**
+         * Determines if every segment in a set has been called.
+         * @param {Set<CodePathSegment>} segments The segments to search.
+         * @returns {boolean} True if every segment has been called; false otherwise.
+         */
+        function isEverySegmentCalled(segments) {
+            for (const segment of segments) {
+                if (!isCalled(segment)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
         /**
          * Checks whether or not this is before `super()` is called.
          * @returns {boolean} `true` if this is before `super()` is called.
@@ -97,7 +112,7 @@ module.exports = {
         function isBeforeCallOfSuper() {
             return (
                 isInConstructorOfDerivedClass() &&
-                !funcInfo.codePath.currentSegments.every(isCalled)
+                !isEverySegmentCalled(funcInfo.currentSegments)
             );
         }
 
@@ -108,11 +123,9 @@ module.exports = {
          * @returns {void}
          */
         function setInvalid(node) {
-            const segments = funcInfo.codePath.currentSegments;
-
-            for (let i = 0; i < segments.length; ++i) {
-                const segment = segments[i];
+            const segments = funcInfo.currentSegments;
 
+            for (const segment of segments) {
                 if (segment.reachable) {
                     segInfoMap[segment.id].invalidNodes.push(node);
                 }
@@ -124,11 +137,9 @@ module.exports = {
          * @returns {void}
          */
         function setSuperCalled() {
-            const segments = funcInfo.codePath.currentSegments;
-
-            for (let i = 0; i < segments.length; ++i) {
-                const segment = segments[i];
+            const segments = funcInfo.currentSegments;
 
+            for (const segment of segments) {
                 if (segment.reachable) {
                     segInfoMap[segment.id].superCalled = true;
                 }
@@ -156,14 +167,16 @@ module.exports = {
                             classNode.superClass &&
                             !astUtils.isNullOrUndefined(classNode.superClass)
                         ),
-                        codePath
+                        codePath,
+                        currentSegments: new Set()
                     };
                 } else {
                     funcInfo = {
                         upper: funcInfo,
                         isConstructor: false,
                         hasExtends: false,
-                        codePath
+                        codePath,
+                        currentSegments: new Set()
                     };
                 }
             },
@@ -211,6 +224,8 @@ module.exports = {
              * @returns {void}
              */
             onCodePathSegmentStart(segment) {
+                funcInfo.currentSegments.add(segment);
+
                 if (!isInConstructorOfDerivedClass()) {
                     return;
                 }
@@ -225,6 +240,18 @@ module.exports = {
                 };
             },
 
+            onUnreachableCodePathSegmentStart(segment) {
+                funcInfo.currentSegments.add(segment);
+            },
+
+            onUnreachableCodePathSegmentEnd(segment) {
+                funcInfo.currentSegments.delete(segment);
+            },
+
+            onCodePathSegmentEnd(segment) {
+                funcInfo.currentSegments.delete(segment);
+            },
+
             /**
              * Update information of the code path segment when a code path was
              * looped.

package/lib/rules/no-unreachable-loop.js

@@ -11,6 +11,22 @@
 
 const allLoopTypes = ["WhileStatement", "DoWhileStatement", "ForStatement", "ForInStatement", "ForOfStatement"];
 
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ * @param {Set<CodePathSegment>} segments The segments to check.
+ * @returns {boolean} True if any segment is reachable; false otherwise.
+ */
+function isAnySegmentReachable(segments) {
+
+    for (const segment of segments) {
+        if (segment.reachable) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * Determines whether the given node is the first node in the code path to which a loop statement
  * 'loops' for the next iteration.
@@ -90,29 +106,36 @@ module.exports = {
             loopsByTargetSegments = new Map(),
             loopsToReport = new Set();
 
-        let currentCodePath = null;
+        const codePathSegments = [];
+        let currentCodePathSegments = new Set();
 
         return {
-            onCodePathStart(codePath) {
-                currentCodePath = codePath;
+
+            onCodePathStart() {
+                codePathSegments.push(currentCodePathSegments);
+                currentCodePathSegments = new Set();
             },
 
             onCodePathEnd() {
-                currentCodePath = currentCodePath.upper;
+                currentCodePathSegments = codePathSegments.pop();
             },
 
-            [loopSelector](node) {
+            onUnreachableCodePathSegmentStart(segment) {
+                currentCodePathSegments.add(segment);
+            },
 
-                /**
-                 * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
-                 * For unreachable segments, the code path analysis does not raise events required for this implementation.
-                 */
-                if (currentCodePath.currentSegments.some(segment => segment.reachable)) {
-                    loopsToReport.add(node);
-                }
+            onUnreachableCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
+            },
+
+            onCodePathSegmentEnd(segment) {
+                currentCodePathSegments.delete(segment);
             },
 
             onCodePathSegmentStart(segment, node) {
+
+                currentCodePathSegments.add(segment);
+
                 if (isLoopingTarget(node)) {
                     const loop = node.parent;
 
@@ -140,6 +163,18 @@ module.exports = {
                 }
             },
 
+            [loopSelector](node) {
+
+                /**
+                 * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
+                 * For unreachable segments, the code path analysis does not raise events required for this implementation.
+                 */
+                if (isAnySegmentReachable(currentCodePathSegments)) {
+                    loopsToReport.add(node);
+                }
+            },
+
+
             "Program:exit"() {
                 loopsToReport.forEach(
                     node => context.report({ node, messageId: "invalid" })