update to zig 0.16.0

Author: Techatrix

.gitignore

@@ -1,8 +1,6 @@
 zig-out
-zig-cache
+zig-pkg
 .zig-cache
 saved_logs
 repos
-node_modules
 .env
-d_*.log

build.zig.zon

@@ -1,11 +1,11 @@
 .{
     .name = .sus,
     .version = "0.1.0",
-    .minimum_zig_version = "0.15.1",
+    .minimum_zig_version = "0.16.0",
     .dependencies = .{
         .lsp_kit = .{
-            .url = "git+https://github.com/zigtools/lsp-kit.git#6274eebace9a6a82ce182e24468fef88e0b95f37",
-            .hash = "lsp_kit-0.1.0-bi_PLzAyCgClDh8_M0U9Q50ysdsQBuRuBTZfwg6rZPd6",
+            .url = "git+https://github.com/zigtools/lsp-kit.git#b886a2b0d5cee85ecbcc3089b863f7517cc9ff7f",
+            .hash = "lsp_kit-0.1.0-bi_PL3IyDACfp1xdTnkiOHEok2YpPCCCJHuuOcNzjl1D",
         },
     },
     .paths = .{

src/Client.zig

@@ -6,6 +6,7 @@ const lsp = @import("lsp");
 
 const Client = @This();
 
+io: std.Io,
 allocator: std.mem.Allocator,
 child_process: std.process.Child,
 transport_read_buffer: [256]u8 = undefined,
@@ -14,12 +15,14 @@ text_document_uri: []const u8,
 zig_path: []const u8,
 
 pub fn init(
+    io: std.Io,
     allocator: std.mem.Allocator,
+    environ_map: *const std.process.Environ.Map,
     zls_path: []const u8,
     zig_path: []const u8,
-    stderr_behavior: std.process.Child.StdIo,
-) (std.process.GetEnvMapError || std.process.Child.SpawnError)!Client {
-    var env_map = try std.process.getEnvMap(allocator);
+    stderr_behavior: std.process.SpawnOptions.StdIo,
+) (std.process.SpawnError)!Client {
+    var env_map = try environ_map.clone(allocator);
     defer env_map.deinit();
 
     try env_map.put("NO_COLOR", "1");
@@ -31,14 +34,14 @@ pub fn init(
         "--disable-lsp-logs",
     };
 
-    var child_process: std.process.Child = .init(argv, allocator);
-    child_process.env_map = &env_map;
-    child_process.stdin_behavior = .Pipe;
-    child_process.stderr_behavior = stderr_behavior;
-    child_process.stdout_behavior = .Pipe;
-
-    try child_process.spawn();
-    errdefer _ = child_process.kill() catch @panic("failed to kill ZLS process");
+    var child_process = try std.process.spawn(io, .{
+        .environ_map = &env_map,
+        .argv = argv,
+        .stdin = .pipe,
+        .stderr = stderr_behavior,
+        .stdout = .pipe,
+    });
+    errdefer child_process.kill(io);
 
     const text_document_uri = try std.fmt.allocPrint(allocator, "{f}", .{std.Uri{
         .scheme = "untitled",
@@ -47,6 +50,7 @@ pub fn init(
     errdefer allocator.free(text_document_uri);
 
     return .{
+        .io = io,
         .allocator = allocator,
         .child_process = child_process,
         .stdio_transport = undefined, // See `initialize`
@@ -56,11 +60,11 @@ pub fn init(
 }
 
 pub fn wait(client: *Client) std.process.Child.WaitError!void {
-    _ = try client.child_process.wait();
+    _ = try client.child_process.wait(client.io);
 }
 
 pub fn kill(client: *Client) void {
-    _ = client.child_process.wait() catch @panic("failed to kill ZLS process");
+    client.child_process.kill(client.io);
 }
 
 pub fn transport(client: *Client) *lsp.Transport {
@@ -75,18 +79,18 @@ pub fn initialize(client: *Client) !void {
     });
     try client.sendNotification("initialized", .{});
 
-    var settings: std.json.ObjectMap = .init(client.allocator);
-    defer settings.deinit();
-    try settings.putNoClobber("skip_std_references", .{ .bool = true }); // references collection into std is very slow
-    try settings.putNoClobber("zig_exe_path", .{ .string = client.zig_path });
+    var settings: std.json.ObjectMap = .empty;
+    defer settings.deinit(client.allocator);
+    try settings.putNoClobber(client.allocator, "skip_std_references", .{ .bool = true }); // references collection into std is very slow
+    try settings.putNoClobber(client.allocator, "zig_exe_path", .{ .string = client.zig_path });
 
-    try client.sendNotification("workspace/didChangeConfiguration", lsp.types.DidChangeConfigurationParams{
+    try client.sendNotification("workspace/didChangeConfiguration", lsp.types.workspace.configuration.did_change.Params{
         .settings = .{ .object = settings },
     });
 
-    try client.sendNotification("textDocument/didOpen", lsp.types.DidOpenTextDocumentParams{ .textDocument = .{
+    try client.sendNotification("textDocument/didOpen", lsp.types.TextDocument.DidOpenParams{ .textDocument = .{
         .uri = client.text_document_uri,
-        .languageId = "zig",
+        .languageId = .{ .custom_value = "zig" },
         .version = 0,
         .text = "",
     } });
@@ -108,6 +112,7 @@ fn sendRequest(
     params: lsp.ParamsType(method),
 ) !void {
     try client.transport().writeRequest(
+        client.io,
         client.allocator,
         id,
         method,
@@ -116,6 +121,7 @@ fn sendRequest(
         .{ .emit_null_optional_fields = false },
     );
     try utils.waitForResponseToRequest(
+        client.io,
         client.allocator,
         client.transport(),
         id,
@@ -128,6 +134,7 @@ fn sendNotification(
     params: lsp.ParamsType(method),
 ) !void {
     try client.transport().writeNotification(
+        client.io,
         client.allocator,
         method,
         lsp.ParamsType(method),

src/Fuzzer.zig

@@ -44,6 +44,7 @@ pub const Config = struct {
     }
 };
 
+io: std.Io,
 allocator: std.mem.Allocator,
 mode: *Mode,
 config: *const Config,
@@ -53,28 +54,36 @@ cycle: usize = 0,
 client: Client,
 rand: std.Random.DefaultPrng,
 pending_request_ids: std.AutoArrayHashMapUnmanaged(i64, void) = .empty,
-text_document: lsp.types.TextDocumentItem,
+text_document: lsp.types.TextDocument,
 
 pub fn init(
+    io: std.Io,
     allocator: std.mem.Allocator,
+    environ_map: *const std.process.Environ.Map,
     mode: *Mode,
     config: *const Config,
 ) !Fuzzer {
     var client: Client = try .init(
+        io,
         allocator,
+        environ_map,
         config.zls_path,
         config.zig_env.zig_exe,
-        if (config.seed != null) .Inherit else .Ignore,
+        if (config.seed != null) .inherit else .ignore,
     );
-    errdefer _ = client.child_process.kill() catch @panic("failed to kill ZLS process");
+    errdefer client.child_process.kill(io);
 
-    const seed = config.seed orelse std.crypto.random.int(u64);
+    const rng_impl: std.Random.IoSource = .{ .io = io };
+    const rng = rng_impl.interface();
+
+    const seed = config.seed orelse rng.int(u64);
 
     var pending_request_ids: std.AutoArrayHashMapUnmanaged(i64, void) = .empty;
     try pending_request_ids.ensureTotalCapacity(allocator, config.cycles_per_gen);
     errdefer pending_request_ids.deinit(allocator);
 
     return .{
+        .io = io,
         .allocator = allocator,
         .mode = mode,
         .config = config,
@@ -85,7 +94,7 @@ pub fn init(
         .pending_request_ids = pending_request_ids,
         .text_document = .{
             .uri = client.text_document_uri,
-            .languageId = "zig",
+            .languageId = .{ .custom_value = "zig" },
             .version = 0,
             .text = "",
         },
@@ -104,6 +113,7 @@ pub fn fuzz(fuzzer: *Fuzzer) (lsp.Transport.WriteError || lsp.Transport.ReadErro
 
     if (fuzzer.cycle % fuzzer.config.cycles_per_gen == 0) {
         try utils.waitForResponseToRequests(
+            fuzzer.io,
             fuzzer.allocator,
             &fuzzer.client.stdio_transport.transport,
             &fuzzer.pending_request_ids,
@@ -120,22 +130,24 @@ pub fn fuzz(fuzzer: *Fuzzer) (lsp.Transport.WriteError || lsp.Transport.ReadErro
 
         fuzzer.text_document.version += 1;
         try fuzzer.client.transport().writeNotification(
+            fuzzer.io,
             fuzzer.allocator,
             "textDocument/didChange",
-            lsp.types.DidChangeTextDocumentParams,
+            lsp.types.TextDocument.DidChangeParams,
             .{
                 .textDocument = .{ .uri = fuzzer.text_document.uri, .version = fuzzer.text_document.version },
-                .contentChanges = &[1]lsp.types.TextDocumentContentChangeEvent{
-                    .{ .literal_1 = .{ .text = fuzzer.text_document.text } },
+                .contentChanges = &[1]lsp.types.TextDocument.ContentChangeEvent{
+                    .{ .text_document_content_change_whole_document = .{ .text = fuzzer.text_document.text } },
                 },
             },
             .{ .emit_null_optional_fields = false },
         );
     }
 
     const id, const json_message = try utils.fuzzFeatureRandom(
-        fuzzer.client.transport(),
+        fuzzer.io,
         fuzzer.allocator,
+        fuzzer.client.transport(),
         fuzzer.text_document,
         fuzzer.rand.random(),
     );

src/Reducer.zig

@@ -8,19 +8,23 @@ const Client = @import("Client.zig");
 const lsp = @import("lsp");
 
 pub fn reduce(
+    io: std.Io,
     allocator: std.mem.Allocator,
+    environ_map: *const std.process.Environ.Map,
     mode: *Mode,
     config: *const Fuzzer.Config,
     seed: u64,
     progress_node: std.Progress.Node,
 ) !void {
     var client: Client = try .init(
+        io,
         allocator,
+        environ_map,
         config.zls_path,
         config.zig_env.zig_exe,
-        .Pipe,
+        .pipe,
     );
-    errdefer _ = client.child_process.kill() catch @panic("failed to kill ZLS process");
+    errdefer client.child_process.kill(io);
 
     try client.initialize();
 
@@ -29,6 +33,7 @@ pub fn reduce(
 
     var keep_running_stderr: std.atomic.Value(bool) = .init(true);
     const stderr_thread: std.Thread = try .spawn(.{}, readStderr, .{
+        io,
         allocator,
         client.child_process.stderr.?,
         &stderr,
@@ -40,9 +45,9 @@ pub fn reduce(
     }
 
     var rand: std.Random.DefaultPrng = .init(seed);
-    var text_document: lsp.types.TextDocumentItem = .{
+    var text_document: lsp.types.TextDocument = .{
         .uri = client.text_document_uri,
-        .languageId = "zig",
+        .languageId = .{ .custom_value = "zig" },
         .version = 0,
         .text = "",
     };
@@ -62,28 +67,30 @@ pub fn reduce(
 
             text_document.version += 1;
             try client.transport().writeNotification(
+                io,
                 allocator,
                 "textDocument/didChange",
-                lsp.types.DidChangeTextDocumentParams,
+                lsp.types.TextDocument.DidChangeParams,
                 .{
                     .textDocument = .{ .uri = text_document.uri, .version = text_document.version },
-                    .contentChanges = &[1]lsp.types.TextDocumentContentChangeEvent{
-                        .{ .literal_1 = .{ .text = text_document.text } },
+                    .contentChanges = &[1]lsp.types.TextDocument.ContentChangeEvent{
+                        .{ .text_document_content_change_whole_document = .{ .text = text_document.text } },
                     },
                 },
                 .{ .emit_null_optional_fields = false },
             );
         }
 
         const id, const json_message = try utils.fuzzFeatureRandom(
-            client.transport(),
+            io,
             allocator,
+            client.transport(),
             text_document,
             rand.random(),
         );
         errdefer allocator.free(json_message);
 
-        utils.waitForResponseToRequest(client.allocator, client.transport(), id) catch |err| switch (err) {
+        utils.waitForResponseToRequest(io, allocator, client.transport(), id) catch |err| switch (err) {
             error.EndOfStream => break json_message,
             else => |e| return e,
         };
@@ -98,6 +105,8 @@ pub fn reduce(
     else
         stderr.items;
 
+    const now: std.Io.Timestamp = .now(io, .awake);
+
     if (config.rpc) {
         var data = [_][]const u8{
             std.mem.asBytes(&@as(u32, @intCast(
@@ -109,7 +118,7 @@ pub fn reduce(
                     2 + processed_stderr.len,
             ))),
 
-            std.mem.asBytes(&std.time.milliTimestamp()),
+            std.mem.asBytes(&now.toMilliseconds()),
 
             std.mem.asBytes(&@as(u8, @intCast(config.zig_env.version.len))),
             config.zig_env.version,
@@ -127,22 +136,22 @@ pub fn reduce(
             processed_stderr,
         };
 
-        var file_writer = std.fs.File.stdout().writer(&.{});
+        var file_writer = std.Io.File.stdout().writer(io, &.{});
         try file_writer.interface.writeVecAll(&data);
     } else {
-        var logs_dir = try std.fs.cwd().makeOpenPath("saved_logs", .{});
-        defer logs_dir.close();
+        var logs_dir = try std.Io.Dir.cwd().createDirPathOpen(io, "saved_logs", .{});
+        defer logs_dir.close(io);
 
         const file_name = std.fmt.hex(seed) ++ ".md";
-        const entry_file = try logs_dir.createFile(file_name, .{});
-        defer entry_file.close();
+        const entry_file = try logs_dir.createFile(io, file_name, .{});
+        defer entry_file.close(io);
 
-        var file_writer = entry_file.writer(&.{});
+        var file_writer = entry_file.writer(io, &.{});
 
         var timestamp_buf: [32]u8 = undefined;
         var data = [_][]const u8{
             "timestamp: ",
-            try std.fmt.bufPrint(&timestamp_buf, "{d}", .{std.time.milliTimestamp()}),
+            try std.fmt.bufPrint(&timestamp_buf, "{d}", .{now}),
             "\n",
             "zig version: ",
             config.zig_env.version,
@@ -164,14 +173,17 @@ pub fn reduce(
 }
 
 fn readStderr(
+    io: std.Io,
     allocator: std.mem.Allocator,
-    stderr: std.fs.File,
+    stderr: std.Io.File,
     out: *std.ArrayList(u8),
     keep_running: *std.atomic.Value(bool),
 ) void {
     var buffer: [4096]u8 = undefined;
+    var reader = stderr.reader(io, &buffer);
+    var aw: std.Io.Writer.Allocating = .fromArrayList(allocator, out);
+    defer aw.deinit();
     while (keep_running.load(.acquire)) {
-        const amt = stderr.read(&buffer) catch break;
-        out.appendSlice(allocator, buffer[0..amt]) catch break;
+        _ = reader.interface.streamRemaining(&aw.writer) catch break;
     }
 }