fix: formatting and lint issues

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

Author: abhinavs1920

core/engine/src/bytecompiler/mod.rs

@@ -2258,10 +2258,10 @@ impl<'ctx> ByteCompiler<'ctx> {
                             } else {
                                 self.bytecode.emit_store_undefined(value.variable());
                             }
-                            
+
                             // Add resource to disposal stack
                             self.bytecode.emit_add_disposable_resource(value.variable());
-                            
+
                             self.emit_binding(BindingOpcode::InitLexical, ident, &value);
                             self.register_allocator.dealloc(value);
                         }
@@ -2273,10 +2273,10 @@ impl<'ctx> ByteCompiler<'ctx> {
                             } else {
                                 self.bytecode.emit_store_undefined(value.variable());
                             }
-                            
+
                             // Add resource to disposal stack
                             self.bytecode.emit_add_disposable_resource(value.variable());
-                            
+
                             self.compile_declaration_pattern(
                                 pattern,
                                 BindingOpcode::InitLexical,

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

@@ -10,29 +10,29 @@ impl ByteCompiler<'_> {
     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);
-        
+
         // Check if this block has any using declarations
-        let has_using = lexically_scoped_declarations(block)
-            .iter()
-            .any(|decl| matches!(
+        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();
         }
-        
+
         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();
         }
-        
+
         self.pop_declarative_scope(scope);
     }
 }

core/engine/src/vm/code_block.rs

@@ -892,12 +892,10 @@ impl CodeBlock {
             | Instruction::SuperCallSpread
             | Instruction::PopPrivateEnvironment
             | Instruction::Generator
-            | Instruction::AsyncGenerator => String::new(),
-            Instruction::AddDisposableResource { value } => {
-                format!("value: {value}")
-            }
-            Instruction::DisposeResources => String::new(),
-            Instruction::PushDisposalScope => String::new(),
+            | Instruction::AsyncGenerator
+            | Instruction::AddDisposableResource { .. }
+            | Instruction::DisposeResources
+            | Instruction::PushDisposalScope => String::new(),
             Instruction::Reserved4
             | Instruction::Reserved5
             | Instruction::Reserved6

core/engine/src/vm/mod.rs

@@ -101,9 +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. Each entry contains (`value`, `dispose_method`, `scope_depth`).
     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>,
@@ -620,17 +620,17 @@ 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();

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

@@ -1,6 +1,6 @@
 use crate::{
-    vm::opcode::{Operation, RegisterOperand},
     Context, JsResult,
+    vm::opcode::{Operation, RegisterOperand},
 };
 
 /// `AddDisposableResource` implements the AddDisposableResource operation.
@@ -32,7 +32,9 @@ impl AddDisposableResource {
         };
 
         // Add to disposal stack
-        context.vm.push_disposable_resource(value, dispose_method.into());
+        context
+            .vm
+            .push_disposable_resource(value, dispose_method.into());
 
         Ok(())
     }

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

@@ -1,7 +1,4 @@
-use crate::{
-    vm::opcode::Operation,
-    Context, JsError, JsNativeError, JsResult,
-};
+use crate::{Context, JsError, JsNativeError, JsResult, vm::opcode::Operation};
 
 /// `DisposeResources` implements the DisposeResources operation.
 ///
@@ -14,7 +11,7 @@ pub(crate) struct DisposeResources;
 impl DisposeResources {
     pub(crate) fn operation((): (), context: &mut Context) -> JsResult<()> {
         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();
 
@@ -30,13 +27,13 @@ impl DisposeResources {
                         None => err,
                         Some(previous) => {
                             // Create a SuppressedError
-                            create_suppressed_error(err, previous, context)
+                            create_suppressed_error(err, &previous, context)
                         }
                     });
                 }
             }
         }
-        
+
         // Pop the disposal scope depth marker
         context.vm.pop_disposal_scope();
 
@@ -56,19 +53,16 @@ impl Operation for DisposeResources {
 }
 
 /// Helper function to create a SuppressedError
-fn create_suppressed_error(_error: JsError, suppressed: JsError, _context: &mut Context) -> JsError {
+fn create_suppressed_error(
+    _error: JsError,
+    suppressed: &JsError,
+    _context: &mut Context,
+) -> JsError {
     // For now, we'll create a simple error that contains both errors
     // TODO: Implement proper SuppressedError builtin in Phase 2
-    let message = format!(
-        "An error was suppressed during disposal: {}",
-        suppressed
-    );
-    
-    let err = JsNativeError::error()
-        .with_message(message)
-        .into();
-    
+    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
-    err
+    JsNativeError::error().with_message(message).into()
 }

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

@@ -1,7 +1,4 @@
-use crate::{
-    vm::opcode::Operation,
-    Context, JsResult,
-};
+use crate::{Context, vm::opcode::Operation};
 
 /// `PushDisposalScope` marks the current disposal stack depth for a new scope.
 ///
@@ -12,9 +9,8 @@ use crate::{
 pub(crate) struct PushDisposalScope;
 
 impl PushDisposalScope {
-    pub(crate) fn operation((): (), context: &mut Context) -> JsResult<()> {
+    pub(crate) fn operation((): (), context: &mut Context) {
         context.vm.push_disposal_scope();
-        Ok(())
     }
 }
 

core/engine/src/vm/opcode/global.rs

@@ -1,6 +1,6 @@
 use crate::{
-    vm::opcode::{Operation, RegisterOperand, IndexOperand},
     Context, JsResult,
+    vm::opcode::{IndexOperand, Operation, RegisterOperand},
 };
 
 /// `HasRestrictedGlobalProperty` implements the Opcode Operation for `Opcode::HasRestrictedGlobalProperty`
@@ -101,16 +101,13 @@ impl CreateGlobalFunctionBinding {
         let name = code_block.constant_string(name_index.into());
         let value = context.vm.get_register(src.into()).clone();
         let configurable = u32::from(configurable) != 0;
-        
+
         // Convert JsValue to JsObject
         let function = value
             .as_object()
-            .ok_or_else(|| {
-                crate::JsNativeError::typ()
-                    .with_message("value is not an object")
-            })?
+            .ok_or_else(|| crate::JsNativeError::typ().with_message("value is not an object"))?
             .clone();
-        
+
         context.create_global_function_binding(name, function, configurable)?;
         Ok(())
     }

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

@@ -2202,7 +2202,7 @@ generate_opcodes! {
     ///
     /// - Registers:
     ///   - Input: value
-    AddDisposableResource { value: RegisterOperand },
+    AddDisposableResource { #[allow(dead_code)] value: RegisterOperand },
 
     /// Dispose all resources in the current disposal stack.
     ///
@@ -2211,7 +2211,7 @@ generate_opcodes! {
     ///
     /// - Stack: **=>**
     DisposeResources,
-    
+
     /// Push a new disposal scope.
     ///
     /// This marks the current disposal stack depth for a new scope.