fix(es/minifier): Restrict parameter inlining to undefined values only

This commit addresses the PR review feedback by:

1. **Fixing the USED_AS_REF check**: The previous implementation incorrectly
   checked for `USED_AS_REF` flag which is always set when a function is
   referenced (even when called). The fix changes this to check for `USED_AS_ARG`
   which specifically indicates the function is passed as an argument.

2. **Restricting inlining to undefined only**: To avoid being too aggressive
   and breaking existing tests, parameter inlining now only applies to `undefined`
   values (both implicit and explicit). This matches the original use case of
   eliminating optional callbacks and configuration parameters.

3. **Updating test outputs**: Test expectation files have been updated to reflect
   the correct behavior where undefined parameters are inlined as `let` declarations.

The optimization now correctly handles cases like:
```javascript
function complex(foo, fn) {
  return fn?.(foo);
}
complex("foo");  // fn is implicitly undefined
```

Which becomes:
```javascript
function complex(foo) {
  let fn;
  return fn?.(foo);
}
complex("foo");
```

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: github-actions[bot]

crates/swc_ecma_minifier/src/compress/optimize/params.rs

@@ -60,15 +60,22 @@ impl Optimizer<'_> {
             None => return,
         };
 
-        // Skip if function is exported or can't optimize
+        // Skip if function is exported, reassigned, or inlining is prevented
         if usage.flags.contains(VarUsageInfoFlags::EXPORTED)
             || usage.flags.contains(VarUsageInfoFlags::INLINE_PREVENTED)
-            || usage.flags.contains(VarUsageInfoFlags::USED_AS_REF)
             || usage.flags.contains(VarUsageInfoFlags::REASSIGNED)
         {
             return;
         }
 
+        // Skip if function is used as a reference/argument (not just called)
+        // Check if the function is used in ways other than being called directly
+        // USED_AS_ARG indicates the function is passed to another function, which means
+        // we don't have visibility into all call sites
+        if usage.flags.contains(VarUsageInfoFlags::USED_AS_ARG) {
+            return;
+        }
+
         // Get call site arguments
         let call_sites = match &usage.call_site_args {
             Some(sites) if !sites.is_empty() => sites,
@@ -153,10 +160,17 @@ impl Optimizer<'_> {
             }
 
             // If all call sites pass the same constant value, mark for inlining
+            // Currently, we only inline undefined values to match the original use case
+            // and avoid being too aggressive. This handles optional callbacks/parameters
+            // that are consistently omitted or explicitly undefined.
             if inlinable {
-                if let Some(Some(value)) = common_value {
-                    // Explicit value passed at all call sites
-                    params_to_inline.push((param_idx, value));
+                if let Some(Some(value)) = &common_value {
+                    // Check if the value is explicitly undefined
+                    if let Expr::Ident(id) = &**value {
+                        if id.ctxt == self.ctx.expr_ctx.unresolved_ctxt && id.sym == "undefined" {
+                            params_to_inline.push((param_idx, value.clone()));
+                        }
+                    }
                 } else if let Some(None) = common_value {
                     // All call sites have implicit undefined
                     let undefined_expr = Box::new(Expr::Ident(Ident::new(

crates/swc_ecma_minifier/tests/fixture/param_inline/basic/output.js

@@ -1,5 +1,6 @@
 // Basic parameter inlining - undefined parameter
-function complex(foo, fn) {
+function complex(foo) {
+    let fn;
     if (Math.random() > 0.5) throw Error();
     return fn?.(foo);
 }

crates/swc_ecma_minifier/tests/fixture/param_inline/mixed_params/output.js

@@ -1,5 +1,6 @@
 // Mixed parameters - some inlinable, some not
-function mixed(foo, callback, debug) {
+function mixed(foo, callback) {
+    let debug;
     if (debug) console.log("Debug:", foo);
     return callback(foo);
 }