feat(minifier): add pure to side-effect free global constructor during DCE (oxc-project#11270)

So that codegen can print /* #__PURE__# */ during codegen.

This mimics esbuild evanw/esbuild@7918716

closes ENG-48

Author: Boshen

crates/oxc_minifier/src/peephole/normalize.rs

@@ -1,5 +1,9 @@
 use oxc_allocator::{TakeIn, Vec};
 use oxc_ast::ast::*;
+use oxc_ecmascript::{
+    constant_evaluation::{DetermineValueType, ValueType},
+    side_effects::MayHaveSideEffects,
+};
 use oxc_semantic::IsGlobalReference;
 use oxc_span::GetSpan;
 use oxc_syntax::scope::ScopeFlags;
@@ -25,6 +29,7 @@ pub struct NormalizeOptions {
 /// * convert `NaN` to `f64::NaN`
 /// * convert `var x; void x` to `void 0`
 /// * convert `undefined` to `void 0`
+/// * apply `pure` to side-effect free global constructors (e.g. `new WeakMap()`)
 ///
 /// Also
 ///
@@ -94,11 +99,11 @@ impl<'a> Traverse<'a> for Normalize {
     }
 
     fn exit_call_expression(&mut self, e: &mut CallExpression<'a>, ctx: &mut TraverseCtx<'a>) {
-        Self::set_no_side_effects(&mut e.pure, &e.callee, ctx);
+        Self::set_no_side_effects_to_call_expr(e, ctx);
     }
 
     fn exit_new_expression(&mut self, e: &mut NewExpression<'a>, ctx: &mut TraverseCtx<'a>) {
-        Self::set_no_side_effects(&mut e.pure, &e.callee, ctx);
+        Self::set_pure_or_no_side_effects_to_new_expr(e, ctx);
     }
 }
 
@@ -243,19 +248,82 @@ impl<'a> Normalize {
         e.argument = ctx.ast.expression_numeric_literal(ident.span, 0.0, None, NumberBase::Decimal);
     }
 
-    fn set_no_side_effects(pure: &mut bool, callee: &Expression<'a>, ctx: &TraverseCtx<'a>) {
-        if !*pure {
-            if let Some(ident) = callee.get_identifier_reference() {
-                if let Some(symbol_id) =
-                    ctx.scoping().get_reference(ident.reference_id()).symbol_id()
-                {
-                    if ctx.scoping().no_side_effects().contains(&symbol_id) {
-                        *pure = true;
-                    }
-                }
+    fn set_no_side_effects_to_call_expr(call_expr: &mut CallExpression<'a>, ctx: &TraverseCtx<'a>) {
+        if call_expr.pure {
+            return;
+        }
+        let Some(ident) = call_expr.callee.get_identifier_reference() else {
+            return;
+        };
+        if let Some(symbol_id) = ctx.scoping().get_reference(ident.reference_id()).symbol_id() {
+            // Apply `/* #__NO_SIDE_EFFECTS__ */`
+            if ctx.scoping().no_side_effects().contains(&symbol_id) {
+                call_expr.pure = true;
             }
         }
     }
+
+    fn set_pure_or_no_side_effects_to_new_expr(
+        new_expr: &mut NewExpression<'a>,
+        ctx: &TraverseCtx<'a>,
+    ) {
+        if new_expr.pure {
+            return;
+        }
+        let Some(ident) = new_expr.callee.get_identifier_reference() else {
+            return;
+        };
+        if let Some(symbol_id) = ctx.scoping().get_reference(ident.reference_id()).symbol_id() {
+            // Apply `/* #__NO_SIDE_EFFECTS__ */`
+            if ctx.scoping().no_side_effects().contains(&symbol_id) {
+                new_expr.pure = true;
+            }
+            return;
+        }
+        // callee is a global reference.
+        let ctx = Ctx(ctx);
+        let len = new_expr.arguments.len();
+        if match ident.name.as_str() {
+            "WeakSet" | "WeakMap" if ctx.is_global_reference(ident) => match len {
+                0 => true,
+                1 => match new_expr.arguments[0].as_expression() {
+                    Some(Expression::NullLiteral(_)) => true,
+                    Some(Expression::ArrayExpression(e)) => e.elements.is_empty(),
+                    Some(e) if ctx.is_expression_undefined(e) => true,
+                    _ => false,
+                },
+                _ => false,
+            },
+            "Date" if ctx.is_global_reference(ident) => match len {
+                0 => true,
+                1 => {
+                    let Some(arg) = new_expr.arguments[0].as_expression() else { return };
+                    let ty = arg.value_type(&ctx);
+                    matches!(
+                        ty,
+                        ValueType::Null
+                            | ValueType::Undefined
+                            | ValueType::Boolean
+                            | ValueType::Number
+                            | ValueType::String
+                    ) && !arg.may_have_side_effects(&ctx)
+                }
+                _ => false,
+            },
+            "Set" | "Map" if ctx.is_global_reference(ident) => match len {
+                0 => true,
+                1 => match new_expr.arguments[0].as_expression() {
+                    Some(Expression::NullLiteral(_)) => true,
+                    Some(e) if ctx.is_expression_undefined(e) => true,
+                    _ => false,
+                },
+                _ => false,
+            },
+            _ => false,
+        } {
+            new_expr.pure = true;
+        }
+    }
 }
 
 #[cfg(test)]

crates/oxc_minifier/src/peephole/remove_unused_expression.rs

@@ -2,11 +2,7 @@ use std::iter;
 
 use oxc_allocator::{TakeIn, Vec};
 use oxc_ast::ast::*;
-use oxc_ecmascript::{
-    ToPrimitive,
-    constant_evaluation::{DetermineValueType, ValueType},
-    side_effects::MayHaveSideEffects,
-};
+use oxc_ecmascript::{ToPrimitive, side_effects::MayHaveSideEffects};
 use oxc_span::GetSpan;
 use oxc_syntax::es_target::ESTarget;
 
@@ -247,64 +243,20 @@ impl<'a> PeepholeOptimizations {
         ctx: Ctx<'a, '_>,
     ) -> bool {
         let Expression::NewExpression(new_expr) = e else { return false };
-
-        if new_expr.pure {
-            let mut exprs =
-                self.fold_arguments_into_needed_expressions(&mut new_expr.arguments, state, ctx);
-            if exprs.is_empty() {
-                return true;
-            } else if exprs.len() == 1 {
-                *e = exprs.pop().unwrap();
-                state.changed = true;
-                return false;
-            }
-            *e = ctx.ast.expression_sequence(new_expr.span, exprs);
-            state.changed = true;
+        if !new_expr.pure {
             return false;
         }
-
-        let Expression::Identifier(ident) = &new_expr.callee else { return false };
-        let len = new_expr.arguments.len();
-        if match ident.name.as_str() {
-            "WeakSet" | "WeakMap" if ctx.is_global_reference(ident) => match len {
-                0 => true,
-                1 => match new_expr.arguments[0].as_expression() {
-                    Some(Expression::NullLiteral(_)) => true,
-                    Some(Expression::ArrayExpression(e)) => e.elements.is_empty(),
-                    Some(e) if ctx.is_expression_undefined(e) => true,
-                    _ => false,
-                },
-                _ => false,
-            },
-            "Date" if ctx.is_global_reference(ident) => match len {
-                0 => true,
-                1 => {
-                    let Some(arg) = new_expr.arguments[0].as_expression() else { return false };
-                    let ty = arg.value_type(&ctx);
-                    matches!(
-                        ty,
-                        ValueType::Null
-                            | ValueType::Undefined
-                            | ValueType::Boolean
-                            | ValueType::Number
-                            | ValueType::String
-                    ) && !arg.may_have_side_effects(&ctx)
-                }
-                _ => false,
-            },
-            "Set" | "Map" if ctx.is_global_reference(ident) => match len {
-                0 => true,
-                1 => match new_expr.arguments[0].as_expression() {
-                    Some(Expression::NullLiteral(_)) => true,
-                    Some(e) if ctx.is_expression_undefined(e) => true,
-                    _ => false,
-                },
-                _ => false,
-            },
-            _ => false,
-        } {
+        let mut exprs =
+            self.fold_arguments_into_needed_expressions(&mut new_expr.arguments, state, ctx);
+        if exprs.is_empty() {
             return true;
+        } else if exprs.len() == 1 {
+            *e = exprs.pop().unwrap();
+            state.changed = true;
+            return false;
         }
+        *e = ctx.ast.expression_sequence(new_expr.span, exprs);
+        state.changed = true;
         false
     }
 

crates/oxc_minifier/tests/peephole/dead_code_elimination.rs

@@ -175,6 +175,14 @@ fn dce_var_hoisting() {
     );
 }
 
+#[test]
+fn pure_comment_for_pure_global_constructors() {
+    test("var x = new WeakSet", "var x = /* @__PURE__ */ new WeakSet();\n");
+    test("var x = new WeakSet(null)", "var x = /* @__PURE__ */ new WeakSet(null);\n");
+    test("var x = new WeakSet(undefined)", "var x = /* @__PURE__ */ new WeakSet(void 0);\n");
+    test("var x = new WeakSet([])", "var x = /* @__PURE__ */ new WeakSet([]);\n");
+}
+
 // https://github.com/terser/terser/blob/v5.9.0/test/compress/dead-code.js
 #[test]
 fn dce_from_terser() {

tasks/coverage/snapshots/minifier_test262.snap

@@ -2,4 +2,6 @@ commit: 4b5d36ab
 
 minifier_test262 Summary:
 AST Parsed     : 42013/42013 (100.00%)
-Positive Passed: 42013/42013 (100.00%)
+Positive Passed: 42012/42013 (100.00%)
+Compress: tasks/coverage/test262/test/built-ins/Date/prototype/valueOf/S9.4_A3_T2.js
+