feat: support 0.16.0-dev.1976+8e091047b

Author: dotcarmen

build.zig

@@ -345,7 +345,7 @@ fn getVersion(b: *Build) std.SemanticVersion {
         "git", "-C", b.pathFromRoot("."), "--git-dir", ".git", "describe", "--match", "*.*.*", "--tags",
     };
     var code: u8 = undefined;
-    const git_describe_untrimmed = b.runAllowFail(argv, &code, .Ignore) catch |err| {
+    const git_describe_untrimmed = b.runAllowFail(argv, &code, .ignore) catch |err| {
         const argv_joined = std.mem.join(b.allocator, " ", argv) catch @panic("OOM");
         std.log.warn(
             \\Failed to run git describe to resolve ZLS version: {}

build.zig.zon

@@ -10,7 +10,7 @@
     // nix flake update --commit-lock-file
     // ```
     // If you do not use Nix, a ZLS maintainer can take care of this.
-    .minimum_zig_version = "0.16.0-dev.1912+0cbaaa5eb",
+    .minimum_zig_version = "0.16.0-dev.1976+8e091047b",
     // If you do not use Nix, a ZLS maintainer can take care of this.
     // Whenever the dependencies are updated, run the following command:
     // ```bash

src/build_runner/build_runner.zig

@@ -26,6 +26,18 @@ const ArrayList = if (@hasDecl(std, "array_list")) std.ArrayList else std.ArrayL
 const Step = std.Build.Step;
 const Allocator = std.mem.Allocator;
 
+const has_process_env = @import("builtin").zig_version.order(.{
+    .major = 0,
+    .minor = 16,
+    .patch = 0,
+    .pre = "dev.1976",
+}) == .lt;
+const process_stdio_ignore: std.process.SpawnOptions.StdIo =
+    if (@hasField(std.process.SpawnOptions.StdIo, "Ignore"))
+        .Ignore
+    else
+        .ignore;
+
 pub const dependencies = @import("@dependencies");
 
 pub const std_options: std.Options = .{
@@ -34,9 +46,31 @@ pub const std_options: std.Options = .{
     .crypto_fork_safety = false,
 };
 
-///! This is a modified build runner to extract information out of build.zig
-///! Modified version of lib/build_runner.zig
-pub fn main() !void {
+pub const main = if (has_process_env) @"main < dev.1976" else @"main >= dev.1976";
+
+fn @"main >= dev.1976"(init: std.process.Init.Minimal) !void {
+    // Here we use an ArenaAllocator backed by a DirectAllocator because a build is a short-lived,
+    // one shot program. We don't need to waste time freeing memory and finding places to squish
+    // bytes into. So we free everything all at once at the very end.
+    var single_threaded_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer single_threaded_arena.deinit();
+
+    var thread_safe_arena: std.heap.ThreadSafeAllocator = .{
+        .child_allocator = single_threaded_arena.allocator(),
+    };
+    const arena = thread_safe_arena.allocator();
+
+    const args = try init.args.toSlice(arena);
+
+    var threaded: std.Io.Threaded = .init(arena, .{
+        .environ = init.environ,
+    });
+    defer threaded.deinit();
+
+    try doMain(arena, &threaded, args);
+}
+
+fn @"main < dev.1976"() !void {
     // Here we use an ArenaAllocator backed by a DirectAllocator because a build is a short-lived,
     // one shot program. We don't need to waste time freeing memory and finding places to squish
     // bytes into. So we free everything all at once at the very end.
@@ -52,6 +86,13 @@ pub fn main() !void {
 
     var threaded: std.Io.Threaded = .init(arena, .{});
     defer threaded.deinit();
+
+    try doMain(arena, &threaded, args);
+}
+
+///! This is a modified build runner to extract information out of build.zig
+///! Modified version of lib/build_runner.zig
+fn doMain(arena: std.mem.Allocator, threaded: *std.Io.Threaded, args: []const [:0]const u8) !void {
     const io = threaded.ioBasic();
 
     // skip my own exe name
@@ -64,6 +105,7 @@ pub fn main() !void {
     const global_cache_root = nextArg(args, &arg_idx) orelse fatal("missing global cache root directory path", .{});
 
     const cwd: std.Io.Dir = .cwd();
+    const cwd_path = try std.process.getCwdAlloc(arena);
 
     const zig_lib_directory: std.Build.Cache.Directory = .{
         .path = zig_lib_dir,
@@ -85,24 +127,33 @@ pub fn main() !void {
         .handle = try cwd.createDirPathOpen(io, global_cache_root, .{}),
     };
 
-    var graph: std.Build.Graph = .{
-        .io = io,
-        .arena = arena,
-        .cache = .{
+    var graph: std.Build.Graph = undefined;
+    graph.io = io;
+    graph.arena = arena;
+    graph.zig_exe = zig_exe;
+    graph.global_cache_root = global_cache_directory;
+    graph.zig_lib_directory = zig_lib_directory;
+    graph.host = .{
+        .query = .{},
+        .result = try std.zig.system.resolveTargetQuery(io, .{}),
+    };
+    graph.time_report = false;
+
+    if (has_process_env) {
+        graph.env_map = try process.getEnvMap(arena);
+        graph.cache = .{
             .io = io,
             .gpa = arena,
             .manifest_dir = try local_cache_directory.handle.createDirPathOpen(io, "h", .{}),
-        },
-        .zig_exe = zig_exe,
-        .env_map = try process.getEnvMap(arena),
-        .global_cache_root = global_cache_directory,
-        .zig_lib_directory = zig_lib_directory,
-        .host = .{
-            .query = .{},
-            .result = try std.zig.system.resolveTargetQuery(io, .{}),
-        },
-        .time_report = false,
-    };
+        };
+    } else {
+        graph.cache = .{
+            .io = io,
+            .gpa = arena,
+            .manifest_dir = try local_cache_directory.handle.createDirPathOpen(io, "h", .{}),
+            .cwd = cwd_path,
+        };
+    }
 
     graph.cache.addPrefix(.{ .path = null, .handle = cwd });
     graph.cache.addPrefix(build_root_directory);
@@ -388,7 +439,7 @@ pub fn main() !void {
         return;
     }
 
-    var w = try Watch.init(io);
+    var w = try Watch.init(io, cwd_path);
 
     const message_thread = try std.Thread.spawn(.{}, struct {
         fn do(ww: *Watch) void {
@@ -475,10 +526,24 @@ const Watch = struct {
     manual_event: std.Io.Event,
     steps: []const *Step,
 
-    fn init(io: std.Io) !Watch {
+    fn init(io: std.Io, cwd_path: []const u8) !Watch {
+        const std_build_watch_status: enum {
+            unimplemented,
+            v1,
+            v2,
+        } = if (@TypeOf(std.Build.Watch) == void)
+            .unimplemented
+        else if (@typeInfo(@TypeOf(std.Build.Watch.init)).@"fn".params.len == 0)
+            .v1
+        else
+            .v2;
         return .{
             .io = io,
-            .fs_watch = if (@TypeOf(std.Build.Watch) != void) try std.Build.Watch.init() else {},
+            .fs_watch = switch (std_build_watch_status) {
+                .unimplemented => {},
+                .v1 => try std.Build.Watch.init(),
+                .v2 => try std.Build.Watch.init(cwd_path),
+            },
             .supports_fs_watch = @TypeOf(std.Build.Watch) != void and shared.BuildOnSaveSupport.isSupportedRuntime(builtin.zig_version) == .supported,
             .manual_event = .unset,
             .steps = &.{},
@@ -1395,7 +1460,7 @@ const copied_from_zig = struct {
             pkg_name,
             "--cflags",
             "--libs",
-        }, &code, .Ignore)) |stdout| stdout else |err| switch (err) {
+        }, &code, process_stdio_ignore)) |stdout| stdout else |err| switch (err) {
             error.ProcessTerminated => return error.PkgConfigCrashed,
             error.ExecNotSupported => return error.PkgConfigFailed,
             error.ExitCodeFailure => return error.PkgConfigFailed,
@@ -1437,7 +1502,7 @@ const copied_from_zig = struct {
     }
 
     fn execPkgConfigList(self: *std.Build, out_code: *u8) (std.Build.PkgConfigError || std.Build.RunError)![]const std.Build.PkgConfigPkg {
-        const stdout = try self.runAllowFail(&.{ "pkg-config", "--list-all" }, out_code, .Ignore);
+        const stdout = try self.runAllowFail(&.{ "pkg-config", "--list-all" }, out_code, process_stdio_ignore);
         var list = ArrayListManaged(std.Build.PkgConfigPkg).init(self.allocator);
         errdefer list.deinit();
         var line_it = mem.tokenizeAny(u8, stdout, "\r\n");

src/tools/config_gen.zig

@@ -1010,15 +1010,15 @@ fn generateVersionDataFile(
     try file_writer.end();
 }
 
-pub fn main() !void {
+pub fn main(init: std.process.Init.Minimal) !void {
     var debug_allocator: std.heap.DebugAllocator(.{}) = .init;
     defer _ = debug_allocator.deinit();
     const gpa = debug_allocator.allocator();
 
     var threaded: std.Io.Threaded = .init_single_threaded;
     const io = threaded.io();
 
-    var args_it = try std.process.argsWithAllocator(gpa);
+    var args_it = try init.args.iterateAllocator(gpa);
     defer args_it.deinit();
 
     _ = args_it.skip();