refactor(transformer): add more debug assertions

crates/oxc_transformer/src/es2015/arrow_functions.rs

@@ -169,6 +169,7 @@ impl<'a> Traverse<'a> for ArrowFunctions<'a> {
             );
         }
         debug_assert!(self.this_var_stack.len() == 1);
+        debug_assert!(self.this_var_stack.last().is_none());
     }
 
     fn enter_function(&mut self, _func: &mut Function<'a>, _ctx: &mut TraverseCtx<'a>) {

crates/oxc_transformer/src/es2016/exponentiation_operator.rs

@@ -65,6 +65,7 @@ impl<'a> Traverse<'a> for ExponentiationOperator<'a> {
     #[inline] // Inline because it's no-op in release mode
     fn exit_program(&mut self, _program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) {
         debug_assert!(self.var_declarations.len() == 1);
+        debug_assert!(self.var_declarations.last().is_none());
     }
 
     fn enter_statements(

crates/oxc_transformer/src/es2020/nullish_coalescing_operator.rs

@@ -51,6 +51,7 @@ impl<'a> Traverse<'a> for NullishCoalescingOperator<'a> {
     #[inline] // Inline because it's no-op in release mode
     fn exit_program(&mut self, _program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) {
         debug_assert!(self.var_declarations.len() == 1);
+        debug_assert!(self.var_declarations.last().is_none());
     }
 
     fn enter_statements(

crates/oxc_transformer/src/es2021/logical_assignment_operators.rs

@@ -76,6 +76,7 @@ impl<'a> Traverse<'a> for LogicalAssignmentOperators<'a> {
     #[inline] // Inline because it's no-op in release mode
     fn exit_program(&mut self, _program: &mut Program<'a>, _ctx: &mut TraverseCtx<'a>) {
         debug_assert!(self.var_declarations.len() == 1);
+        debug_assert!(self.var_declarations.last().is_none());
     }
 
     fn enter_statements(

crates/oxc_transformer/src/helpers/stack.rs

@@ -85,6 +85,24 @@ impl<T> SparseStack<T> {
         }
     }
 
+    /// Get value of last entry on the stack.
+    #[inline]
+    pub fn last(&self) -> Option<&T> {
+        debug_assert!(!self.has_values.is_empty());
+        // SAFETY: `self.has_values` starts with 1 entry. Only `pop` removes entries from it,
+        // and it ensures `self.has_values` always has at least 1 entry.
+        let has_value = unsafe { *self.has_values.last().unwrap_unchecked() };
+        if has_value {
+            debug_assert!(!self.values.is_empty());
+            // SAFETY: Last `self.has_values` is only `true` if there's a corresponding value in `self.values`.
+            // This invariant is maintained in `push`, `pop`, `take_last`, `last_or_init`, and `last_mut_or_init`.
+            let value = unsafe { self.values.last().unwrap_unchecked() };
+            Some(value)
+        } else {
+            None
+        }
+    }
+
     /// Take value from last entry on the stack, leaving last entry empty.
     #[inline]
     pub fn take_last(&mut self) -> Option<T> {