feat: Implement onUnreachableCodePathStart/End

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/rules/no-unreachable.js

@@ -132,6 +132,12 @@ module.exports = {
         /** @type {ConsecutiveRange} */
         const range = new ConsecutiveRange(context.sourceCode);
 
+        /** @type {Array<Array<CodePathSegments>>} */
+        const codePathSegments = [];
+
+        /** @type {Array<CodePathSegments>} */
+        let currentCodePathSegments = [];
+
         /**
          * Reports a given node if it's unreachable.
          * @param {ASTNode} node A statement node to report.
@@ -140,7 +146,7 @@ module.exports = {
         function reportIfUnreachable(node) {
             let nextNode = null;
 
-            if (node && (node.type === "PropertyDefinition" || currentCodePath.currentSegments.every(isUnreachable))) {
+            if (node && (node.type === "PropertyDefinition" || currentCodePathSegments.every(isUnreachable))) {
 
                 // Store this statement to distinguish consecutive statements.
                 if (range.isEmpty) {
@@ -183,10 +189,29 @@ module.exports = {
             // Manages the current code path.
             onCodePathStart(codePath) {
                 currentCodePath = codePath;
+                codePathSegments.push(currentCodePathSegments);
+                currentCodePathSegments = [];
             },
 
             onCodePathEnd() {
                 currentCodePath = currentCodePath.upper;
+                currentCodePathSegments = codePathSegments.pop();
+            },
+
+            onUnreachableCodePathSegmentStart(segment) {
+                currentCodePathSegments.push(segment);
+            },
+
+            onUnreachableCodePathSegmentEnd() {
+                currentCodePathSegments.pop();
+            },
+
+            onCodePathSegmentStart(segment) {
+                currentCodePathSegments.push(segment);
+            },
+
+            onCodePathSegmentEnd() {
+                currentCodePathSegments.pop();
             },
 
             // Registers for all statement nodes (excludes FunctionDeclaration).

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

@@ -439,6 +439,142 @@ describe("CodePathAnalyzer", () => {
         });
     });
 
+    describe("onUnreachableCodePathSegmentStart", () => {
+        it("should be fired after a throw", () => {
+            let lastCodePathNodeType = null;
+
+            linter.defineRule("test", {
+                create: () => ({
+                    onUnreachableCodePathSegmentStart(segment, node) {
+                        lastCodePathNodeType = node.type;
+
+                        assert(segment instanceof CodePathSegment);
+                        assert.strictEqual(node.type, "ExpressionStatement");
+                    },
+                    ExpressionStatement() {
+                        assert.strictEqual(lastCodePathNodeType, "ExpressionStatement");
+                    }
+                })
+            });
+            linter.verify(
+                "throw 'boom'; foo();",
+                { rules: { test: 2 } }
+            );
+
+        });
+
+        it("should be fired after a return", () => {
+            let lastCodePathNodeType = null;
+
+            linter.defineRule("test", {
+                create: () => ({
+                    onUnreachableCodePathSegmentStart(segment, node) {
+                        lastCodePathNodeType = node.type;
+
+                        assert(segment instanceof CodePathSegment);
+                        assert.strictEqual(node.type, "ExpressionStatement");
+                    },
+                    ExpressionStatement() {
+                        assert.strictEqual(lastCodePathNodeType, "ExpressionStatement");
+                    }
+                })
+            });
+            linter.verify(
+                "function foo() { return; foo(); }",
+                { rules: { test: 2 } }
+            );
+
+        });
+    });
+
+    describe("onUnreachableCodePathSegmentEnd", () => {
+        it("should be fired after a throw", () => {
+            let lastCodePathNodeType = null;
+
+            linter.defineRule("test", {
+                create: () => ({
+                    onUnreachableCodePathSegmentEnd(segment, node) {
+                        lastCodePathNodeType = node.type;
+
+                        assert(segment instanceof CodePathSegment);
+                        assert.strictEqual(node.type, "Program");
+                    }
+                })
+            });
+            linter.verify(
+                "throw 'boom'; foo();",
+                { rules: { test: 2 } }
+            );
+
+            assert.strictEqual(lastCodePathNodeType, "Program");
+        });
+
+        it("should be fired after a return", () => {
+            let lastCodePathNodeType = null;
+
+            linter.defineRule("test", {
+                create: () => ({
+                    onUnreachableCodePathSegmentEnd(segment, node) {
+                        lastCodePathNodeType = node.type;
+                        assert(segment instanceof CodePathSegment);
+                        assert.strictEqual(node.type, "FunctionDeclaration");
+                    },
+                    "Program:exit"() {
+                        assert.strictEqual(lastCodePathNodeType, "FunctionDeclaration");
+                    }
+                })
+            });
+            linter.verify(
+                "function foo() { return; foo(); }",
+                { rules: { test: 2 } }
+            );
+
+        });
+
+        it("should be fired at the end of programs/functions for the final segment", () => {
+            let count = 0;
+            let lastNodeType = null;
+
+            linter.defineRule("test", {
+                create: () => ({
+                    onCodePathSegmentEnd(cp, node) {
+                        count += 1;
+
+                        assert(cp instanceof CodePathSegment);
+                        if (count === 4) {
+                            assert(node.type === "Program");
+                        } else if (count === 1) {
+                            assert(node.type === "FunctionDeclaration");
+                        } else if (count === 2) {
+                            assert(node.type === "FunctionExpression");
+                        } else if (count === 3) {
+                            assert(node.type === "ArrowFunctionExpression");
+                        }
+                        assert(node.type === lastNodeType);
+                    },
+                    "Program:exit"() {
+                        lastNodeType = "Program";
+                    },
+                    "FunctionDeclaration:exit"() {
+                        lastNodeType = "FunctionDeclaration";
+                    },
+                    "FunctionExpression:exit"() {
+                        lastNodeType = "FunctionExpression";
+                    },
+                    "ArrowFunctionExpression:exit"() {
+                        lastNodeType = "ArrowFunctionExpression";
+                    }
+                })
+            });
+            linter.verify(
+                "foo(); function foo() {} var foo = function() {}; var foo = () => {};",
+                { rules: { test: 2 }, env: { es6: true } }
+            );
+
+            assert(count === 4);
+        });
+    });
+
     describe("onCodePathSegmentLoop", () => {
         it("should be fired in `while` loops", () => {
             let count = 0;