fix: wrap function bodies with using declarations in try-finally for proper disposal on return

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

Author: abhinavs1920

core/engine/src/bytecompiler/function.rs

@@ -219,7 +219,113 @@ impl FunctionCompiler {
 
         {
             let mut compiler = compiler.position_guard(body);
-            compiler.compile_statement_list(body.statement_list(), false, false);
+            
+            // Check if the function body contains `using` declarations
+            #[cfg(feature = "experimental")]
+            let using_count: u32 = {
+                use boa_ast::{
+                    declaration::LexicalDeclaration,
+                    operations::{LexicallyScopedDeclaration, lexically_scoped_declarations},
+                };
+                
+                lexically_scoped_declarations(body.statement_list())
+                    .iter()
+                    .filter_map(|decl| {
+                        if let LexicallyScopedDeclaration::LexicalDeclaration(
+                            LexicalDeclaration::Using(u) | LexicalDeclaration::AwaitUsing(u),
+                        ) = decl
+                        {
+                            Some(u.as_ref().len() as u32)
+                        } else {
+                            None
+                        }
+                    })
+                    .sum()
+            };
+
+            #[cfg(not(feature = "experimental"))]
+            let using_count: u32 = 0;
+
+            if using_count > 0 {
+                #[cfg(feature = "experimental")]
+                {
+                    use crate::bytecompiler::jump_control::JumpControlInfoFlags;
+                    
+                    // Function body with `using` declarations needs try-finally semantics
+                    let finally_re_throw = compiler.register_allocator.alloc();
+                    let finally_jump_index = compiler.register_allocator.alloc();
+
+                    compiler.bytecode.emit_store_true(finally_re_throw.variable());
+                    compiler.bytecode.emit_store_zero(finally_jump_index.variable());
+
+                    // Push jump control info to handle break/continue/return through disposal
+                    compiler.push_try_with_finally_control_info(
+                        &finally_re_throw,
+                        &finally_jump_index,
+                        false,
+                    );
+
+                    // Push exception handler
+                    let handler = compiler.push_handler();
+
+                    // Compile the function body
+                    compiler.compile_statement_list(body.statement_list(), false, false);
+
+                    // Normal exit: mark that we don't need to re-throw
+                    compiler.bytecode.emit_store_false(finally_re_throw.variable());
+
+                    let finally_jump = compiler.jump();
+
+                    // Exception path: patch the handler
+                    compiler.patch_handler(handler);
+
+                    // Push a second handler for exceptions during exception handling
+                    let catch_handler = compiler.push_handler();
+                    let error = compiler.register_allocator.alloc();
+                    compiler.bytecode.emit_exception(error.variable());
+                    compiler.bytecode.emit_store_true(finally_re_throw.variable());
+
+                    let no_throw = compiler.jump();
+                    compiler.patch_handler(catch_handler);
+
+                    compiler.patch_jump(no_throw);
+                    compiler.patch_jump(finally_jump);
+
+                    // Finally block: dispose resources
+                    let finally_start = compiler.next_opcode_location();
+                    compiler.jump_info
+                        .last_mut()
+                        .expect("there should be a jump control info")
+                        .flags |= JumpControlInfoFlags::IN_FINALLY;
+
+                    // Save accumulator
+                    let value = compiler.register_allocator.alloc();
+                    compiler.bytecode
+                        .emit_set_register_from_accumulator(value.variable());
+
+                    // Emit disposal logic
+                    compiler.bytecode.emit_dispose_resources(using_count.into());
+
+                    // Restore accumulator
+                    compiler.bytecode.emit_set_accumulator(value.variable());
+                    compiler.register_allocator.dealloc(value);
+
+                    // Re-throw if there was an exception
+                    let do_not_throw_exit = compiler.jump_if_false(&finally_re_throw);
+                    compiler.bytecode.emit_throw(error.variable());
+                    compiler.register_allocator.dealloc(error);
+                    compiler.patch_jump(do_not_throw_exit);
+
+                    // Pop jump control info (this handles break/continue/return via jump table)
+                    compiler.pop_try_with_finally_control_info(finally_start);
+
+                    compiler.register_allocator.dealloc(finally_re_throw);
+                    compiler.register_allocator.dealloc(finally_jump_index);
+                }
+            } else {
+                // Normal function body compilation (no using declarations)
+                compiler.compile_statement_list(body.statement_list(), false, false);
+            }
         }
 
         compiler.params = parameters.clone();