What

SemanticBuilder can now build without retaining every AST node. It defaults to a lightweight ancestor-stack storage that keeps only the live root..=current chain during traversal. Consumers that need random access to nodes after the build opt back in with .with_ast_nodes(true) (and .with_cfg(true) forces full storage automatically, since CFG construction needs per-node data).

This makes building AST nodes optional for pipelines that only consume Scoping: the oxc compiler pipeline, transform, minify, and define/inject all call into_scoping() and discard the nodes today, so building them was wasted work.

How

A new NodeStorage enum in oxc_semantic (node/storage.rs) with two backends:

• Full(AstNodes) — today's flat random-access storage, retained after the build.
• Ancestors { stack, len } — a Stack of the live ancestor chain, pushed on enter / popped on exit, serving the parent/ancestor queries the binder, class-table builder, and syntax checker need (they only ever look upward).

Both allocate NodeIds from the same monotonic counter, so Scoping is identical regardless of mode. Semantic::nodes() is empty in ancestor-stack mode; a new node_count field keeps Semantic::stats() accurate so with_stats reuse still pre-allocates correctly.

Redeclaration checks (the only build-time reads of an already-popped node)

Two redeclaration checks used to dereference a previously declared (already-popped) function node. Neither touches AstNodes any more, so both behave identically in either storage mode:

• check_function_redeclaration (Annex B.3.3) consults the async_or_generator_function_node_ids list recorded at bind time — landed separately on main in refactor(semantic): identify illegal function declarations without using AST nodes #22972 / perf(semantic): move cold function redeclaration handling into #[cold] function #22973, which this branch is now rebased on.
• check_redeclaration distinguishes a named function expression from a previous function declaration by comparing NodeIds: a function expression binds its own name in the scope it creates, so the name symbol's declaration node is that scope's node (symbol_declaration(id) == get_node_id(symbol_scope_id(id))). A previous function declaration is bound in the enclosing scope, so it doesn't match. No node kind is read.

Every other build-time node read resolves the current node, the enclosing function, an enclosing scope's node, or the enclosing class's node — all guaranteed to be on the live ancestor stack.

Consumers

• Stack (default): compiler pipeline, compressor, transformer, define/inject rebuilds, napi parser/transform, oxlint parse-check.
• Full (opt-in): mangler (+ minifier mangle path), formatter detect_code_removal, playground, coverage driver (via a new CompilerInterface::build_ast_nodes() hook), and semantic's own tests/examples. The linter already builds with with_cfg(true), so it gets full storage automatically.

Validation

• oxc_semantic, mangler, minifier, transformer, and codegen tests pass.
• Conformance: zero regressions — cargo coverage -- semantic leaves the snapshot failure-counts byte-identical (and it exercises check_redeclaration in full-node mode, so unchanged snapshots prove the NodeId comparison matches the original node read).
• clippy, rustdoc -D warnings, and cargo fmt clean.

Note

The win is build-local: into_scoping() already freed nodes before transform, so this trims the per-node AstNodes allocations/writes during each pipeline semantic build, not transform/codegen themselves.

🤖 This PR was authored with Claude Code.