force buildpkgs.has to be called at comptime

The reason we want to force buildpkgs.has to be comptime is it is meant to be surrounding a block that contains an @import, so if a user accidently forgets to mark it as comptime then their build.zig will be invalid, but this error will only be caught with certain configurations.  I've marked @import("buildpkgs").has with callconv(.Inline) which should force it to be evaluated at comptime, but it looks like this behavior is not implemented yet.

Author: marler8997

src/main.zig

@@ -2675,13 +2675,26 @@ fn generateBuildPkgs(arena: *Allocator, local_cache_directory: Compilation.Direc
         try writer.writeAll(
             \\};
             \\
-            \\pub fn has(comptime name: []const u8) bool {
+            \\// 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;
+            \\}
+            \\
         );
         try buildpkgs_dir.rename("buildpkgs.zig.tmp", "buildpkgs.zig");
     }

test/standalone/build_zig_pkgs/build.zig

@@ -8,11 +8,20 @@ pub fn build(b: *Builder) void {
     } else {
         const resolveandroid = b.addExecutable("resolveandroid", "resolveandroid.zig");
         resolveandroid.setBuildMode(b.standardReleaseOptions());
-
         const run_resolveandroid = resolveandroid.run();
+        run_resolveandroid.addArg("expect-pass");
         run_resolveandroid.addArg(b.zig_exe);
 
-        const resolveandroid_step = b.step("test", "Resolve android and recompile build.zig");
-        resolveandroid_step.dependOn(&run_resolveandroid.step);
+        const test_build_error = b.addExecutable("test-build-error", "resolveandroid.zig");
+        test_build_error.setBuildMode(b.standardReleaseOptions());
+        const run_test_build_error = test_build_error.run();
+        run_test_build_error.addArg("expect-fail");
+        run_test_build_error.addArg(b.zig_exe);
+        run_test_build_error.addArg("--build-file");
+        run_test_build_error.addArg("invalid-build.zig");
+
+        const test_step = b.step("test", "Resolve android and test the zig build files");
+        test_step.dependOn(&run_resolveandroid.step);
+        test_step.dependOn(&run_test_build_error.step);
     }
 }

test/standalone/build_zig_pkgs/invalid-build.zig

@@ -0,0 +1,22 @@
+//! Currently the user MUST specify comptime when calling buidpkgs.has
+//! until https://github.com/ziglang/zig/issues/425 is implemented.
+//! 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 "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 "has" in the first place.
+//!
+const Builder = @import("std").build.Builder;
+const buildpkgs = @import("buildpkgs");
+
+pub fn build(b: *Builder) void {
+    // This should be a compile error
+    if (buildpkgs.has("androidbuild")) {
+        const androidbuild = @import("androidbuild");
+        androidbuild.makeApk(b);
+    }
+}

test/standalone/build_zig_pkgs/resolveandroid.zig

@@ -1,19 +1,47 @@
 const std = @import("std");
 
-pub fn main() !u8 {
-    const args = try std.process.argsAlloc(std.heap.page_allocator);
+pub fn main() !void {
+    const in_args = try std.process.argsAlloc(std.heap.page_allocator);
 
-    const zig_exe = args[1];
-    const child = try std.ChildProcess.init(&[_][]const u8 {
-        zig_exe, "build",
-        "--pkg-begin", "androidbuild", "androidbuild.zig", "--pkg-end",
-    }, std.heap.page_allocator);
+    const expect_pass = blk: {
+        if (std.mem.eql(u8, in_args[1], "expect-pass")) break :blk true;
+        std.debug.assert(std.mem.eql(u8, in_args[1], "expect-fail"));
+        break :blk false;
+    };
+
+    const zig_exe = in_args[2];
+    var out_args = std.ArrayList([]const u8).init(std.heap.page_allocator);
+    try out_args.append(zig_exe);
+    try out_args.append("build");
+    try out_args.append("--pkg-begin");
+    try out_args.append("androidbuild");
+    try out_args.append("androidbuild.zig");
+    try out_args.append("--pkg-end");
+    for (in_args[3..]) |cmd_arg| {
+        try out_args.append(cmd_arg);
+    }
+
+    const child = try std.ChildProcess.init(out_args.items, std.heap.page_allocator);
     defer child.deinit();
-    switch (try child.spawnAndWait()) {
-        .Exited => |e| return if (e == 0) 0 else 0xff,
-        else => |e| {
-            std.debug.print("Error: zig build process failed with {}\n", .{e});
-            return error.ZigBuildFailed;
-        },
+
+    // redirect stderr so it doesn't show up in the test log
+    child.stderr_behavior = .Pipe;
+    errdefer {
+        if (child.stderr) |stderr| {
+            const err = stderr.reader().readAllAlloc(std.heap.page_allocator, std.math.maxInt(usize)) catch unreachable;
+            std.io.getStdErr().writeAll(err) catch unreachable;
+        }
+    }
+
+    const passed = switch (try child.spawnAndWait()) {
+        .Exited => |e| e == 0,
+        else => false,
+    };
+    if (passed) {
+        if (expect_pass) return;
+        return error.ZigBuildUnexpectedlyPassed;
+    }
+    if (expect_pass) {
+        return error.ZigBuildFailed;
     }
 }