fix(minifier): respect @__PURE__ annotations when removing unused variable declarations

Summary

Fixes #22255

When an unused variable declaration has a @__PURE__-annotated call expression as its initializer (e.g., a pure IIFE), the minifier incorrectly preserves the initializer body as a side-effectful expression statement instead of removing it entirely.

The Bug

Given this input:

// With CompressOptions::smallest() (unused: Remove)
var x = /* @__PURE__ */ (() => {
  return oprt(1);
})();

Before this fix (incorrect output):

oprt(1);

After this fix (correct output):

// (empty — fully removed)

Root Cause

In handle_variable_declaration (minimize_statements.rs), when an unused declarator is removed, its initializer is checked via init.may_have_side_effects(ctx) to decide whether to keep it as an expression statement:

if Self::should_remove_unused_declarator(&decl, ctx) {
    ctx.state.changed = true;
    if let Some(init) = decl.init.take()
        && init.may_have_side_effects(ctx)  // ← the issue
    {
        result.push(ctx.ast.statement_expression(init.span(), init));
    }
}

While CallExpression::may_have_side_effects does respect @__PURE__ annotations for direct calls with no arguments, this approach misses the deeper expression-level optimizations that remove_unused_expression provides — such as handling pure IIFEs, stripping pure calls while preserving their side-effectful arguments, and simplifying nested expressions.

The real issue surfaces when:

1. The initializer is a @__PURE__ IIFE like /* @__PURE__ */ (() => { return oprt(1) })()
2. may_have_side_effects correctly returns false for the outer call...
3. ...BUT during the iterative peephole process, the IIFE body gets inlined first (stripping the pure annotation), turning it into just oprt(1) which IS side-effectful

By using remove_unused_expression instead, we leverage the full expression simplification pipeline that properly handles these cases.

Fix

Replace init.may_have_side_effects(ctx) with !Self::remove_unused_expression(&mut init, ctx) in handle_variable_declaration. This delegates to the same expression removal logic used everywhere else in the minifier, which properly handles:

• @__PURE__ annotated calls → fully removed
• @__PURE__ annotated IIFEs → fully removed
• Pure calls with side-effectful arguments → arguments preserved, call removed
• @__NO_SIDE_EFFECTS__ functions → calls removed
• Regular side-effectful expressions → preserved (no behavior change)

Test Cases Added

// All fully removed (unused + pure):
test_options("var x = /* @__PURE__ */ foo()", "", &options);
test_options("var x = /* @__PURE__ */ new Foo()", "", &options);
test_options("var x = /* @__PURE__ */ (() => { return foo() })()", "", &options);
test_options("var x = /* @__PURE__ */ (() => { return oprt(1) })()", "", &options);
test_options("var x = /* @__PURE__ */ (function() { return foo() })()", "", &options);

// Side-effectful arguments preserved:
test_options("var x = /* @__PURE__ */ foo(a)", "a", &options);
test_options("var x = /* @__PURE__ */ foo(bar())", "bar()", &options);

Impact on Downstream (Rolldown)

This bug was discovered while investigating a tree-shaking issue in Rolldown. Rolldown uses the Oxc compressor as a pre-processing step before its own tree-shaking pass. When the compressor incorrectly preserves oprt(1) as a top-level statement, Rolldown's AST scanner treats it as a side-effectful statement, causing the entire module and its dependencies to be included in the final bundle even when unused.

AI Disclosure

AI tools were used to assist with code review and identifying the missing guards in is_in_unused_variable_declarator. All changes have been reviewed, tested, and verified by the contributor.