feat(minify): optimize Error constructors by removing 'new' keyword

src/ast/KnownGlobal.zig

@@ -8,26 +8,144 @@ pub const KnownGlobal = enum {
     Response,
     TextEncoder,
     TextDecoder,
+    Error,
+    TypeError,
+    SyntaxError,
+    RangeError,
+    ReferenceError,
+    EvalError,
+    URIError,
+    AggregateError,
+    Array,
+    Object,
+    Function,
+    RegExp,
 
     pub const map = bun.ComptimeEnumMap(KnownGlobal);
 
-    pub noinline fn maybeMarkConstructorAsPure(noalias e: *E.New, symbols: []const Symbol) void {
-        const id = if (e.target.data == .e_identifier) e.target.data.e_identifier.ref else return;
+    inline fn callFromNew(e: *E.New, loc: logger.Loc) js_ast.Expr {
+        const call = E.Call{
+            .target = e.target,
+            .args = e.args,
+            .close_paren_loc = e.close_parens_loc,
+            .can_be_unwrapped_if_unused = e.can_be_unwrapped_if_unused,
+        };
+        return js_ast.Expr.init(E.Call, call, loc);
+    }
+
+    pub noinline fn minifyGlobalConstructor(allocator: std.mem.Allocator, noalias e: *E.New, symbols: []const Symbol, loc: logger.Loc) ?js_ast.Expr {
+        _ = allocator;
+        const id = if (e.target.data == .e_identifier) e.target.data.e_identifier.ref else return null;
         const symbol = &symbols[id.innerIndex()];
         if (symbol.kind != .unbound)
-            return;
+            return null;
 
-        const constructor = map.get(symbol.original_name) orelse return;
+        const constructor = map.get(symbol.original_name) orelse return null;
 
         switch (constructor) {
+            // Error constructors can be called without 'new' with identical behavior
+            .Error, .TypeError, .SyntaxError, .RangeError, .ReferenceError, .EvalError, .URIError, .AggregateError => {
+                // Convert `new Error(...)` to `Error(...)` to save bytes
+                return callFromNew(e, loc);
+            },
+
+            .Object => {
+                const n = e.args.len;
+
+                if (n == 0) {
+                    // new Object() -> {}
+                    return js_ast.Expr.init(E.Object, E.Object{}, loc);
+                }
+
+                if (n == 1) {
+                    const arg = e.args.ptr[0];
+                    switch (arg.data) {
+                        .e_object, .e_array => {
+                            // new Object({a: 1}) -> {a: 1}
+                            // new Object([1, 2]) -> [1, 2]
+                            return arg;
+                        },
+                        .e_null, .e_undefined => {
+                            // new Object(null) -> {}
+                            // new Object(undefined) -> {}
+                            return js_ast.Expr.init(E.Object, E.Object{}, loc);
+                        },
+                        else => {},
+                    }
+                }
+
+                // For other cases, just remove 'new'
+                return callFromNew(e, loc);
+            },
+
+            .Array => {
+                const n = e.args.len;
+
+                if (n == 0) {
+                    // new Array() -> []
+                    return js_ast.Expr.init(E.Array, E.Array{}, loc);
+                }
+
+                // new Array(1, 2, 3) -> [1, 2, 3]
+                // But NOT new Array(3) which creates an array with 3 empty slots
+                if (n > 1) {
+                    return js_ast.Expr.init(E.Array, .{ .items = e.args }, loc);
+                }
+
+                // For single argument, only convert to literal if we're SURE it's not a number
+                if (n == 1) {
+                    const arg = e.args.ptr[0];
+
+                    // Check if it's an object or array literal first
+                    switch (arg.data) {
+                        .e_object, .e_array => {
+                            // new Array({}) -> [{}], new Array([1]) -> [[1]]
+                            // These are definitely not numbers, safe to convert
+                            return js_ast.Expr.init(E.Array, .{ .items = e.args }, loc);
+                        },
+                        else => {},
+                    }
+
+                    // For other types, check via knownPrimitive
+                    const primitive = arg.knownPrimitive();
+                    // Only convert if we know for certain it's not a number
+                    // unknown could be a number at runtime, so we must preserve Array() call
+                    switch (primitive) {
+                        .null, .undefined, .boolean, .string, .bigint => {
+                            // These are definitely not numbers, safe to convert
+                            return js_ast.Expr.init(E.Array, .{ .items = e.args }, loc);
+                        },
+                        .number, .unknown, .mixed => {
+                            // Could be a number, preserve Array() call
+                            return callFromNew(e, loc);
+                        },
+                    }
+                }
+
+                // For new Array(number), just remove 'new'
+                return callFromNew(e, loc);
+            },
+
+            .Function => {
+                // Just remove 'new' for Function
+                return callFromNew(e, loc);
+            },
+            .RegExp => {
+                // Don't optimize RegExp - the semantics are too complex:
+                // - new RegExp(re) creates a copy, but RegExp(re) returns the same instance
+                // - This affects object identity and lastIndex behavior
+                // - The difference only applies when flags are undefined
+                // Keep the original new RegExp() call to preserve correct semantics
+                return null;
+            },
             .WeakSet, .WeakMap => {
                 const n = e.args.len;
 
                 if (n == 0) {
                     // "new WeakSet()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
 
-                    return;
+                    return null;
                 }
 
                 if (n == 1) {
@@ -50,6 +168,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
             .Date => {
                 const n = e.args.len;
@@ -58,7 +177,7 @@ pub const KnownGlobal = enum {
                     // "new Date()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
 
-                    return;
+                    return null;
                 }
 
                 if (n == 1) {
@@ -78,6 +197,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
 
             .Set => {
@@ -86,7 +206,7 @@ pub const KnownGlobal = enum {
                 if (n == 0) {
                     // "new Set()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
-                    return;
+                    return null;
                 }
 
                 if (n == 1) {
@@ -102,6 +222,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
 
             .Headers => {
@@ -111,8 +232,9 @@ pub const KnownGlobal = enum {
                     // "new Headers()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
 
-                    return;
+                    return null;
                 }
+                return null;
             },
 
             .Response => {
@@ -122,7 +244,7 @@ pub const KnownGlobal = enum {
                     // "new Response()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
 
-                    return;
+                    return null;
                 }
 
                 if (n == 1) {
@@ -142,6 +264,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
             .TextDecoder, .TextEncoder => {
                 const n = e.args.len;
@@ -151,11 +274,12 @@ pub const KnownGlobal = enum {
                     // "new TextDecoder()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
 
-                    return;
+                    return null;
                 }
 
                 // We _could_ validate the encoding argument
                 // But let's not bother
+                return null;
             },
 
             .Map => {
@@ -164,7 +288,7 @@ pub const KnownGlobal = enum {
                 if (n == 0) {
                     // "new Map()" is pure
                     e.can_be_unwrapped_if_unused = .if_unused;
-                    return;
+                    return null;
                 }
 
                 if (n == 1) {
@@ -193,18 +317,19 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
         }
     }
 };
 
 const string = []const u8;
 
+const std = @import("std");
+
 const bun = @import("bun");
+const logger = bun.logger;
 
 const js_ast = bun.ast;
 const E = js_ast.E;
 const Symbol = js_ast.Symbol;
-
-const std = @import("std");
-const Map = std.AutoHashMapUnmanaged;

src/ast/visitExpr.zig

@@ -1492,7 +1492,9 @@ pub fn VisitExpr(
                 }
 
                 if (p.options.features.minify_syntax) {
-                    KnownGlobal.maybeMarkConstructorAsPure(e_, p.symbols.items);
+                    if (KnownGlobal.minifyGlobalConstructor(p.allocator, e_, p.symbols.items, expr.loc)) |minified| {
+                        return minified;
+                    }
                 }
                 return expr;
             }