Migrate to Zig 0.16

build.zig

@@ -220,7 +220,7 @@ fn addCliTests(b: *std.Build, exe: *std.Build.Step.Compile, test_step: *std.Buil
         run.setStdIn(.{ .bytes = case.stdin });
         for (case.args) |arg| run.addArg(arg);
         run.expectExitCode(1);
-        _ = run.captureStdErr();
+        _ = run.captureStdErr(.{});
         test_step.dependOn(&run.step);
     }
 }

build.zig.zon

@@ -1,8 +1,8 @@
 .{
     .name = .comb,
-    .version = "1.0.1",
+    .version = "1.2.0",
     .fingerprint = 0x38b31e72dca1cc4b,
-    .minimum_zig_version = "0.15.2",
+    .minimum_zig_version = "0.16.0",
     .dependencies = .{},
     .paths = .{
         "build.zig",

src/Parser.zig

@@ -623,7 +623,7 @@ fn parseBlockMappingKey(self: *Parser) opts.Error!Value {
         self.pos += 1;
     }
 
-    const raw = std.mem.trimRight(u8, self.input[start..self.pos], " \t");
+    const raw = std.mem.trimEnd(u8, self.input[start..self.pos], " \t");
     return .{ .string = raw };
 }
 
@@ -990,7 +990,7 @@ fn parseFlowValue(self: *Parser) opts.Error!Value {
             self.pos += 1;
         }
 
-        const raw = std.mem.trimRight(u8, self.input[start..self.pos], " \t");
+        const raw = std.mem.trimEnd(u8, self.input[start..self.pos], " \t");
         if (raw.len > 0) {
             parts.append(self.allocator, raw) catch return error.OutOfMemory;
         }
@@ -1059,7 +1059,7 @@ fn parseFlowKey(self: *Parser) opts.Error!Value {
             self.pos += 1;
         }
 
-        const raw = std.mem.trimRight(u8, self.input[start..self.pos], " \t");
+        const raw = std.mem.trimEnd(u8, self.input[start..self.pos], " \t");
         if (raw.len > 0) {
             parts.append(self.allocator, raw) catch return error.OutOfMemory;
         }
@@ -1143,7 +1143,7 @@ fn parseBlockScalar(self: *Parser, parent_indent: ?usize) opts.Error!Value {
         if (line.len > 0 and line[0] == '\t')
             return self.fail("TabInIndentation");
 
-        const stripped = std.mem.trimLeft(u8, line, " ");
+        const stripped = std.mem.trimStart(u8, line, " ");
         if (stripped.len == 0) {
             if (content_indent == null and line.len > last_empty_indent)
                 last_empty_indent = line.len;
@@ -1341,7 +1341,7 @@ fn readValueLine(self: *Parser) []const u8 {
         if (self.input[self.pos] == '#' and self.pos > start and (self.input[self.pos - 1] == ' ' or self.input[self.pos - 1] == '\t')) break;
         self.pos += 1;
     }
-    return std.mem.trimRight(u8, self.input[start..self.pos], " \t");
+    return std.mem.trimEnd(u8, self.input[start..self.pos], " \t");
 }
 
 // ── Quoted strings ──────────────────────────────────────────────────────

src/Renderer.zig

@@ -11,13 +11,13 @@ const Entry = value_mod.Entry;
 
 /// Render a `Value` as a normalized YAML string.
 pub fn render(allocator: Allocator, value: Value, options: opts.OutputOptions) opts.Error![]const u8 {
-    var out: std.io.Writer.Allocating = .init(allocator);
+    var out: std.Io.Writer.Allocating = .init(allocator);
     errdefer out.deinit();
     renderValue(allocator, &out.writer, value, 0, options, false) catch return error.OutOfMemory;
     return out.toOwnedSlice() catch return error.OutOfMemory;
 }
 
-fn renderValue(allocator: Allocator, writer: *std.io.Writer, value: Value, indent_level: usize, options: opts.OutputOptions, inline_first: bool) !void {
+fn renderValue(allocator: Allocator, writer: *std.Io.Writer, value: Value, indent_level: usize, options: opts.OutputOptions, inline_first: bool) !void {
     switch (value) {
         .string => |s| try renderString(writer, s),
         .integer => |i| try writer.print("{d}", .{i}),
@@ -116,7 +116,7 @@ fn renderValue(allocator: Allocator, writer: *std.io.Writer, value: Value, inden
     }
 }
 
-fn renderString(writer: *std.io.Writer, s: []const u8) !void {
+fn renderString(writer: *std.Io.Writer, s: []const u8) !void {
     if (s.len == 0) {
         try writer.writeAll("''");
         return;
@@ -198,7 +198,7 @@ fn isCollection(value: Value) bool {
     };
 }
 
-fn writeIndent(writer: *std.io.Writer, level: usize, indent_size: u8) !void {
+fn writeIndent(writer: *std.Io.Writer, level: usize, indent_size: u8) !void {
     try writer.splatByteAll(' ', level * indent_size);
 }
 

src/Value.zig

@@ -55,8 +55,8 @@ pub const Value = union(enum) {
                 return .{ .array = json_arr };
             },
             .object => |entries| {
-                var map = json.ObjectMap.init(allocator);
-                try map.ensureTotalCapacity(@intCast(entries.len));
+                var map: json.ObjectMap = .empty;
+                try map.ensureTotalCapacity(allocator, @intCast(entries.len));
                 for (entries) |entry| {
                     const key_str = try entry.key.toKeyString(allocator);
                     const val = try entry.value.toStdJsonValue(allocator);
@@ -83,7 +83,7 @@ pub const Value = union(enum) {
             .null_val => allocator.dupe(u8, "null"),
             else => {
                 const jv = try self.toStdJsonValue(allocator);
-                var out: std.io.Writer.Allocating = .init(allocator);
+                var out: std.Io.Writer.Allocating = .init(allocator);
                 errdefer out.deinit();
                 var jw: json.Stringify = .{ .writer = &out.writer, .options = .{} };
                 jw.write(jv) catch return error.OutOfMemory;
@@ -256,7 +256,7 @@ test "toStdJsonValue: object" {
     };
     const result = try (Value{ .object = &entries }).toStdJsonValue(alloc);
     var m = result.object;
-    defer m.deinit();
+    defer m.deinit(alloc);
 
     try std.testing.expectEqualStrings("Alice", m.get("name").?.string);
     try std.testing.expectEqual(@as(i64, 30), m.get("age").?.integer);

src/main.zig

@@ -5,13 +5,19 @@ const std = @import("std");
 const comb = @import("comb");
 
 /// Entry point. Parses CLI arguments, reads YAML, and writes output.
-pub fn main() !void {
+pub fn main(init: std.process.Init.Minimal) !void {
     const allocator = std.heap.page_allocator;
     var arena = std.heap.ArenaAllocator.init(allocator);
     defer arena.deinit();
     const alloc = arena.allocator();
+    const io = std.Io.Threaded.global_single_threaded.io();
 
-    const args = try std.process.argsAlloc(alloc);
+    var args_iter = std.process.Args.Iterator.init(init.args);
+    var args_list: std.ArrayListUnmanaged([]const u8) = .empty;
+    while (args_iter.next()) |arg| {
+        try args_list.append(alloc, try alloc.dupe(u8, arg));
+    }
+    const args = args_list.items;
 
     var file_path: ?[]const u8 = null;
     var mode: enum { json_compact, json_pretty, yaml } = .json_compact;
@@ -24,7 +30,7 @@ pub fn main() !void {
     while (i < args.len) : (i += 1) {
         const arg = args[i];
         if (std.mem.eql(u8, arg, "--help") or std.mem.eql(u8, arg, "-h")) {
-            try printUsage();
+            try printUsage(io);
             return;
         } else if (std.mem.eql(u8, arg, "--pretty")) {
             mode = .json_pretty;
@@ -57,21 +63,21 @@ pub fn main() !void {
     }
 
     const input = if (file_path) |path|
-        std.fs.cwd().readFileAlloc(alloc, path, 10 * 1024 * 1024) catch |err| {
+        std.Io.Dir.readFileAlloc(std.Io.Dir.cwd(), io, path, alloc, .limited(10 * 1024 * 1024)) catch |err| {
             std.debug.print("error: cannot read '{s}': {}\n", .{ path, err });
             std.process.exit(1);
         }
     else blk: {
         var stdin_buf: [4096]u8 = undefined;
-        var stdin_r = std.fs.File.stdin().reader(&stdin_buf);
+        var stdin_r = std.Io.File.stdin().reader(io, &stdin_buf);
         break :blk stdin_r.interface.allocRemaining(alloc, .limited(10 * 1024 * 1024)) catch |err| {
             std.debug.print("error: cannot read stdin: {}\n", .{err});
             std.process.exit(1);
         };
     };
 
     var stdout_buf: [4096]u8 = undefined;
-    var stdout_w = std.fs.File.stdout().writer(&stdout_buf);
+    var stdout_w = std.Io.File.stdout().writer(io, &stdout_buf);
     const stdout = &stdout_w.interface;
     defer stdout.flush() catch {};
 
@@ -163,9 +169,9 @@ pub fn main() !void {
     }
 }
 
-fn printUsage() !void {
+fn printUsage(io: std.Io) !void {
     var buf: [4096]u8 = undefined;
-    var w = std.fs.File.stdout().writer(&buf);
+    var w = std.Io.File.stdout().writer(io, &buf);
     const stdout = &w.interface;
     defer stdout.flush() catch {};
     try stdout.writeAll(

src/root.zig

@@ -119,7 +119,7 @@ pub fn valueToJson(allocator: Allocator, value: Value, options: OutputOptions) e
     else
         try value.toStdJsonValue(aa);
 
-    var out: std.io.Writer.Allocating = .init(allocator);
+    var out: std.Io.Writer.Allocating = .init(allocator);
     errdefer out.deinit();
 
     const ws = indentToWhitespace(options.indent);
@@ -134,8 +134,8 @@ fn sortedToStdJson(allocator: Allocator, value: Value) error{OutOfMemory}!std.js
         .object => |entries| {
             const sorted = try allocator.dupe(Entry, entries);
             std.mem.sortUnstable(Entry, sorted, {}, Entry.keyLessThan);
-            var map = std.json.ObjectMap.init(allocator);
-            try map.ensureTotalCapacity(@intCast(sorted.len));
+            var map: std.json.ObjectMap = .empty;
+            try map.ensureTotalCapacity(allocator, @intCast(sorted.len));
             for (sorted) |entry| {
                 const key_str = try entry.key.toKeyString(allocator);
                 const val = try sortedToStdJson(allocator, entry.value);

src/yaml_suite_runner.zig

@@ -214,7 +214,7 @@ fn parseMultiJsonValues(allocator: Allocator, json_str: []const u8) ![]JsonParse
     var remaining = json_str;
 
     while (true) {
-        remaining = mem.trimLeft(u8, remaining, " \t\n\r");
+        remaining = mem.trimStart(u8, remaining, " \t\n\r");
         if (remaining.len == 0) break;
 
         const end_pos = findJsonValueEnd(remaining) orelse return error.OutOfMemory;
@@ -314,37 +314,40 @@ fn jsonEqual(a: std.json.Value, b: std.json.Value) bool {
 
 test "YAML Test Suite conformance" {
     const alloc = std.testing.allocator;
+    const io = std.testing.io;
 
-    var suite_dir = std.fs.cwd().openDir("test/yaml-test-suite", .{ .iterate = true }) catch |err| {
+    var suite_dir = std.Io.Dir.openDir(std.Io.Dir.cwd(), io, "test/yaml-test-suite", .{ .iterate = true }) catch |err| {
         std.debug.print("\n  Could not open test/yaml-test-suite: {}\n", .{err});
         return;
     };
-    defer suite_dir.close();
+    defer suite_dir.close(io);
 
     var total = TestResults{};
 
     var dir_it = suite_dir.iterate();
-    while (dir_it.next() catch null) |entry| {
+    while (dir_it.next(io) catch null) |entry| {
         if (entry.kind != .file) continue;
         if (!mem.endsWith(u8, entry.name, ".test")) continue;
 
         var arena = std.heap.ArenaAllocator.init(alloc);
         defer arena.deinit();
         const aa = arena.allocator();
 
-        const content = suite_dir.readFileAlloc(aa, entry.name, 4 * 1024 * 1024) catch continue;
+        const content = std.Io.Dir.readFileAlloc(suite_dir, io, entry.name, aa, .limited(4 * 1024 * 1024)) catch continue;
         const cases = parseTestFile(aa, content) catch continue;
 
         for (cases) |tc| {
             runSingleCase(aa, tc, &total);
         }
     }
 
-    std.debug.print("\n  YAML Test Suite: {d} passed, {d} failed ({d} total)\n\n", .{
-        total.passed,
-        total.failed,
-        total.total(),
-    });
+    if (total.failed > 0) {
+        std.debug.print("\n  YAML Test Suite: {d} passed, {d} failed ({d} total)\n\n", .{
+            total.passed,
+            total.failed,
+            total.total(),
+        });
+    }
 
     try std.testing.expectEqual(@as(usize, 0), total.failed);
 }