generate buildpkgs.zig for each sub-package

Author: marler8997

src/Compilation.zig

@@ -137,9 +137,9 @@ emit_llvm_ir: ?EmitLoc,
 emit_analysis: ?EmitLoc,
 emit_docs: ?EmitLoc,
 
-// true to generate the pkg_names array and hasPkg function in builtin.zig
-// should only be true when compiling build.zig
-enable_builtin_pkg_names: bool,
+/// enables the "buildpkgs" package that exposes what packages are available to the module.
+/// this should only be enabled for build.zig and its package dependencies.
+enable_buildpkgs: bool,
 
 work_queue_wait_group: WaitGroup,
 
@@ -507,7 +507,7 @@ pub const InitOptions = struct {
     test_filter: ?[]const u8 = null,
     test_name_prefix: ?[]const u8 = null,
     subsystem: ?std.Target.SubSystem = null,
-    enable_builtin_pkg_names: ?bool = null,
+    enable_buildpkgs: ?bool = false,
 };
 
 fn addPackageTableToCacheHash(
@@ -909,6 +909,14 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
                     artifact_sub_dir,
             };
 
+            if (options.enable_buildpkgs orelse false) {
+                if (root_pkg.table.get("@build")) |build_pkg| {
+                    try addBuildpkgs(gpa, arena, zig_cache_artifact_directory, "buildpkgs", build_pkg);
+                } else {
+                    fatal("enable_buildpkgs should only be enabled for build.zig", .{});
+                }
+            }
+
             // TODO when we implement serialization and deserialization of incremental compilation metadata,
             // this is where we would load it. We have open a handle to the directory where
             // the output either already is, or will be.
@@ -1125,7 +1133,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             .test_evented_io = options.test_evented_io,
             .debug_compiler_runtime_libs = options.debug_compiler_runtime_libs,
             .work_queue_wait_group = undefined,
-            .enable_builtin_pkg_names = options.enable_builtin_pkg_names orelse false,
+            .enable_buildpkgs = options.enable_buildpkgs orelse false,
         };
         break :comp comp;
     };
@@ -2791,7 +2799,7 @@ fn updateBuiltinZigFile(comp: *Compilation, mod: *Module) !void {
     const tracy = trace(@src());
     defer tracy.end();
 
-    const source = try comp.generateBuiltinZigSource(comp.gpa, mod);
+    const source = try comp.generateBuiltinZigSource(comp.gpa);
     defer comp.gpa.free(source);
     try mod.zig_cache_artifact_directory.handle.writeFile("builtin.zig", source);
 }
@@ -2803,7 +2811,7 @@ pub fn dump_argv(argv: []const []const u8) void {
     std.debug.print("{s}\n", .{argv[argv.len - 1]});
 }
 
-pub fn generateBuiltinZigSource(comp: *Compilation, allocator: *Allocator, optional_mod: ?*Module) ![]u8 {
+pub fn generateBuiltinZigSource(comp: *Compilation, allocator: *Allocator) ![]u8 {
     const tracy = trace(@src());
     defer tracy.end();
 
@@ -2993,59 +3001,76 @@ pub fn generateBuiltinZigSource(comp: *Compilation, allocator: *Allocator, optio
         }
     }
 
-    if (comp.enable_builtin_pkg_names) {
-        try buffer.writer().writeAll(
-            \\
-            \\pub const pkg_names = &[_][]const u8 {
-            \\
-        );
-        if (optional_mod) |mod| {
-            // TODO: this isn't right, each package should have it's
-            //       own set of sub-packages
-            try recursiveWritePackageNames(buffer.writer(), mod.root_pkg);
-        }
-        try buffer.writer().writeAll(
-            \\};
-            \\
-            \\// using .Inline to force this to be comptime
-            \\pub fn hasPkg(comptime name: []const u8) callconv(.Inline) bool {
-            \\    if (!isComptime()) {
-            \\        @compileError("builtin.hasPkg MUST be called with comptime");
-            \\    }
-            \\    inline for (pkg_names) |has_name| {
-            \\        if (@import("std").mem.eql(u8, name, has_name)) return true;
-            \\    }
-            \\    return false;
-            \\}
-            \\
-            \\// A temporary workaround until https://github.com/ziglang/zig/issues/425
-            \\// is implemented and the callconv(.Inline) on the `hasPkg` function forces
-            \\// it to be comptime
-            \\fn isComptime() bool {
-            \\    var t: bool = true;
-            \\    const x = if (t) @as(u7, 0) else @as(u8, 0);
-            \\    return @TypeOf(x) == u7;
-            \\}
-            \\
-        );
-    } else {
-        try buffer.writer().writeAll(
-            \\
-            \\pub const pkg_names = @compileError("builtin.pkg_names is only available in build.zig");
-            \\pub const hasPkg = @compileError("builtin.hasPkg is only available in build.zig");
-            \\
-        );
+    return buffer.toOwnedSlice();
+}
+
+fn addBuildpkgs(gpa: *Allocator, arena: *Allocator, dir: Directory, name: []const u8, pkg: *Package) anyerror!void {
+    var pkg_dir = Directory {
+        .path = try dir.join(gpa, &[_][]const u8 { name }),
+        .handle = try dir.handle.makeOpenPath(name, .{}),
+    };
+    defer pkg_dir.handle.close();
+    var sub_pkg_it = pkg.table.iterator();
+    while (sub_pkg_it.next()) |sub_pkg| {
+        try addBuildpkgs(gpa, arena, pkg_dir, sub_pkg.key, sub_pkg.value);
     }
 
-    return buffer.toOwnedSlice();
+    const source = try generateBuildpkgsZigSource(gpa, pkg);
+    defer gpa.free(source);
+    try pkg_dir.handle.writeFile("buildpkgs.zig", source);
+
+    try pkg.table.put(arena, "buildpkgs", Package.create(gpa, pkg_dir.path, "buildpkgs.zig") catch |err| {
+        fatal("Failed to create buildpkgs Package at path {s}: {s}", .{ pkg_dir.path, @errorName(err) });
+    });
 }
 
-fn recursiveWritePackageNames(writer: anytype, pkg: *const Package) anyerror!void {
+pub fn generateBuildpkgsZigSource(allocator: *Allocator, pkg: *const Package) ![]u8 {
+    const tracy = trace(@src());
+    defer tracy.end();
+
+    var buffer = std.ArrayList(u8).init(allocator);
+    defer buffer.deinit();
+
+    try buffer.writer().writeAll(
+        \\
+        \\pub const names = &[_][]const u8 {
+        \\
+    );
+    //std.log.info("writePackageNames: begin (path={s}, dir={s})", .{
+    //    pkg.root_src_path,
+    //    if (pkg.root_src_directory.path) |p| p else "<none>",
+    //});
     var pkg_it = pkg.table.iterator();
     while (pkg_it.next()) |sub_pkg| {
-        try writer.print("    \"{s}\",\n", .{sub_pkg.key});
-        try recursiveWritePackageNames(writer, sub_pkg.value);
+        //std.log.info("writePackageNames: name={s}", .{sub_pkg.key});
+        try buffer.writer().print("    \"{s}\",\n", .{sub_pkg.key});
     }
+    try buffer.writer().writeAll(
+        \\};
+        \\
+        \\// using .Inline to force this to be comptime
+        \\pub fn has(comptime name: []const u8) callconv(.Inline) bool {
+        \\    if (!isComptime()) {
+        \\        @compileError("buildpkgs.has MUST be called with comptime");
+        \\    }
+        \\    inline for (names) |has_name| {
+        \\        if (@import("std").mem.eql(u8, name, has_name)) return true;
+        \\    }
+        \\    return false;
+        \\}
+        \\
+        \\// A temporary workaround until https://github.com/ziglang/zig/issues/425
+        \\// is implemented and the callconv(.Inline) on the `has` function forces
+        \\// it to be comptime
+        \\fn isComptime() bool {
+        \\    var t: bool = true;
+        \\    const x = if (t) @as(u7, 0) else @as(u8, 0);
+        \\    return @TypeOf(x) == u7;
+        \\}
+        \\
+    );
+
+    return buffer.toOwnedSlice();
 }
 
 pub fn updateSubCompilation(sub_compilation: *Compilation) !void {

src/main.zig

@@ -1900,7 +1900,7 @@ fn buildOutputType(
     defer if (!comp_destroyed) comp.destroy();
 
     if (show_builtin) {
-        return std.io.getStdOut().writeAll(try comp.generateBuiltinZigSource(arena, null));
+        return std.io.getStdOut().writeAll(try comp.generateBuiltinZigSource(arena));
     }
     if (arg_mode == .translate_c) {
         return cmdTranslateC(comp, arena, have_enable_cache);
@@ -2596,7 +2596,7 @@ pub fn cmdBuild(gpa: *Allocator, arena: *Allocator, args: []const []const u8) !v
             .optimize_mode = .Debug,
             .self_exe_path = self_exe_path,
             .thread_pool = &thread_pool,
-            .enable_builtin_pkg_names = true,
+            .enable_buildpkgs = true,
         }) catch |err| {
             fatal("unable to create compilation: {s}", .{@errorName(err)});
         };

test/standalone.zig

@@ -17,7 +17,7 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
     cases.addBuildFile("test/standalone/issue_794/build.zig");
     cases.addBuildFile("test/standalone/issue_5825/build.zig");
     cases.addBuildFile("test/standalone/pkg_import/build.zig");
-    cases.addBuildFile("test/standalone/build_zig_pkgs/build.zig");
+    cases.addBuildFile("test/standalone/buildpkgs/build.zig");
     cases.addBuildFile("test/standalone/use_alias/build.zig");
     cases.addBuildFile("test/standalone/brace_expansion/build.zig");
     cases.addBuildFile("test/standalone/empty_env/build.zig");

test/standalone/build_zig_pkgs/calling-haspkg-outside-build.zig

@@ -8,6 +8,7 @@ pub const Options = struct {
     expect: enum { fail, pass },
     outputs: []const []const u8,
     args: []const []const u8,
+    cwd: ?[]const u8 = null,
 };
 
 step: Step,
@@ -26,6 +27,7 @@ fn make(step: *Step) !void {
     const self = @fieldParentPtr(RunStep, "step", step);
     const child = try std.ChildProcess.init(self.opt.args, std.heap.page_allocator);
     defer child.deinit();
+    child.cwd = self.opt.cwd;
     child.stderr_behavior = .Pipe;
     try child.spawn();
     const stderr = try child.stderr.?.reader().readAllAlloc(self.builder.allocator, std.math.maxInt(usize));

test/standalone/build_zig_pkgs/RunStep.zig renamed to test/standalone/buildpkgs/RunStep.zig

@@ -1,5 +1,6 @@
 const std = @import("std");
 const Builder = std.build.Builder;
+const buildpkgs = @import("buildpkgs");
 
 pub const Options = struct {
     fastcompress: bool,
@@ -14,7 +15,7 @@ pub fn getApkOptions(b: *Builder) Options {
 pub fn makeApk(b: *Builder, options: Options) !void {
     // android has its own optional dependency
     if (options.fastcompress) {
-        if (comptime std.builtin.hasPkg("fastcompressor")) {
+        if (comptime buildpkgs.has("fastcompressor")) {
             const fastcompressor = @import("fastcompressor");
             std.log.info("we have and need the 'fastcompressor' package", .{});
             fastcompressor.doTheThing();

test/standalone/build_zig_pkgs/android/build.zig renamed to test/standalone/buildpkgs/android/build.zig

@@ -1,9 +1,10 @@
 const std = @import("std");
 const Builder = std.build.Builder;
+const buildpkgs = @import("buildpkgs");
 
 pub fn build(b: *Builder) !void {
     if (b.option(bool, "android", "build for android") orelse false) {
-        if (comptime @import("std").builtin.hasPkg("androidbuild")) {
+        if (comptime buildpkgs.has("androidbuild")) {
             std.log.info("we have and need the 'androidbuild' package", .{});
             const androidbuild = @import("androidbuild");
             const options = androidbuild.getApkOptions(b);

test/standalone/build_zig_pkgs/app-that-might-use-android/build.zig renamed to test/standalone/buildpkgs/app-that-might-use-android/build.zig

@@ -85,7 +85,7 @@ pub fn build(b: *Builder) !void {
     });
     try addRunStep(b, test_step, .{
         .expect = .fail,
-        .outputs = &[_][]const u8 { "builtin.hasPkg MUST be called with comptime" },
+        .outputs = &[_][]const u8 { "buildpkgs.has MUST be called with comptime" },
         .args = try std.mem.dupe(b.allocator, []const u8, &[_][]const u8 {
             b.zig_exe,
             "build",
@@ -94,17 +94,18 @@ pub fn build(b: *Builder) !void {
     });
     try addRunStep(b, test_step, .{
         .expect = .fail,
-        .outputs = &[_][]const u8 { "builtin.hasPkg is only available in build.zig" },
+        .outputs = &[_][]const u8 { "unable to find 'buildpkgs'" },
         .args = try std.mem.dupe(b.allocator, []const u8, &[_][]const u8 {
             b.zig_exe,
             "build-exe",
-            "calling-haspkg-outside-build.zig"
+            "import-buildpkgs-outside-build.zig",
         }),
     });
 }
 
 fn addRunStep(b: *Builder, test_step: *std.build.Step, opt: RunStep.Options) !void {
     const run = try b.allocator.create(RunStep);
     run.* = RunStep.init(b, opt);
+    run.opt.cwd = b.build_root;
     test_step.dependOn(&run.step);
 }

test/standalone/build_zig_pkgs/build.zig renamed to test/standalone/buildpkgs/build.zig

@@ -1,3 +1,2 @@
-
 pub fn doTheThing() void {
 }

test/standalone/build_zig_pkgs/fastcompressor/build.zig renamed to test/standalone/buildpkgs/fastcompressor/build.zig

@@ -0,0 +1,5 @@
+pub fn main() void {
+    if (@import("buildpkgs").has("foo")) {
+        @compileError("calling buildpkgs.has outside of build.zig should be a compile error");
+    }
+}

test/standalone/buildpkgs/import-buildpkgs-outside-build.zig

@@ -1,20 +1,20 @@
-//! Currently the user MUST specify comptime when calling builtin.hasPkg
+//! Currently the user MUST specify comptime when calling "buildpkgs.has"
 //! until https://github.com/ziglang/zig/issues/425 is implemented.
-//! This build.zig file tries to call builtin.hasPkg without comptime and the
+//! This build.zig file tries to call "buildpkgs.has" without comptime and the
 //! test is to make sure it produces a compile error.
 //!
-//! Note that the reason why "hasPkg" must be evaluated at comptime is
+//! Note that the reason why "buildpkgs.has" must be evaluated at comptime is
 //! because it will always surround an @import statement.  The problem is
 //! that if they forget to add "comptime" to their call, then their build.zig
 //! file will "sometimes work" so long as they are building with the necessary
 //! packages configured, but then it will fail once the @import is missing
-//! which defeats the whole purpose of providing "hasPkg" in the first place.
+//! which defeats the whole purpose of providing "buildpkgs.has" in the first place.
 //!
 const Builder = @import("std").build.Builder;
 
 pub fn build(b: *Builder) void {
     // This should be a compile error because it's not marked as comptime
-    if (@import("std").builtin.hasPkg("androidbuild")) {
+    if (@import("buildpkgs").has("androidbuild")) {
         const androidbuild = @import("androidbuild");
         androidbuild.makeApk(b);
     }