feat(bundler): inlining/dead-code-elimination for import.meta.main (and --compile)

src/bun.js/RuntimeTranspilerCache.zig

@@ -1,7 +1,8 @@
 /// ** Update the version number when any breaking changes are made to the cache format or to the JS parser **
 /// Version 3: "Infinity" becomes "1/0".
 /// Version 4: TypeScript enums are properly handled + more constant folding
-const expected_version = 4;
+/// Version 5: `require.main === module` no longer marks a module as CJS
+const expected_version = 5;
 
 const bun = @import("root").bun;
 const std = @import("std");

src/bundler.zig

@@ -1201,6 +1201,7 @@ pub const Bundler = struct {
                         .inline_require_and_import_errors = false,
                         .import_meta_ref = ast.import_meta_ref,
                         .runtime_transpiler_cache = runtime_transpiler_cache,
+                        .target = bundler.options.target,
                         .print_dce_annotations = bundler.options.emit_dce_annotations,
                     },
                     enable_source_map,

src/bundler/bundle_v2.zig

@@ -655,6 +655,7 @@ pub const BundleV2 = struct {
         hash: ?u64,
         batch: *ThreadPoolLib.Batch,
         resolve: _resolver.Result,
+        is_entry_point: bool,
     ) !?Index.Int {
         var result = resolve;
         var path = result.path() orelse return null;
@@ -692,6 +693,7 @@ pub const BundleV2 = struct {
         task.loader = loader;
         task.task.node.next = null;
         task.tree_shaking = this.linker.options.tree_shaking;
+        task.is_entry_point = is_entry_point;
 
         // Handle onLoad plugins as entry points
         if (!this.enqueueOnLoadPluginIfNeeded(task)) {
@@ -766,6 +768,7 @@ pub const BundleV2 = struct {
         generator.linker.options.source_maps = bundler.options.source_map;
         generator.linker.options.tree_shaking = bundler.options.tree_shaking;
         generator.linker.options.public_path = bundler.options.public_path;
+        generator.linker.options.target = bundler.options.target;
 
         var pool = try generator.graph.allocator.create(ThreadPool);
         if (enable_reloading) {
@@ -822,7 +825,7 @@ pub const BundleV2 = struct {
 
             for (entry_points) |entry_point| {
                 const resolved = this.bundler.resolveEntryPoint(entry_point) catch continue;
-                if (try this.enqueueItem(null, &batch, resolved)) |source_index| {
+                if (try this.enqueueItem(null, &batch, resolved, true)) |source_index| {
                     this.graph.entry_points.append(this.graph.allocator, Index.source(source_index)) catch unreachable;
                 } else {}
             }
@@ -836,7 +839,7 @@ pub const BundleV2 = struct {
 
             for (user_entry_points) |entry_point| {
                 const resolved = this.bundler.resolveEntryPoint(entry_point) catch continue;
-                if (try this.enqueueItem(null, &batch, resolved)) |source_index| {
+                if (try this.enqueueItem(null, &batch, resolved, true)) |source_index| {
                     this.graph.entry_points.append(this.graph.allocator, Index.source(source_index)) catch unreachable;
                 } else {}
             }
@@ -2320,6 +2323,7 @@ pub const ParseTask = struct {
     emit_decorator_metadata: bool = false,
     ctx: *BundleV2,
     package_version: string = "",
+    is_entry_point: bool = false,
 
     /// Used by generated client components
     presolved_source_indices: []const Index.Int = &.{},
@@ -2880,6 +2884,15 @@ pub const ParseTask = struct {
         opts.features.emit_decorator_metadata = bundler.options.emit_decorator_metadata;
         opts.ignore_dce_annotations = bundler.options.ignore_dce_annotations and !source.index.isRuntime();
 
+        // For files that are not user-specified entrypoints, set `import.meta.main` to `false`.
+        // Entrypoints will have `import.meta.main` set as "unknown", unless we use `--compile`,
+        // in which we inline `true`.
+        if (bundler.options.inline_entrypoint_import_meta_main or !task.is_entry_point) {
+            opts.import_meta_main_value = task.is_entry_point;
+        } else if (bundler.options.target == .node) {
+            opts.lower_import_meta_main_for_node_js = true;
+        }
+
         opts.tree_shaking = if (source.index.isRuntime()) true else bundler.options.tree_shaking;
         opts.module_type = task.module_type;
         opts.features.unwrap_commonjs_packages = bundler.options.unwrap_commonjs_packages;
@@ -3862,6 +3875,7 @@ pub const LinkerContext = struct {
         minify_syntax: bool = false,
         minify_identifiers: bool = false,
         source_maps: options.SourceMapOption = .none,
+        target: options.Target = .browser,
 
         mode: Mode = Mode.bundle,
 
@@ -6810,6 +6824,7 @@ pub const LinkerContext = struct {
                 .minify_whitespace = c.options.minify_whitespace,
                 .minify_identifiers = c.options.minify_identifiers,
                 .minify_syntax = c.options.minify_syntax,
+                .target = c.options.target,
                 .print_dce_annotations = c.options.emit_dce_annotations,
                 // .const_values = c.graph.const_values,
             };
@@ -9036,6 +9051,7 @@ pub const LinkerContext = struct {
                 c,
             ),
             .line_offset_tables = c.graph.files.items(.line_offset_table)[part_range.source_index.get()],
+            .target = c.options.target,
         };
 
         writer.buffer.reset();

src/cli.zig

@@ -81,7 +81,7 @@ pub const debug_flags = if (Environment.isDebug) struct {
         }
         return false;
     }
-} else @compileError("Do not access this namespace []const u8; in a release build");
+} else @compileError("Do not access this namespace in a release build");
 
 const LoaderMatcher = strings.ExactSizeMatcher(4);
 const ColonListType = @import("./cli/colon_list_type.zig").ColonListType;
@@ -774,6 +774,7 @@ pub const Arguments = struct {
 
             if (args.flag("--compile")) {
                 ctx.bundler_options.compile = true;
+                ctx.bundler_options.inline_entrypoint_import_meta_main = true;
             }
 
             if (args.option("--outdir")) |outdir| {
@@ -1279,6 +1280,7 @@ pub const Command = struct {
             react_server_components: bool = false,
             code_splitting: bool = false,
             transform_only: bool = false,
+            inline_entrypoint_import_meta_main: bool = false,
             minify_syntax: bool = false,
             minify_whitespace: bool = false,
             minify_identifiers: bool = false,

src/cli/build_command.zig

@@ -102,6 +102,9 @@ pub const BuildCommand = struct {
         this_bundler.options.react_server_components = ctx.bundler_options.react_server_components;
         this_bundler.resolver.opts.react_server_components = ctx.bundler_options.react_server_components;
 
+        this_bundler.options.inline_entrypoint_import_meta_main = ctx.bundler_options.inline_entrypoint_import_meta_main;
+        this_bundler.resolver.opts.inline_entrypoint_import_meta_main = ctx.bundler_options.inline_entrypoint_import_meta_main;
+
         this_bundler.options.code_splitting = ctx.bundler_options.code_splitting;
         this_bundler.resolver.opts.code_splitting = ctx.bundler_options.code_splitting;
 

src/crash_handler.zig

@@ -1519,7 +1519,7 @@ pub fn dumpStackTrace(trace: std.builtin.StackTrace) void {
         },
         .linux => {
             // Linux doesnt seem to be able to decode it's own debug info.
-            // TODO(@paperdave): see if zig 0.12 fixes this
+            // TODO(@paperdave): see if zig 0.14 fixes this
         },
         else => {
             stdDumpStackTrace(trace);

src/js_ast.zig

@@ -1550,6 +1550,12 @@ pub const E = struct {
         range: logger.Range,
     };
     pub const ImportMeta = struct {};
+    pub const ImportMetaMain = struct {
+        /// If we want to print `!import.meta.main`, set this flag to true
+        /// instead of wrapping in a unary not. This way, the printer can easily
+        /// print `require.main != module` instead of `!(require.main == module)`
+        inverted: bool = false,
+    };
 
     pub const Call = struct {
         // Node:
@@ -4468,14 +4474,13 @@ pub const Expr = struct {
         e_undefined,
         e_new_target,
         e_import_meta,
+        e_import_meta_main,
+        e_require_main,
         e_inlined_enum,
 
         /// A string that is UTF-8 encoded without escaping for use in JavaScript.
         e_utf8_string,
 
-        // This should never make it to the printer
-        inline_identifier,
-
         // object, regex and array may have had side effects
         pub fn isPrimitiveLiteral(tag: Tag) bool {
             return switch (tag) {
@@ -5156,8 +5161,8 @@ pub const Expr = struct {
 
         e_require_string: E.RequireString,
         e_require_resolve_string: E.RequireResolveString,
-        e_require_call_target: void,
-        e_require_resolve_call_target: void,
+        e_require_call_target,
+        e_require_resolve_call_target,
 
         e_missing: E.Missing,
         e_this: E.This,
@@ -5166,14 +5171,12 @@ pub const Expr = struct {
         e_undefined: E.Undefined,
         e_new_target: E.NewTarget,
         e_import_meta: E.ImportMeta,
-        e_inlined_enum: *E.InlinedEnum,
+        e_import_meta_main: E.ImportMetaMain,
+        e_require_main,
 
+        e_inlined_enum: *E.InlinedEnum,
         e_utf8_string: *E.UTF8String,
 
-        // This type should not exist outside of MacroContext
-        // If it ends up in JSParser or JSPrinter, it is a bug.
-        inline_identifier: i32,
-
         pub fn as(data: Data, comptime tag: Tag) ?std.meta.FieldType(Data, tag) {
             return if (data == tag) @field(data, @tagName(tag)) else null;
         }
@@ -5754,6 +5757,14 @@ pub const Expr = struct {
             equal: bool = false,
             ok: bool = false,
 
+            /// This extra flag is unfortunately required for the case of visiting the expression
+            /// `require.main === module` (and any combination of !==, ==, !=, either ordering)
+            ///
+            /// We want to replace this with the dedicated import_meta_main node, which:
+            /// - Stops this module from having p.require_ref, allowing conversion to ESM
+            /// - Allows us to inline `import.meta.main`'s value, if it is known (bun build --compile)
+            is_require_main_and_module: bool = false,
+
             pub const @"true" = Equality{ .ok = true, .equal = true };
             pub const @"false" = Equality{ .ok = true, .equal = false };
             pub const unknown = Equality{ .ok = false };
@@ -5765,12 +5776,14 @@ pub const Expr = struct {
         pub fn eql(
             left: Expr.Data,
             right: Expr.Data,
-            allocator: std.mem.Allocator,
+            p: anytype,
             comptime kind: enum { loose, strict },
         ) Equality {
+            comptime bun.assert(@typeInfo(@TypeOf(p)).Pointer.size == .One); // pass *Parser
+
             // https://dorey.github.io/JavaScript-Equality-Table/
             switch (left) {
-                .e_inlined_enum => |inlined| return inlined.value.data.eql(right, allocator, kind),
+                .e_inlined_enum => |inlined| return inlined.value.data.eql(right, p, kind),
 
                 .e_null, .e_undefined => {
                     const ok = switch (@as(Expr.Tag, right)) {
@@ -5881,8 +5894,8 @@ pub const Expr = struct {
                 .e_string => |l| {
                     switch (right) {
                         .e_string => |r| {
-                            r.resolveRopeIfNeeded(allocator);
-                            l.resolveRopeIfNeeded(allocator);
+                            r.resolveRopeIfNeeded(p.allocator);
+                            l.resolveRopeIfNeeded(p.allocator);
                             return .{
                                 .ok = true,
                                 .equal = r.eql(E.String, l),
@@ -5892,8 +5905,8 @@ pub const Expr = struct {
                             if (inlined.value.data == .e_string) {
                                 const r = inlined.value.data.e_string;
 
-                                r.resolveRopeIfNeeded(allocator);
-                                l.resolveRopeIfNeeded(allocator);
+                                r.resolveRopeIfNeeded(p.allocator);
+                                l.resolveRopeIfNeeded(p.allocator);
 
                                 return .{
                                     .ok = true,
@@ -5924,7 +5937,20 @@ pub const Expr = struct {
                         else => {},
                     }
                 },
-                else => {},
+
+                else => {
+                    // Do not need to check left because e_require_main is
+                    // always re-ordered to the right side.
+                    if (right == .e_require_main) {
+                        if (left.as(.e_identifier)) |id| {
+                            if (id.ref.eql(p.module_ref)) return .{
+                                .ok = true,
+                                .equal = true,
+                                .is_require_main_and_module = true,
+                            };
+                        }
+                    }
+                },
             }
 
             return Equality.unknown;
@@ -5949,7 +5975,6 @@ pub const Expr = struct {
 
                 .e_identifier,
                 .e_import_identifier,
-                .inline_identifier,
                 .e_private_identifier,
                 .e_commonjs_export_identifier,
                 => error.@"Cannot convert identifier to JS. Try a statically-known value",