fix(minifier): scope rest parameter eval checks

Author: labor0-bot[bot]

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

@@ -2378,6 +2378,8 @@ impl VisitMut for Optimizer<'_> {
         n.decorators.visit_mut_with(self);
 
         let old_in_asm = self.ctx.bit_ctx.contains(BitCtx::InAsm);
+        let function_is_strict =
+            self.ctx.expr_ctx.in_strict || rest_params::has_use_strict_directive(n);
 
         {
             let ctx = self.function_like_ctx(n.ctxt);
@@ -2420,7 +2422,8 @@ impl VisitMut for Optimizer<'_> {
         }
 
         {
-            self.with_ctx(self.ctx.clone()).drop_unused_rest_params(n);
+            self.with_ctx(self.ctx.clone())
+                .drop_unused_rest_params(n, function_is_strict);
         }
 
         self.ctx.bit_ctx.set(BitCtx::InAsm, old_in_asm);

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

@@ -1,22 +1,37 @@
 use swc_ecma_ast::*;
 use swc_ecma_visit::{Visit, VisitWith};
 
-use super::{Optimizer, ProgramData, ScopeData, VarUsageInfoFlags};
+use super::{Optimizer, ProgramData, VarUsageInfoFlags};
+
+/// Returns true if a function body has a strict-mode directive.
+pub(super) fn has_use_strict_directive(f: &Function) -> bool {
+    f.body.as_ref().is_some_and(|body| {
+        body.stmts
+            .iter()
+            .take_while(|stmt| {
+                matches!(stmt, Stmt::Expr(ExprStmt { expr, .. }) if matches!(&**expr, Expr::Lit(Lit::Str(..))))
+            })
+            .any(|stmt| {
+                matches!(stmt,
+                    Stmt::Expr(ExprStmt {
+                        expr,
+                        ..
+                    }) if matches!(
+                        &**expr,
+                        Expr::Lit(Lit::Str(Str { raw: Some(raw), .. }))
+                            if raw == "\"use strict\"" || raw == "'use strict'"
+                    )
+                )
+            })
+    })
+}
 
 /// Returns true if a function body reads its implicit `arguments` object.
 ///
 /// A lexical `arguments` declaration has a distinct syntax context, while a
 /// `var arguments` declaration aliases the implicit arguments object unless it
 /// belongs to a nested arrow function.
 fn uses_implicit_arguments(f: &Function, data: &ProgramData) -> bool {
-    // A direct eval can read `arguments` without a corresponding identifier node.
-    if data
-        .get_scope(f.ctxt)
-        .is_some_and(|scope| scope.contains(ScopeData::HAS_EVAL_CALL))
-    {
-        return true;
-    }
-
     struct ArrowVarFinder {
         ids: Vec<Id>,
     }
@@ -92,6 +107,21 @@ fn uses_implicit_arguments(f: &Function, data: &ProgramData) -> bool {
             self.shadowed_arguments.truncate(shadowed_len);
         }
 
+        fn visit_call_expr(&mut self, call: &CallExpr) {
+            // Direct eval can read the enclosing implicit `arguments` object without a
+            // corresponding identifier node. Nested ordinary functions and constructors
+            // are skipped above, while arrows share the enclosing lexical scope.
+            if matches!(
+                &call.callee,
+                Callee::Expr(expr) if matches!(&**expr, Expr::Ident(Ident { sym, .. }) if *sym == *"eval")
+            ) && self.shadowed_arguments.is_empty()
+            {
+                self.found = true;
+            }
+
+            call.visit_children_with(self);
+        }
+
         fn visit_ident(&mut self, ident: &Ident) {
             if ident.sym == "arguments"
                 && !self.shadowed_arguments.contains(&ident.to_id())
@@ -130,7 +160,7 @@ impl Optimizer<'_> {
     ///     console.log(a);
     /// }
     /// ```
-    pub(super) fn drop_unused_rest_params(&mut self, f: &mut Function) {
+    pub(super) fn drop_unused_rest_params(&mut self, f: &mut Function, in_strict: bool) {
         if !self.options.arguments && !self.options.unused {
             return;
         }
@@ -161,7 +191,7 @@ impl Optimizer<'_> {
         // In that case, `arguments` becomes mapped to the remaining parameters, which
         // changes observable behavior when the function uses `arguments`.
         let can_make_arguments_mapped = f.params.len() > 1
-            && !self.ctx.expr_ctx.in_strict
+            && !in_strict
             && f.params[..f.params.len() - 1].iter().all(|param| {
                 matches!(
                     &param.pat,

crates/swc_ecma_minifier/tests/fixture/issues/12211/function-strict-context/expected.stdout

@@ -0,0 +1 @@
+original

crates/swc_ecma_minifier/tests/fixture/issues/12211/function-strict-context/input.js

@@ -0,0 +1,7 @@
+function f(value, ...rest) {
+    "use strict";
+    value = "changed";
+    return arguments[0];
+}
+
+console.log(f("original"));

crates/swc_ecma_minifier/tests/fixture/issues/12211/function-strict-context/output.js

@@ -0,0 +1,5 @@
+function f(value) {
+    "use strict";
+    return arguments[0];
+}
+console.log(f("original"));

crates/swc_ecma_minifier/tests/fixture/issues/12211/nested-function-eval/expected.stdout

@@ -0,0 +1 @@
+inner

crates/swc_ecma_minifier/tests/fixture/issues/12211/nested-function-eval/input.js

@@ -0,0 +1,7 @@
+function f(value, ...rest) {
+    return function g() {
+        return eval("arguments[0]");
+    };
+}
+
+console.log(f("outer")("inner"));

crates/swc_ecma_minifier/tests/fixture/issues/12211/nested-function-eval/output.js

@@ -0,0 +1,6 @@
+function f(value) {
+    return function g() {
+        return eval("arguments[0]");
+    };
+}
+console.log(f("outer")("inner"));