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

src/ast/KnownGlobal.zig

@@ -8,26 +8,166 @@ 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, minify_whitespace: bool) ?js_ast.Expr {
+        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 null;
+
+        return 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);
+            },
 
-        const constructor = map.get(symbol.original_name) orelse return;
+            .Object => {
+                const n = e.args.len;
 
-        switch (constructor) {
+                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;
+
+                return switch (n) {
+                    0 => {
+                        // new Array() -> []
+                        return js_ast.Expr.init(E.Array, E.Array{}, loc);
+                    },
+                    1 => {
+                        // For single argument, only convert to literal if we're SURE it's not a number
+                        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 => {
+                                const val = arg.data.e_number.value;
+                                if (
+                                // only want this with whitespace minification
+                                minify_whitespace and
+                                    (val == 0 or
+                                        val == 1 or
+                                        val == 2 or
+                                        val == 3 or
+                                        val == 4 or
+                                        val == 5 or
+                                        val == 6 or
+                                        val == 7 or
+                                        val == 8 or
+                                        val == 9 or
+                                        val == 10))
+                                {
+                                    const arg_loc = arg.loc;
+                                    var list = e.args.listManaged(allocator);
+                                    list.clearRetainingCapacity();
+                                    bun.handleOom(list.appendNTimes(js_ast.Expr{ .data = js_parser.Prefill.Data.EMissing, .loc = arg_loc }, @intFromFloat(val)));
+                                    return js_ast.Expr.init(E.Array, .{ .items = .fromList(list) }, loc);
+                                }
+                                return callFromNew(e, loc);
+                            },
+                            .unknown, .mixed => {
+                                // Could be a number, preserve Array() call
+                                return callFromNew(e, loc);
+                            },
+                        }
+                    },
+                    // > 1
+                    else => {
+                        // new Array(1, 2, 3) -> [1, 2, 3]
+                        // But NOT new Array(3) which creates an array with 3 empty slots
+                        return js_ast.Expr.init(E.Array, .{ .items = e.args }, 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 +190,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
             .Date => {
                 const n = e.args.len;
@@ -58,7 +199,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 +219,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
 
             .Set => {
@@ -86,7 +228,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 +244,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
 
             .Headers => {
@@ -111,8 +254,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 +266,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 +286,7 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
             .TextDecoder, .TextEncoder => {
                 const n = e.args.len;
@@ -151,11 +296,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 +310,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 +339,20 @@ pub const KnownGlobal = enum {
                         },
                     }
                 }
+                return null;
             },
-        }
+        };
     }
 };
 
 const string = []const u8;
 
+const std = @import("std");
+
 const bun = @import("bun");
+const js_parser = bun.js_parser;
+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, p.options.features.minify_whitespace)) |minified| {
+                        return minified;
+                    }
                 }
                 return expr;
             }

src/bundler/ParseTask.zig

@@ -1175,6 +1175,7 @@ fn runWithSourceCode(
     opts.output_format = output_format;
     opts.features.minify_syntax = transpiler.options.minify_syntax;
     opts.features.minify_identifiers = transpiler.options.minify_identifiers;
+    opts.features.minify_whitespace = transpiler.options.minify_whitespace;
     opts.features.emit_decorator_metadata = transpiler.options.emit_decorator_metadata;
     opts.features.unwrap_commonjs_packages = transpiler.options.unwrap_commonjs_packages;
     opts.features.hot_module_reloading = output_format == .internal_bake_dev and !source.index.isRuntime();

src/runtime.zig

@@ -168,6 +168,7 @@ pub const Runtime = struct {
 
         minify_syntax: bool = false,
         minify_identifiers: bool = false,
+        minify_whitespace: bool = false,
         dead_code_elimination: bool = true,
 
         set_breakpoint_on_first_line: bool = false,