feat: Implement onUnreachableCodePathStart/End

docs/src/extend/code-path-analysis.md

@@ -69,7 +69,7 @@ module.exports = function(context) {
          * @param {ASTNode} node - The current node.
          * @returns {void}
          */
-        "onCodePathStart": function(codePath, node) {
+        onCodePathStart(codePath, node) {
             // do something with codePath
         },
 
@@ -81,12 +81,12 @@ module.exports = function(context) {
          * @param {ASTNode} node - The current node.
          * @returns {void}
          */
-        "onCodePathEnd": function(codePath, node) {
+        onCodePathEnd(codePath, node) {
             // do something with codePath
         },
 
         /**
-         * This is called when a code path segment was created.
+         * This is called when a reachable code path segment was created.
          * It meant the code path is forked or merged.
          * In this time, the segment has the previous segments and has been
          * judged reachable or not.
@@ -95,19 +95,45 @@ module.exports = function(context) {
          * @param {ASTNode} node - The current node.
          * @returns {void}
          */
-        "onCodePathSegmentStart": function(segment, node) {
+        onCodePathSegmentStart(segment, node) {
             // do something with segment
         },
 
         /**
-         * This is called when a code path segment was left.
+         * This is called when a reachable code path segment was left.
          * In this time, the segment does not have the next segments yet.
          *
          * @param {CodePathSegment} segment - The left code path segment.
          * @param {ASTNode} node - The current node.
          * @returns {void}
          */
-        "onCodePathSegmentEnd": function(segment, node) {
+        onCodePathSegmentEnd(segment, node) {
+            // do something with segment
+        },
+
+        /**
+         * This is called when an unreachable code path segment was created.
+         * It meant the code path is forked or merged.
+         * In this time, the segment has the previous segments and has been
+         * judged reachable or not.
+         *
+         * @param {CodePathSegment} segment - The new code path segment.
+         * @param {ASTNode} node - The current node.
+         * @returns {void}
+         */
+        onUnreachableCodePathSegmentStart(segment, node) {
+            // do something with segment
+        },
+
+        /**
+         * This is called when an unreachable code path segment was left.
+         * In this time, the segment does not have the next segments yet.
+         *
+         * @param {CodePathSegment} segment - The left code path segment.
+         * @param {ASTNode} node - The current node.
+         * @returns {void}
+         */
+        onUnreachableCodePathSegmentEnd(segment, node) {
             // do something with segment
         },
 
@@ -122,7 +148,7 @@ module.exports = function(context) {
          * @param {ASTNode} node - The current node.
          * @returns {void}
          */
-        "onCodePathSegmentLoop": function(fromSegment, toSegment, node) {
+        "onCodePathSegmentLoop(fromSegment, toSegment, node) {
             // do something with segment
         }
     };
@@ -272,23 +298,28 @@ function isCbCalled(info) {
 }
 
 module.exports = function(context) {
-    var funcInfoStack = [];
-    var segmentInfoMap = Object.create(null);
+    let funcInfo;
+    const funcInfoStack = [];
+    const segmentInfoMap = Object.create(null);
 
     return {
         // Checks `cb`.
-        "onCodePathStart": function(codePath, node) {
-            funcInfoStack.push({
+        onCodePathStart(codePath, node) {
+            funcInfo = {
                 codePath: codePath,
-                hasCb: hasCb(node, context)
-            });
+                hasCb: hasCb(node, context),
+                currentSegments: []
+            };
+
+            funcInfoStack.push(funcInfo);
         },
-        "onCodePathEnd": function(codePath, node) {
-            funcInfoStack.pop();
+
+        onCodePathEnd(codePath, node) {
+            funcInfo = funcInfoStack.pop();
 
             // Checks `cb` was called in every paths.
-            var cbCalled = codePath.finalSegments.every(function(segment) {
-                var info = segmentInfoMap[segment.id];
+            const cbCalled = codePath.finalSegments.every(function(segment) {
+                const info = segmentInfoMap[segment.id];
                 return info.cbCalled;
             });
 
@@ -300,17 +331,18 @@ module.exports = function(context) {
             }
         },
 
-        // Manages state of code paths.
-        "onCodePathSegmentStart": function(segment) {
-            var funcInfo = funcInfoStack[funcInfoStack.length - 1];
+        // Manages state of code paths and tracks traversed segments
+        onCodePathSegmentStart(segment) {
+
+            funcInfo.currentSegments.push(segment);
 
             // Ignores if `cb` doesn't exist.
             if (!funcInfo.hasCb) {
                 return;
             }
 
             // Initialize state of this path.
-            var info = segmentInfoMap[segment.id] = {
+            const info = segmentInfoMap[segment.id] = {
                 cbCalled: false
             };
 
@@ -321,20 +353,34 @@ module.exports = function(context) {
             }
         },
 
+        // Tracks unreachable segment traversal
+        onUnreachableCodePathSegmentStart(segment) {
+            funcInfo.currentSegments.push(segment);
+        }
+
+        // Tracks reachable segment traversal
+        onCodePathSegmentEnd() {
+            funcInfo.currentSegments.pop();
+        }
+
+        // Tracks unreachable segment traversal
+        onUnreachableCodePathSegmentEnd() {
+            funcInfo.currentSegments.pop();
+        }
+
         // Checks reachable or not.
-        "CallExpression": function(node) {
-            var funcInfo = funcInfoStack[funcInfoStack.length - 1];
+        CallExpression(node) {
 
             // Ignores if `cb` doesn't exist.
             if (!funcInfo.hasCb) {
                 return;
             }
 
             // Sets marks that `cb` was called.
-            var callee = node.callee;
+            const callee = node.callee;
             if (callee.type === "Identifier" && callee.name === "cb") {
-                funcInfo.codePath.currentSegments.forEach(function(segment) {
-                    var info = segmentInfoMap[segment.id];
+                funcInfo.currentSegments.forEach(segment => {
+                    const info = segmentInfoMap[segment.id];
                     info.cbCalled = true;
                 });
             }

lib/linter/code-path-analysis/code-path-analyzer.js

@@ -192,15 +192,18 @@ function forwardCurrentToHead(analyzer, node) {
         headSegment = headSegments[i];
 
         if (currentSegment !== headSegment && currentSegment) {
-            debug.dump(`onCodePathSegmentEnd ${currentSegment.id}`);
 
-            if (currentSegment.reachable) {
-                analyzer.emitter.emit(
-                    "onCodePathSegmentEnd",
-                    currentSegment,
-                    node
-                );
-            }
+            const eventName = currentSegment.reachable
+                ? "onCodePathSegmentEnd"
+                : "onUnreachableCodePathSegmentEnd";
+
+            debug.dump(`${eventName} ${currentSegment.id}`);
+
+            analyzer.emitter.emit(
+                eventName,
+                currentSegment,
+                node
+            );
         }
     }
 
@@ -213,16 +216,19 @@ function forwardCurrentToHead(analyzer, node) {
         headSegment = headSegments[i];
 
         if (currentSegment !== headSegment && headSegment) {
-            debug.dump(`onCodePathSegmentStart ${headSegment.id}`);
+
+            const eventName = headSegment.reachable
+                ? "onCodePathSegmentStart"
+                : "onUnreachableCodePathSegmentStart";
+
+            debug.dump(`${eventName} ${headSegment.id}`);
 
             CodePathSegment.markUsed(headSegment);
-            if (headSegment.reachable) {
-                analyzer.emitter.emit(
-                    "onCodePathSegmentStart",
-                    headSegment,
-                    node
-                );
-            }
+            analyzer.emitter.emit(
+                eventName,
+                headSegment,
+                node
+            );
         }
     }
 
@@ -241,15 +247,17 @@ function leaveFromCurrentSegment(analyzer, node) {
 
     for (let i = 0; i < currentSegments.length; ++i) {
         const currentSegment = currentSegments[i];
+        const eventName = currentSegment.reachable
+            ? "onCodePathSegmentEnd"
+            : "onUnreachableCodePathSegmentEnd";
 
-        debug.dump(`onCodePathSegmentEnd ${currentSegment.id}`);
-        if (currentSegment.reachable) {
-            analyzer.emitter.emit(
-                "onCodePathSegmentEnd",
-                currentSegment,
-                node
-            );
-        }
+        debug.dump(`${eventName} ${currentSegment.id}`);
+
+        analyzer.emitter.emit(
+            eventName,
+            currentSegment,
+            node
+        );
     }
 
     state.currentSegments = [];

lib/linter/linter.js

@@ -898,6 +898,7 @@ const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
     getTokensBetween: "getTokensBetween"
 };
 
+
 const BASE_TRAVERSAL_CONTEXT = Object.freeze(
     Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).reduce(
         (contextInfo, methodName) =>

lib/rules/array-callback-return.js

@@ -18,15 +18,6 @@ const astUtils = require("./utils/ast-utils");
 const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
 const TARGET_METHODS = /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort|toSorted)$/u;
 
-/**
- * Checks a given code path segment is reachable.
- * @param {CodePathSegment} segment A segment to check.
- * @returns {boolean} `true` if the segment is reachable.
- */
-function isReachable(segment) {
-    return segment.reachable;
-}
-
 /**
  * Checks a given node is a member access which has the specified name's
  * property.
@@ -38,6 +29,22 @@ function isTargetMethod(node) {
     return astUtils.isSpecificMemberAccess(node, null, TARGET_METHODS);
 }
 
+/**
+ * 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;
+}
+
 /**
  * Returns a human-legible description of an array method
  * @param {string} arrayMethodName A method name to fully qualify
@@ -205,7 +212,7 @@ module.exports = {
                     messageId = "expectedNoReturnValue";
                 }
             } else {
-                if (node.body.type === "BlockStatement" && funcInfo.codePath.currentSegments.some(isReachable)) {
+                if (node.body.type === "BlockStatement" && isAnySegmentReachable(funcInfo.currentSegments)) {
                     messageId = funcInfo.hasReturn ? "expectedAtEnd" : "expectedInside";
                 }
             }
@@ -242,7 +249,8 @@ module.exports = {
                         methodName &&
                         !node.async &&
                         !node.generator,
-                    node
+                    node,
+                    currentSegments: new Set()
                 };
             },
 
@@ -251,6 +259,23 @@ module.exports = {
                 funcInfo = funcInfo.upper;
             },
 
+            onUnreachableCodePathSegmentStart(segment) {
+                funcInfo.currentSegments.add(segment);
+            },
+
+            onUnreachableCodePathSegmentEnd(segment) {
+                funcInfo.currentSegments.delete(segment);
+            },
+
+            onCodePathSegmentStart(segment) {
+                funcInfo.currentSegments.add(segment);
+            },
+
+            onCodePathSegmentEnd(segment) {
+                funcInfo.currentSegments.delete(segment);
+            },
+
+
             // Checks the return statement is valid.
             ReturnStatement(node) {