feat: integrate try-finally semantics for using declarations

Signed-off-by: Abhinav Sharma <abhinavs1920bpl@gmail.com>

Author: abhinavs1920

core/engine/src/bytecompiler/statement/block.rs

@@ -1,20 +1,17 @@
 use crate::bytecompiler::ByteCompiler;
-#[cfg(not(feature = "experimental"))]
+#[cfg(feature = "experimental")]
+use crate::bytecompiler::jump_control::JumpControlInfoFlags;
 use boa_ast::statement::Block;
 #[cfg(feature = "experimental")]
 use boa_ast::{
     declaration::LexicalDeclaration,
     operations::{LexicallyScopedDeclaration, lexically_scoped_declarations},
-    statement::Block,
 };
 
 impl ByteCompiler<'_> {
     /// Compile a [`Block`] `boa_ast` node
     pub(crate) fn compile_block(&mut self, block: &Block, use_expr: bool) {
-        let scope = self.push_declarative_scope(block.scope());
-        self.block_declaration_instantiation(block);
-
-        // Count how many `using` bindings are in this block (statically known at compile time)
+        // Check if this block has `using` declarations
         #[cfg(feature = "experimental")]
         let using_count: u32 = lexically_scoped_declarations(block)
             .iter()
@@ -30,13 +27,100 @@ impl ByteCompiler<'_> {
             })
             .sum();
 
-        self.compile_statement_list(block.statement_list(), use_expr, true);
-
-        // Emit DisposeResources with the static count if there are any using declarations
         #[cfg(feature = "experimental")]
-        if using_count > 0 {
-            self.bytecode.emit_dispose_resources(using_count.into());
+        let has_using = using_count > 0;
+
+        #[cfg(not(feature = "experimental"))]
+        let has_using = false;
+
+        if has_using {
+            // Blocks with `using` declarations need try-finally semantics
+            // to ensure disposal happens on all exit paths (normal, exception, break, continue, return)
+            self.compile_block_with_disposal(
+                block,
+                use_expr,
+                #[cfg(feature = "experimental")]
+                using_count,
+            );
+        } else {
+            // Normal block compilation
+            self.compile_block_without_disposal(block, use_expr);
         }
+    }
+
+    /// Compile a block without disposal semantics (normal block)
+    fn compile_block_without_disposal(&mut self, block: &Block, use_expr: bool) {
+        let scope = self.push_declarative_scope(block.scope());
+        self.block_declaration_instantiation(block);
+        self.compile_statement_list(block.statement_list(), use_expr, true);
+        self.pop_declarative_scope(scope);
+    }
+
+    /// Compile a block with disposal semantics (block with `using` declarations)
+    ///
+    /// This wraps the block in try-finally semantics to ensure resources are disposed
+    /// on all exit paths: normal completion, exceptions, and early exits (break/continue/return).
+    #[cfg(feature = "experimental")]
+    fn compile_block_with_disposal(&mut self, block: &Block, use_expr: bool, using_count: u32) {
+        let scope = self.push_declarative_scope(block.scope());
+        self.block_declaration_instantiation(block);
+
+        // Allocate registers for finally control flow (same pattern as try-finally)
+        let finally_re_throw = self.register_allocator.alloc();
+        let finally_jump_index = self.register_allocator.alloc();
+
+        self.bytecode.emit_store_true(finally_re_throw.variable());
+        self.bytecode.emit_store_zero(finally_jump_index.variable());
+
+        // Push jump control info to handle break/continue/return through disposal
+        self.push_try_with_finally_control_info(&finally_re_throw, &finally_jump_index, use_expr);
+
+        // Push exception handler to catch any exceptions during block execution
+        let handler = self.push_handler();
+
+        // Compile the block body (this includes the `using` declarations)
+        self.compile_statement_list(block.statement_list(), use_expr, true);
+
+        // Normal exit: mark that we don't need to re-throw
+        self.bytecode.emit_store_false(finally_re_throw.variable());
+
+        let finally_jump = self.jump();
+
+        // Exception path: patch the handler
+        self.patch_handler(handler);
+
+        let catch_handler = self.push_handler();
+        let error = self.register_allocator.alloc();
+        self.bytecode.emit_exception(error.variable());
+        self.bytecode.emit_store_true(finally_re_throw.variable());
+
+        let no_throw = self.jump();
+        self.patch_handler(catch_handler);
+
+        self.patch_jump(no_throw);
+        self.patch_jump(finally_jump);
+
+        // Finally block: dispose resources
+        let finally_start = self.next_opcode_location();
+        self.jump_info
+            .last_mut()
+            .expect("there should be a jump control info")
+            .flags |= JumpControlInfoFlags::IN_FINALLY;
+
+        // Emit disposal logic
+        self.bytecode.emit_dispose_resources(using_count.into());
+
+        // Re-throw if there was an exception
+        let do_not_throw_exit = self.jump_if_false(&finally_re_throw);
+        self.bytecode.emit_throw(error.variable());
+        self.register_allocator.dealloc(error);
+        self.patch_jump(do_not_throw_exit);
+
+        // Pop jump control info (this handles break/continue/return via jump table)
+        self.pop_try_with_finally_control_info(finally_start);
+
+        self.register_allocator.dealloc(finally_re_throw);
+        self.register_allocator.dealloc(finally_jump_index);
 
         self.pop_declarative_scope(scope);
     }

core/engine/tests/disposal.rs

@@ -99,7 +99,6 @@ fn disposal_with_no_method() {
 }
 
 #[test]
-#[ignore = "Disposal on exception requires try-finally integration - will be implemented in next phase"]
 fn disposal_on_exception() {
     let mut context = Context::default();
 
@@ -186,3 +185,79 @@ fn multiple_resources_in_one_declaration() {
     // Should dispose in reverse order: b, then a
     assert_eq!(value.to_string(&mut context).unwrap(), "b,a");
 }
+
+#[test]
+fn disposal_on_return() {
+    let mut context = Context::default();
+
+    let result = context.eval(Source::from_bytes(
+        r"
+        let disposed = false;
+        function test() {
+            using x = {
+                [Symbol.dispose]() {
+                    disposed = true;
+                }
+            };
+            return 'early';
+        }
+        test();
+        // Return the disposed flag
+        disposed;
+        ",
+    ));
+
+    assert!(result.is_ok());
+    let value = result.unwrap();
+    assert_eq!(value, JsValue::from(true));
+}
+
+#[test]
+fn disposal_on_break() {
+    let mut context = Context::default();
+
+    let result = context.eval(Source::from_bytes(
+        r"
+        let disposed = false;
+        while (true) {
+            using x = {
+                [Symbol.dispose]() {
+                    disposed = true;
+                }
+            };
+            break;
+        }
+        disposed;
+        ",
+    ));
+
+    assert!(result.is_ok());
+    let value = result.unwrap();
+    assert_eq!(value, JsValue::from(true));
+}
+
+#[test]
+fn disposal_on_continue() {
+    let mut context = Context::default();
+
+    let result = context.eval(Source::from_bytes(
+        r"
+        let disposed = false;
+        let count = 0;
+        while (count < 2) {
+            count++;
+            using x = {
+                [Symbol.dispose]() {
+                    disposed = true;
+                }
+            };
+            continue;
+        }
+        disposed;
+        ",
+    ));
+
+    assert!(result.is_ok());
+    let value = result.unwrap();
+    assert_eq!(value, JsValue::from(true));
+}