fix(semantic): add scope tracking for with statements (#14652)

Fixes #8365

## Summary

The `with` statement was not creating a scope in the semantic analysis, causing `is_global_reference` to incorrectly return `true` for references inside `with` blocks. This could lead to incorrect minification.

## Problem

According to the ECMAScript specification, `with` statements should create an Object Environment Record that extends the lexical environment. Without proper scope tracking:

- `is_global_reference()` incorrectly returns `true` for identifiers inside `with` blocks
- This can cause minification to incorrectly treat local references as global
- The scope tree doesn't accurately represent the program structure

## Solution

### Changes Made

1. **AST Definition** (`crates/oxc_ast/src/ast/js.rs`):
   - Added `#[scope]` attribute to `WithStatement` struct
   - Added `scope_id: Cell<Option<ScopeId>>` field

2. **Semantic Builder** (`crates/oxc_semantic/src/builder.rs`):
   - Modified `visit_with_statement` to call `enter_scope()` before visiting the body
   - Added `leave_scope()` call after visiting the body
   - Uses `ScopeFlags::empty()` similar to block statements

3. **Test Coverage** (`crates/oxc_semantic/tests/integration/scopes.rs`):
   - Added `test_with_statement` to verify scope creation
   - Tests both simple expressions and block statement bodies
   - Verifies proper scope tree structure

### Example

```javascript
const foo = {
  Object: class {
    constructor() { console.log('Constructor') }
  }
}
with (foo) {
  console.log(new Object()) // should print "Constructor"
}
```

Before this fix, `Object` inside the `with` block would be incorrectly identified as a global reference, potentially causing minification errors.

## Implementation Notes

While this implementation doesn't fully model the complex object environment semantics (where property lookups can dynamically affect identifier resolution at runtime), it ensures:

- References inside `with` blocks are no longer incorrectly marked as global
- The scope tree properly represents the lexical structure
- Provides a foundation for future improvements to object environment handling

## Testing

All existing tests pass, plus the new test verifies:
- `with` statements create scopes
- Scopes are properly nested in the scope tree
- Works correctly with both simple and block statement bodies

Author: Boshen

crates/oxc_ast/src/ast/js.rs

@@ -1384,12 +1384,15 @@ pub struct ReturnStatement<'a> {
 
 /// With Statement
 #[ast(visit)]
+#[scope]
 #[derive(Debug)]
 #[generate_derive(CloneIn, Dummy, TakeIn, GetSpan, GetSpanMut, ContentEq, ESTree)]
 pub struct WithStatement<'a> {
     pub span: Span,
     pub object: Expression<'a>,
+    #[scope(enter_before)]
     pub body: Statement<'a>,
+    pub scope_id: Cell<Option<ScopeId>>,
 }
 
 /// Switch Statement

crates/oxc_ast/src/generated/assert_layouts.rs

@@ -461,12 +461,13 @@ const _: () = {
     assert!(offset_of!(ReturnStatement, span) == 0);
     assert!(offset_of!(ReturnStatement, argument) == 8);
 
-    // Padding: 0 bytes
-    assert!(size_of::<WithStatement>() == 40);
+    // Padding: 4 bytes
+    assert!(size_of::<WithStatement>() == 48);
     assert!(align_of::<WithStatement>() == 8);
     assert!(offset_of!(WithStatement, span) == 0);
     assert!(offset_of!(WithStatement, object) == 8);
     assert!(offset_of!(WithStatement, body) == 24);
+    assert!(offset_of!(WithStatement, scope_id) == 40);
 
     // Padding: 4 bytes
     assert!(size_of::<SwitchStatement>() == 56);
@@ -2066,11 +2067,12 @@ const _: () = if cfg!(target_family = "wasm") || align_of::<u64>() == 8 {
     assert!(offset_of!(ReturnStatement, argument) == 8);
 
     // Padding: 0 bytes
-    assert!(size_of::<WithStatement>() == 24);
+    assert!(size_of::<WithStatement>() == 28);
     assert!(align_of::<WithStatement>() == 4);
     assert!(offset_of!(WithStatement, span) == 0);
     assert!(offset_of!(WithStatement, object) == 8);
     assert!(offset_of!(WithStatement, body) == 16);
+    assert!(offset_of!(WithStatement, scope_id) == 24);
 
     // Padding: 0 bytes
     assert!(size_of::<SwitchStatement>() == 36);

crates/oxc_ast/src/generated/ast_builder.rs

@@ -3742,6 +3742,28 @@ impl<'a> AstBuilder<'a> {
         Statement::WithStatement(self.alloc_with_statement(span, object, body))
     }
 
+    /// Build a [`Statement::WithStatement`] with `scope_id`.
+    ///
+    /// This node contains a [`WithStatement`] that will be stored in the memory arena.
+    ///
+    /// ## Parameters
+    /// * `span`: The [`Span`] covering this node
+    /// * `object`
+    /// * `body`
+    /// * `scope_id`
+    #[inline]
+    pub fn statement_with_with_scope_id(
+        self,
+        span: Span,
+        object: Expression<'a>,
+        body: Statement<'a>,
+        scope_id: ScopeId,
+    ) -> Statement<'a> {
+        Statement::WithStatement(
+            self.alloc_with_statement_with_scope_id(span, object, body, scope_id),
+        )
+    }
+
     /// Build a [`Directive`].
     ///
     /// ## Parameters
@@ -5047,7 +5069,7 @@ impl<'a> AstBuilder<'a> {
         object: Expression<'a>,
         body: Statement<'a>,
     ) -> WithStatement<'a> {
-        WithStatement { span, object, body }
+        WithStatement { span, object, body, scope_id: Default::default() }
     }
 
     /// Build a [`WithStatement`], and store it in the memory arena.
@@ -5069,6 +5091,48 @@ impl<'a> AstBuilder<'a> {
         Box::new_in(self.with_statement(span, object, body), self.allocator)
     }
 
+    /// Build a [`WithStatement`] with `scope_id`.
+    ///
+    /// If you want the built node to be allocated in the memory arena,
+    /// use [`AstBuilder::alloc_with_statement_with_scope_id`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: The [`Span`] covering this node
+    /// * `object`
+    /// * `body`
+    /// * `scope_id`
+    #[inline]
+    pub fn with_statement_with_scope_id(
+        self,
+        span: Span,
+        object: Expression<'a>,
+        body: Statement<'a>,
+        scope_id: ScopeId,
+    ) -> WithStatement<'a> {
+        WithStatement { span, object, body, scope_id: Cell::new(Some(scope_id)) }
+    }
+
+    /// Build a [`WithStatement`] with `scope_id`, and store it in the memory arena.
+    ///
+    /// Returns a [`Box`] containing the newly-allocated node.
+    /// If you want a stack-allocated node, use [`AstBuilder::with_statement_with_scope_id`] instead.
+    ///
+    /// ## Parameters
+    /// * `span`: The [`Span`] covering this node
+    /// * `object`
+    /// * `body`
+    /// * `scope_id`
+    #[inline]
+    pub fn alloc_with_statement_with_scope_id(
+        self,
+        span: Span,
+        object: Expression<'a>,
+        body: Statement<'a>,
+        scope_id: ScopeId,
+    ) -> Box<'a, WithStatement<'a>> {
+        Box::new_in(self.with_statement_with_scope_id(span, object, body, scope_id), self.allocator)
+    }
+
     /// Build a [`SwitchStatement`].
     ///
     /// If you want the built node to be allocated in the memory arena,

crates/oxc_ast/src/generated/derive_clone_in.rs

@@ -3201,6 +3201,7 @@ impl<'new_alloc> CloneIn<'new_alloc> for WithStatement<'_> {
             span: CloneIn::clone_in(&self.span, allocator),
             object: CloneIn::clone_in(&self.object, allocator),
             body: CloneIn::clone_in(&self.body, allocator),
+            scope_id: Default::default(),
         }
     }
 
@@ -3209,6 +3210,7 @@ impl<'new_alloc> CloneIn<'new_alloc> for WithStatement<'_> {
             span: CloneIn::clone_in_with_semantic_ids(&self.span, allocator),
             object: CloneIn::clone_in_with_semantic_ids(&self.object, allocator),
             body: CloneIn::clone_in_with_semantic_ids(&self.body, allocator),
+            scope_id: CloneIn::clone_in_with_semantic_ids(&self.scope_id, allocator),
         }
     }
 }

crates/oxc_ast/src/generated/derive_dummy.rs

@@ -855,6 +855,7 @@ impl<'a> Dummy<'a> for WithStatement<'a> {
             span: Dummy::dummy(allocator),
             object: Dummy::dummy(allocator),
             body: Dummy::dummy(allocator),
+            scope_id: Dummy::dummy(allocator),
         }
     }
 }

crates/oxc_ast/src/generated/get_id.rs

@@ -138,6 +138,25 @@ impl ForOfStatement<'_> {
     }
 }
 
+impl WithStatement<'_> {
+    /// Get [`ScopeId`] of [`WithStatement`].
+    ///
+    /// Only use this method on a post-semantic AST where [`ScopeId`]s are always defined.
+    ///
+    /// # Panics
+    /// Panics if `scope_id` is [`None`].
+    #[inline]
+    pub fn scope_id(&self) -> ScopeId {
+        self.scope_id.get().unwrap()
+    }
+
+    /// Set [`ScopeId`] of [`WithStatement`].
+    #[inline]
+    pub fn set_scope_id(&self, scope_id: ScopeId) {
+        self.scope_id.set(Some(scope_id));
+    }
+}
+
 impl SwitchStatement<'_> {
     /// Get [`ScopeId`] of [`SwitchStatement`].
     ///

crates/oxc_ast_visit/src/generated/visit.rs

@@ -2256,7 +2256,9 @@ pub mod walk {
         visitor.enter_node(kind);
         visitor.visit_span(&it.span);
         visitor.visit_expression(&it.object);
+        visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
         visitor.visit_statement(&it.body);
+        visitor.leave_scope();
         visitor.leave_node(kind);
     }
 

crates/oxc_ast_visit/src/generated/visit_mut.rs

@@ -2314,7 +2314,9 @@ pub mod walk_mut {
         visitor.enter_node(kind);
         visitor.visit_span(&mut it.span);
         visitor.visit_expression(&mut it.object);
+        visitor.enter_scope(ScopeFlags::empty(), &it.scope_id);
         visitor.visit_statement(&mut it.body);
+        visitor.leave_scope();
         visitor.leave_node(kind);
     }
 

crates/oxc_semantic/src/builder.rs

@@ -1678,6 +1678,7 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
         /* cfg */
 
         self.visit_expression(&stmt.object);
+        self.enter_scope(ScopeFlags::empty(), &stmt.scope_id);
 
         /* cfg - body basic block */
         #[cfg(feature = "cfg")]
@@ -1697,6 +1698,7 @@ impl<'a> Visit<'a> for SemanticBuilder<'a> {
         });
         /* cfg */
 
+        self.leave_scope();
         self.leave_node(kind);
     }
 

crates/oxc_semantic/tests/integration/scopes.rs

@@ -284,3 +284,54 @@ fn test_eval() {
         assert!(!semantic.scoping().root_scope_flags().contains_direct_eval());
     }
 }
+
+#[test]
+fn test_with_statement() {
+    // Test that with statement creates a scope
+    let tester = SemanticTester::js(
+        "
+        const foo = { x: 1 };
+        with (foo) x;
+        ",
+    )
+    .with_module(false)
+    .with_scope_tree_child_ids(true);
+
+    let semantic = tester.build();
+    let scopes = semantic.scoping();
+
+    // Should have root scope + with statement scope
+    assert_eq!(scopes.scopes_len(), 2, "with statement should create a scope");
+
+    // Verify scope tree structure
+    let root_id = semantic.scoping().root_scope_id();
+    let child_ids = semantic.scoping().get_scope_child_ids(root_id);
+    assert_eq!(child_ids.len(), 1, "with statement scope should be a child of root scope");
+
+    // Verify the child scope is for the with statement
+    let with_scope_id = child_ids[0];
+    let with_scope_node_id = scopes.get_node_id(with_scope_id);
+    let with_node = semantic.nodes().get_node(with_scope_node_id);
+    assert!(
+        matches!(with_node.kind(), AstKind::WithStatement(_)),
+        "Child scope should be associated with WithStatement"
+    );
+
+    // Test with block statement as body
+    let tester2 = SemanticTester::js(
+        "
+        const foo = { x: 1 };
+        with (foo) {
+            const y = 2;
+        }
+        ",
+    )
+    .with_module(false)
+    .with_scope_tree_child_ids(true);
+
+    let semantic2 = tester2.build();
+    let scopes2 = semantic2.scoping();
+
+    // Should have root scope + with statement scope + block statement scope
+    assert_eq!(scopes2.scopes_len(), 3, "with statement and its block should create scopes");
+}