refactor: encode using declaration count statically in DisposeResources opcode, removing runtime scope depth tracking

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

Author: abhinavs1920

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

@@ -11,26 +11,26 @@ impl ByteCompiler<'_> {
         let scope = self.push_declarative_scope(block.scope());
         self.block_declaration_instantiation(block);
 
-        // Check if this block has any using declarations
-        let has_using = lexically_scoped_declarations(block).iter().any(|decl| {
-            matches!(
-                decl,
-                LexicallyScopedDeclaration::LexicalDeclaration(
-                    LexicalDeclaration::Using(_) | LexicalDeclaration::AwaitUsing(_)
-                )
-            )
-        });
-
-        // Push disposal scope if this block has using declarations
-        if has_using {
-            self.bytecode.emit_push_disposal_scope();
-        }
+        // Count how many `using` bindings are in this block (statically known at compile time)
+        let using_count: u32 = lexically_scoped_declarations(block)
+            .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();
 
         self.compile_statement_list(block.statement_list(), use_expr, true);
 
-        // Dispose resources if this block has using declarations
-        if has_using {
-            self.bytecode.emit_dispose_resources();
+        // Emit DisposeResources with the static count if there are any using declarations
+        if using_count > 0 {
+            self.bytecode.emit_dispose_resources(using_count.into());
         }
 
         self.pop_declarative_scope(scope);

core/engine/src/vm/code_block.rs

@@ -892,10 +892,9 @@ impl CodeBlock {
             | Instruction::SuperCallSpread
             | Instruction::PopPrivateEnvironment
             | Instruction::Generator
-            | Instruction::AsyncGenerator
-            | Instruction::AddDisposableResource { .. }
-            | Instruction::DisposeResources
-            | Instruction::PushDisposalScope => String::new(),
+            | Instruction::AsyncGenerator => String::new(),
+            Instruction::AddDisposableResource { value } => format!("value: {value}"),
+            Instruction::DisposeResources { count } => format!("count: {count}"),
             Instruction::Reserved4
             | Instruction::Reserved5
             | Instruction::Reserved6
@@ -947,7 +946,8 @@ impl CodeBlock {
             | Instruction::Reserved52
             | Instruction::Reserved53
             | Instruction::Reserved54
-            | Instruction::Reserved55 => unreachable!("Reserved opcodes are unreachable"),
+            | Instruction::Reserved55
+            | Instruction::Reserved56 => unreachable!("Reserved opcodes are unreachable"),
         }
     }
 }

core/engine/src/vm/flowgraph/mod.rs

@@ -383,21 +383,9 @@ impl CodeBlock {
                     let label = format!("AddDisposableResource value: {value}");
                     graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                 }
-                Instruction::DisposeResources => {
-                    graph.add_node(
-                        previous_pc,
-                        NodeShape::None,
-                        "DisposeResources".into(),
-                        Color::None,
-                    );
-                }
-                Instruction::PushDisposalScope => {
-                    graph.add_node(
-                        previous_pc,
-                        NodeShape::None,
-                        "PushDisposalScope".into(),
-                        Color::None,
-                    );
+                Instruction::DisposeResources { count } => {
+                    let label = format!("DisposeResources count: {count}");
+                    graph.add_node(previous_pc, NodeShape::None, label.into(), Color::None);
                 }
                 Instruction::Reserved4
                 | Instruction::Reserved5

core/engine/src/vm/mod.rs

@@ -101,13 +101,9 @@ pub struct Vm {
     /// Stack of disposable resources for explicit resource management.
     ///
     /// Resources are added via `using` declarations and disposed in reverse order (LIFO)
-    /// when the scope exits. Each entry contains (`value`, `dispose_method`, `scope_depth`).
+    /// when the scope exits.
     pub(crate) disposal_stack: Vec<(JsValue, JsValue)>,
 
-    /// Tracks the disposal stack depth for each scope level.
-    /// When a scope exits, we dispose resources back to this depth.
-    pub(crate) disposal_scope_depths: Vec<usize>,
-
     #[cfg(feature = "trace")]
     pub(crate) trace: bool,
     #[cfg(feature = "trace")]
@@ -360,7 +356,6 @@ impl Vm {
             host_call_depth: 0,
             shadow_stack: ShadowStack::default(),
             disposal_stack: Vec::new(),
-            disposal_scope_depths: Vec::new(),
             #[cfg(feature = "trace")]
             trace: false,
             #[cfg(feature = "trace")]
@@ -620,21 +615,6 @@ impl Vm {
     pub(crate) fn pop_disposable_resource(&mut self) -> Option<(JsValue, JsValue)> {
         self.disposal_stack.pop()
     }
-
-    /// Mark the current disposal stack depth for a new scope.
-    pub(crate) fn push_disposal_scope(&mut self) {
-        self.disposal_scope_depths.push(self.disposal_stack.len());
-    }
-
-    /// Get the disposal stack depth for the current scope.
-    pub(crate) fn current_disposal_scope_depth(&self) -> usize {
-        self.disposal_scope_depths.last().copied().unwrap_or(0)
-    }
-
-    /// Pop the disposal scope depth marker.
-    pub(crate) fn pop_disposal_scope(&mut self) {
-        self.disposal_scope_depths.pop();
-    }
 }
 
 #[allow(clippy::print_stdout)]

core/engine/src/vm/opcode/disposal/dispose_resources.rs

@@ -1,43 +1,36 @@
-use crate::{Context, JsError, JsNativeError, JsResult, vm::opcode::Operation};
+use crate::{
+    Context, JsError, JsNativeError, JsResult,
+    vm::opcode::{IndexOperand, Operation},
+};
 
 /// `DisposeResources` implements the DisposeResources operation.
 ///
-/// This opcode disposes all resources in the current disposal stack.
+/// This opcode disposes the last `count` resources from the disposal stack.
+/// The count is statically determined by the bytecompiler.
 ///
 /// Operation:
 ///  - Stack: **=>**
 pub(crate) struct DisposeResources;
 
 impl DisposeResources {
-    pub(crate) fn operation((): (), context: &mut Context) -> JsResult<()> {
+    pub(crate) fn operation(count: IndexOperand, context: &mut Context) -> JsResult<()> {
+        let count = u32::from(count) as usize;
         let mut suppressed_error: Option<JsError> = None;
 
-        // Get the scope depth to know how many resources to dispose
-        let scope_depth = context.vm.current_disposal_scope_depth();
-
-        // Dispose resources in reverse order (LIFO) until we reach the scope depth
-        while context.vm.disposal_stack.len() > scope_depth {
+        // Dispose exactly `count` resources in reverse order (LIFO)
+        for _ in 0..count {
             if let Some((value, method)) = context.vm.pop_disposable_resource() {
-                // Call the dispose method
                 let result = method.call(&value, &[], context);
 
-                // If an error occurs, aggregate it
                 if let Err(err) = result {
                     suppressed_error = Some(match suppressed_error {
                         None => err,
-                        Some(previous) => {
-                            // Create a SuppressedError
-                            create_suppressed_error(err, &previous, context)
-                        }
+                        Some(previous) => create_suppressed_error(err, &previous, context),
                     });
                 }
             }
         }
 
-        // Pop the disposal scope depth marker
-        context.vm.pop_disposal_scope();
-
-        // If there were any errors, throw the aggregated error
         if let Some(err) = suppressed_error {
             return Err(err);
         }
@@ -62,7 +55,6 @@ fn create_suppressed_error(
     // TODO: Implement proper SuppressedError builtin in Phase 2
     let message = format!("An error was suppressed during disposal: {suppressed}");
 
-    // Attach the original error as a property
     // This is a temporary solution until SuppressedError is implemented
     JsNativeError::error().with_message(message).into()
 }

core/engine/src/vm/opcode/disposal/mod.rs

@@ -1,7 +1,5 @@
 mod add_disposable;
 mod dispose_resources;
-mod push_scope;
 
 pub(crate) use add_disposable::*;
 pub(crate) use dispose_resources::*;
-pub(crate) use push_scope::*;

core/engine/src/vm/opcode/disposal/push_scope.rs

@@ -2207,18 +2207,11 @@ generate_opcodes! {
     /// Dispose all resources in the current disposal stack.
     ///
     /// This opcode implements the DisposeResources abstract operation.
-    /// It calls all dispose methods in reverse order (LIFO).
+    /// It calls the last `count` dispose methods in reverse order (LIFO).
+    /// The count is statically determined by the bytecompiler.
     ///
     /// - Stack: **=>**
-    DisposeResources,
-
-    /// Push a new disposal scope.
-    ///
-    /// This marks the current disposal stack depth for a new scope.
-    /// When DisposeResources is called, it will dispose resources back to this depth.
-    ///
-    /// - Stack: **=>**
-    PushDisposalScope,
+    DisposeResources { count: IndexOperand },
     /// Reserved [`Opcode`].
     Reserved4 => Reserved,
     /// Reserved [`Opcode`].
@@ -2323,4 +2316,6 @@ generate_opcodes! {
     Reserved54 => Reserved,
     /// Reserved [`Opcode`].
     Reserved55 => Reserved,
+    /// Reserved [`Opcode`].
+    Reserved56 => Reserved,
 }