fix(es/compat): Fix finally handling of generator (#7215)

**Description:**

Update generator implementation to match
https://github.com/microsoft/TypeScript/blob/e83d61398ea0e4231e882121dd6c6bcfe4fdc9e4/src/compiler/transformers/generators.ts

**Related issue:**

 - Closes #5913.

crates/swc_ecma_transforms_compat/src/es2015/generator.rs

@@ -37,6 +37,16 @@ struct Wrapper {
     unresolved_ctxt: SyntaxContext,
 }
 
+macro_rules! dev_span {
+    ($($tt:tt)*) => {{
+        if cfg!(debug_assertions) {
+            Some(tracing::span!(tracing::Level::ERROR, $($tt)*).entered())
+        } else {
+            None
+        }
+    }};
+}
+
 impl VisitMut for Wrapper {
     noop_visit_mut_type!();
 
@@ -338,7 +348,7 @@ struct Generator {
     clauses: Option<Vec<SwitchCase>>,
     stmts: Option<Vec<Stmt>>,
     /// Index to `blocks`
-    exception_block_stack: Vec<Ptr<CodeBlock>>,
+    exception_block_stack: Option<Vec<Ptr<CodeBlock>>>,
     /// Index to `blocks`
     current_exception_block: Option<Ptr<CodeBlock>>,
     /// Index to `blocks`
@@ -1425,6 +1435,8 @@ impl Generator {
     }
 
     fn transform_and_emit_stmt(&mut self, node: Stmt) {
+        let _tracing = dev_span!("transform_and_emit_stmt");
+
         let saved_in_statement_containing_yield = self.in_statement_containing_yield;
         if !self.in_statement_containing_yield {
             self.in_statement_containing_yield = contains_yield(&node);
@@ -1608,6 +1620,8 @@ impl Generator {
     }
 
     fn transform_and_emit_while_stmt(&mut self, mut node: WhileStmt) {
+        let _tracing = dev_span!("transform_and_emit_while_stmt");
+
         if contains_yield(&node) {
             // [source]
             //      while (i < 10) {
@@ -1628,7 +1642,7 @@ impl Generator {
             self.mark_label(loop_label);
             node.test.visit_mut_with(self);
             self.emit_break_when_false(end_label, node.test, None);
-            self.transform_and_emit_stmt(*node.body);
+            self.transform_and_emit_embedded_stmt(*node.body);
             self.emit_break(loop_label, None);
             self.end_loop_block();
         } else {
@@ -2015,6 +2029,8 @@ impl Generator {
     }
 
     fn transform_and_emit_try_stmt(&mut self, mut node: TryStmt) {
+        let _tracing = dev_span!("transform_and_emit_try_stmt");
+
         if contains_yield(&node) {
             // [source]
             //      try {
@@ -2236,11 +2252,15 @@ impl Generator {
         let b = block.borrow();
         if let CodeBlock::With(block) = &*b {
             self.mark_label(block.end_label);
+        } else {
+            unreachable!()
         }
     }
 
     /// Begins a code block for a generated `try` statement.
     fn begin_exception_block(&mut self) -> Label {
+        let _tracing = dev_span!("begin_exception_block");
+
         let start_label = self.define_label();
         let end_label = self.define_label();
         self.mark_label(start_label);
@@ -2305,6 +2325,8 @@ impl Generator {
 
     /// Enters the `finally` block of a generated `try` statement.
     fn begin_finally_block(&mut self) {
+        let _tracing = dev_span!("begin_finally_block");
+
         debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::Exception));
 
         let block = self.peek_block().unwrap();
@@ -2319,6 +2341,8 @@ impl Generator {
             self.mark_label(finally_label);
             block.state = ExceptionBlockState::Finally;
             block.finally_label = Some(finally_label);
+        } else {
+            unreachable!()
         }
     }
 
@@ -2337,6 +2361,8 @@ impl Generator {
             self.mark_label(block.end_label);
             self.emit_nop();
             block.state = ExceptionBlockState::Done;
+        } else {
+            unreachable!()
         }
     }
 
@@ -2357,6 +2383,8 @@ impl Generator {
     /// - `continue_label`: A Label used to mark the operation to which to jump
     ///   when a `continue` statement targets this block.
     fn begin_loop_block(&mut self, continue_label: Label) -> Label {
+        let _tracing = dev_span!("begin_loop_block");
+
         let break_label = self.define_label();
         self.begin_block(CodeBlock::Loop(LoopBlock {
             is_script: false,
@@ -2377,6 +2405,8 @@ impl Generator {
             if !block.is_script {
                 self.mark_label(break_label);
             }
+        } else {
+            unreachable!()
         }
     }
 
@@ -2414,6 +2444,8 @@ impl Generator {
             if !block.is_script {
                 self.mark_label(break_label);
             }
+        } else {
+            unreachable!()
         }
     }
 
@@ -2469,6 +2501,8 @@ impl Generator {
                     if block.label_text == *label_text {
                         return true;
                     }
+                } else {
+                    unreachable!()
                 }
             } else {
                 break;
@@ -2542,6 +2576,9 @@ impl Generator {
     fn create_label(&mut self, label: Option<Label>) -> Box<Expr> {
         if let Some(label) = label {
             if label.0 > 0 {
+                #[cfg(debug_assertions)]
+                debug!("create_label: label={:?}", label);
+
                 if self.label_exprs.is_none() {
                     self.label_exprs = Some(Default::default());
                 }
@@ -3079,13 +3116,20 @@ impl Generator {
                     CodeBlock::Exception(_) => {
                         if block_action == BlockAction::Open {
                             self.exception_block_stack
+                                .get_or_insert_with(Default::default)
                                 .extend(self.current_exception_block.clone());
 
+                            // https://github.com/swc-project/swc/issues/5913
+                            if self.stmts.is_none() {
+                                self.stmts = Some(Default::default());
+                            }
+
                             #[cfg(debug_assertions)]
                             debug!("Current exception block: open = Some({:?})", block);
                             self.current_exception_block = Some(block.clone());
                         } else if block_action == BlockAction::Close {
-                            self.current_exception_block = self.exception_block_stack.pop();
+                            self.current_exception_block =
+                                self.exception_block_stack.as_mut().unwrap().pop();
                             #[cfg(debug_assertions)]
                             debug!(
                                 "Current exception block: close = {:?}",

crates/swc_ecma_transforms_compat/tests/async-to-generator/issue-1892/exec.js

@@ -0,0 +1,39 @@
+function* gen() {
+    var firstTime = true;
+    outer:
+    while (true) {
+        yield 0;
+        try {
+            while (true) {
+                yield 1;
+                if (firstTime) {
+                    firstTime = false;
+                    yield 2;
+                    continue outer;
+                } else {
+                    yield 3;
+                    break;
+                }
+            }
+            yield 4;
+            break;
+        } finally {
+            yield 5;
+        }
+        yield 6;
+    }
+    yield 7;
+}
+
+const iter = gen();
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())
+console.log(iter.next())

crates/swc_ecma_transforms_compat/tests/async-to-generator/issue-5913/1/exec.js

@@ -0,0 +1,19 @@
+function* generator() {
+    try {
+        while (true) {
+            yield "foo";
+        }
+    } finally {
+        yield "bar";
+    }
+}
+
+function test() {
+    const gen = generator();
+    console.log(gen.next().value);
+    console.log(gen.next().value);
+    console.log(gen.next().value);
+    console.log(gen.next().value);
+}
+
+test();

crates/swc_ecma_transforms_compat/tests/async-to-generator/issue-5913/2/exec.js

@@ -0,0 +1,18 @@
+function* generator() {
+    try {
+        while (true) {
+            yield "foo";
+        }
+    } finally {
+    }
+}
+
+function test() {
+    const gen = generator();
+    console.log(gen.next().value);
+    console.log(gen.next().value);
+    console.log(gen.next().value);
+    console.log(gen.next().value);
+}
+
+test();