Fix incorrect code generation for try...finally with break in a generator.

When a `break` statement appeared inside a `finally` block, the transpiler would generate an extra `break` statement, which would cause the `leaveFinallyBlock` call to be unreachable.

This change fixes the issue by introducing an `inFinallyBlock` flag to the `TranspilationContext`. This flag is used in `replaceBreakContinueWithJump` to prevent the extra `break` from being generated when inside a `finally` block.

PiperOrigin-RevId: 795630876

Author: concavelenz

src/com/google/javascript/jscomp/Es6RewriteGenerators.java

@@ -1139,8 +1139,12 @@ private class TranspilationContext {
        */
       Case currentCase;
 
+      // A counter for the number of finally blocks we are currently inside.
+      // This value is used for two purposes:
+      // 1. At COMPILE-TIME, to determine if a break/continue is inside a finally block.
+      // 2. At RUNTIME, its value is emitted into the generated code to manage the
+      //    exception-handling stack.
       int nestedFinallyBlockCount = 0;
-
       boolean thisReferenceFound;
       boolean argumentsReferenceFound;
 
@@ -1514,7 +1518,11 @@ Node createJumpToBlock(Case section, boolean allowEmbedding, Node sourceNode) {
       /** Converts "break" and "continue" statements into state machine jumps. */
       void replaceBreakContinueWithJump(Node sourceNode, Case section, int breakSuppressors) {
         final String jumpMethod;
-        if (finallyCases.isEmpty() || finallyCases.getFirst().id < section.id) {
+        if (nestedFinallyBlockCount > 0) {
+          // If we are in a finally block, we need to use jumpThroughFinallyBlocks to ensure that
+          // the finally block is correctly exited.
+          jumpMethod = "jumpThroughFinallyBlocks";
+        } else if (finallyCases.isEmpty() || finallyCases.getFirst().id < section.id) {
           // There are no finally blocks that should be exectuted pior to jumping
           jumpMethod = "jumpTo";
         } else {
@@ -1530,7 +1538,14 @@ void replaceBreakContinueWithJump(Node sourceNode, Case section, int breakSuppre
                   type(StandardColors.NULL_OR_VOID),
                   section.getNumber(sourceNode))
               .insertBefore(sourceNode);
-          sourceNode.replaceWith(createBreakNodeFor(sourceNode));
+          if (nestedFinallyBlockCount == 0) {
+            sourceNode.replaceWith(createBreakNodeFor(sourceNode));
+          } else {
+            // If we are in a finally block, we need to detach the source node to prevent an extra
+            // break from being generated. The break is not needed because the
+            // jumpThroughFinallyBlocks call will handle the control flow.
+            sourceNode.detach();
+          }
         } else {
           // "break;" inside a loop or swtich statement:
           // for (...) {

test/com/google/javascript/jscomp/Es6RewriteGeneratorsTest.java

@@ -33,6 +33,7 @@
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
+/** Tests for {@link Es6RewriteGenerators} */
 @RunWith(JUnit4.class)
 public final class Es6RewriteGeneratorsTest extends CompilerTestCase {
 
@@ -1914,9 +1915,46 @@ private Node getAndCheckGeneratorProgram(Node genFunction) {
     return createGenerator.getNext().getNext();
   }
 
-  // The following tests demonstrate the bug in how "break" is handled in a "finally" block.
-  // The "expected" output is the actual, incorrect output of the compiler, and a comment
-  // is added to the test to indicate that the test is expected to fail with the fix.
+  @Test
+  public void testBreakInNestedFinally() {
+    rewriteGeneratorSwitchBodyWithVars(
+        """
+        OUTER: do {
+          try {
+            try {
+              yield 1;
+            } finally {
+              break OUTER;
+            }
+          } finally {
+            break OUTER;
+          }
+        } while (false);
+        """,
+        "",
+        """
+          GEN_CONTEXT$0.setFinallyBlock(5);
+          GEN_CONTEXT$0.setFinallyBlock(7);
+          return GEN_CONTEXT$0.yield(1, 7);
+        case 7:
+          GEN_CONTEXT$0.enterFinallyBlock(0, 5);
+          GEN_CONTEXT$0.jumpThroughFinallyBlocks(0);
+          GEN_CONTEXT$0.leaveFinallyBlock(5);
+          break;
+        case 5:
+          GEN_CONTEXT$0.enterFinallyBlock();
+          GEN_CONTEXT$0.jumpThroughFinallyBlocks(0);
+          GEN_CONTEXT$0.leaveFinallyBlock(2);
+          break;
+        case 2:
+          if (false) {
+            GEN_CONTEXT$0.jumpTo(1);
+            break;
+          }
+          GEN_CONTEXT$0.jumpToEnd();
+        """);
+  }
+
   @Test
   public void testFinallyReturnCancelledByOuterBreak() {
     rewriteGeneratorSwitchBodyWithVars(
@@ -1938,8 +1976,7 @@ public void testFinallyReturnCancelledByOuterBreak() {
           return GEN_CONTEXT$0.return("innerTry");
         case 5:
           GEN_CONTEXT$0.enterFinallyBlock();
-          GEN_CONTEXT$0.jumpTo(0);
-          break; // This break is wrong. It should not be here.
+          GEN_CONTEXT$0.jumpThroughFinallyBlocks(0);
           GEN_CONTEXT$0.leaveFinallyBlock(2);
           break;
         case 2:
@@ -1978,7 +2015,6 @@ public void testFinallyReturnCancelledByOuterBreak_nested() {
         case 7:
           GEN_CONTEXT$0.enterFinallyBlock(0, 5);
           GEN_CONTEXT$0.jumpThroughFinallyBlocks(0);
-          break; // This break is wrong. It should not be here.
           GEN_CONTEXT$0.leaveFinallyBlock(5);
           break;
         case 5:
@@ -1995,4 +2031,45 @@ public void testFinallyReturnCancelledByOuterBreak_nested() {
           GEN_CONTEXT$0.jumpToEnd();
         """);
   }
+
+  @Test
+  public void testContinueInNestedFinallyInLoop() {
+    rewriteGeneratorSwitchBodyWithVars(
+        """
+        OUT: do {
+          try {
+            yield 1;
+          } finally {
+            try {
+              yield 2;
+            } finally {
+              continue OUT;
+            }
+          }
+        } while (false);
+        """,
+        "",
+        """
+          GEN_CONTEXT$0.setFinallyBlock(5);
+          return GEN_CONTEXT$0.yield(1, 5);
+        case 5:
+          GEN_CONTEXT$0.enterFinallyBlock();
+          GEN_CONTEXT$0.setFinallyBlock(8);
+          return GEN_CONTEXT$0.yield(2, 8);
+        case 8:
+          GEN_CONTEXT$0.enterFinallyBlock(0, 0, 1);
+          GEN_CONTEXT$0.jumpThroughFinallyBlocks(2);
+          GEN_CONTEXT$0.leaveFinallyBlock(9, 1);
+          break;
+        case 9:
+          GEN_CONTEXT$0.leaveFinallyBlock(2);
+          break;
+        case 2:
+          if (false) {
+            GEN_CONTEXT$0.jumpTo(1);
+            break;
+          }
+          GEN_CONTEXT$0.jumpToEnd();
+        """);
+  }
 }