refactor: upgrade to Zig v0.15.1

The first commit targets porting the entire codebase to Zig v0.15.1
compiler and stdlib. However there are still a lot of unsolved logic
errors. Further commits will address those

Author: AMythicDev

build.zig

@@ -10,6 +10,7 @@ pub fn build(b: *std.Build) !void {
     if (default_os.isBSD() or default_os.isDarwin() or default_os == std.Target.Os.Tag.linux) {
         common.link_libc = true;
     }
+    const zip = b.dependency("zip", .{});
 
     const strip = if (optimize == std.builtin.OptimizeMode.ReleaseSafe) true else null;
 
@@ -22,6 +23,8 @@ pub fn build(b: *std.Build) !void {
         }) },
     );
     zigverm.subsystem = .Console;
+    zigverm.root_module.addImport("zip", zip.module("zip"));
+
     const zig = b.addExecutable(.{ .name = "zig", .root_module = b.createModule(.{
         .root_source_file = b.path("src/zig/main.zig"),
         .target = target,

build.zig.zon

@@ -1,7 +1,13 @@
 .{
     .name = .zigverm,
-    .version = "0.6.2",
-    .minimum_zig_version = "0.11.0",
+    .version = "0.7.0",
+    .dependencies = .{
+        .zip = .{
+            .url = "https://github.com/AMythicDev/zip.zig/archive/refs/tags/v0.3.0.tar.gz",
+            .hash = "zip-0.3.0-eQGR_4tTAAAOUDb0yPv2-cdgLuXIrDsnRroGc9SLZ78p",
+        },
+    },
+    .minimum_zig_version = "0.15.1",
     .fingerprint = 0xffdf55ceb1c7efde,
 
     .paths = .{

src/common/overrides.zig

@@ -3,6 +3,7 @@ const Allocator = std.mem.Allocator;
 const StringArrayHashMap = std.StringArrayHashMap;
 const json = std.json;
 const CommonPaths = @import("paths.zig").CommonPaths;
+const File = std.fs.File;
 
 pub const OverrideMap = struct {
     backing_map: json.ObjectMap,
@@ -51,8 +52,9 @@ pub const OverrideMap = struct {
 };
 
 pub fn read_overrides(alloc: Allocator, cp: CommonPaths) !OverrideMap {
-    var file_bufreader = std.io.bufferedReader(cp.overrides.reader());
-    const file_reader = file_bufreader.reader();
+    var buf: [4096]u8 = undefined;
+    var file_bufreader = File.Reader.init(cp.overrides, &buf);
+    const file_reader = &file_bufreader.interface;
 
     var overrides = OverrideMap{ .backing_map = json.ObjectMap.init(alloc), .allocator = alloc };
 
@@ -62,7 +64,7 @@ pub fn read_overrides(alloc: Allocator, cp: CommonPaths) !OverrideMap {
     // by checking if there bytes can be read and then resetting the file cursor back to 0.
     if (try cp.overrides.getEndPos() != 0) {
         try cp.overrides.seekTo(0);
-        var json_reader = json.reader(alloc, file_reader);
+        var json_reader = json.Reader.init(alloc, file_reader);
         const parsed = try json.parseFromTokenSource(json.Value, alloc, &json_reader, .{});
         defer {
             json_reader.deinit();
@@ -87,9 +89,11 @@ pub fn write_overrides(overrides: OverrideMap, cp: CommonPaths) !void {
     // isn't any weird byte writings at the beginning of the file.
     try cp.overrides.seekTo(0);
     try cp.overrides.setEndPos(0);
-    var file_writer = std.io.bufferedWriter(cp.overrides.writer());
+    var buf: [4096]u8 = undefined;
+    var file_writer = cp.overrides.writer(&buf);
+    const intf = &file_writer.interface;
 
-    try json.stringify(json.Value{ .object = overrides.backing_map }, .{ .whitespace = .indent_2 }, file_writer.writer());
-    _ = try file_writer.write("\n");
-    try file_writer.flush();
+    try json.Stringify.value(json.Value{ .object = overrides.backing_map }, .{ .whitespace = .indent_2 }, intf);
+    _ = try intf.write("\n");
+    try file_writer.end();
 }

src/common/root.zig

@@ -12,6 +12,7 @@ const RelError = error{
     InvalidVersionSpec,
     Overflow,
     OutOfMemory,
+    WriteFailed,
 };
 
 pub const ReleaseSpec = union(enum) { Master, Stable, MajorMinorVersionSpec: []const u8, FullVersionSpec: []const u8 };
@@ -28,9 +29,11 @@ pub const Release = struct {
             ReleaseSpec.FullVersionSpec => |v| return try alloc.dupe(u8, v),
             else => {
                 if (self.actual_version == null) @panic("actual_version() called without resolving");
-                var buffer = std.ArrayList(u8).init(alloc);
-                defer buffer.deinit();
-                try self.actual_version.?.format("", .{}, buffer.writer());
+                var buffer: std.ArrayListUnmanaged(u8) = .empty;
+                defer buffer.deinit(alloc);
+                var writer = std.Io.Writer.Allocating.fromArrayList(alloc, &buffer);
+                const intf = &writer.writer;
+                try self.actual_version.?.format(intf);
                 return try alloc.dupe(u8, buffer.items);
             },
         }
@@ -98,13 +101,15 @@ pub const Release = struct {
 
     pub inline fn completeSpec(spec: []const u8) RelError!std.SemanticVersion {
         const count = std.mem.count(u8, spec, ".");
-        var buffer = try std.BoundedArray(u8, 24).fromSlice(spec);
+        var buf: [24]u8 = undefined;
+        var buffer = std.ArrayListUnmanaged(u8).initBuffer(&buf);
+        try buffer.appendSliceBounded(spec);
 
         if (count == 2)
             return std.SemanticVersion.parse(spec) catch return RelError.InvalidVersionSpec
         else if (count == 1) {
-            try buffer.appendSlice(".0");
-            return std.SemanticVersion.parse(buffer.slice()) catch return RelError.InvalidVersionSpec;
+            try buffer.appendSliceBounded(".0");
+            return std.SemanticVersion.parse(buffer.items) catch return RelError.InvalidVersionSpec;
         } else return RelError.InvalidVersionSpec;
     }
 };

src/install.zig

@@ -14,6 +14,7 @@ const Sha256 = std.crypto.hash.sha2.Sha256;
 const release_name = common.release_name;
 const AtomicOrder = std.builtin.AtomicOrder;
 const time = std.time;
+const File = std.fs.File;
 
 const default_os = builtin.target.os.tag;
 const default_arch = builtin.target.cpu.arch;
@@ -43,11 +44,13 @@ pub fn install_release(alloc: Allocator, client: *Client, releases: json.Value,
     var tarball = try get_correct_tarball(alloc, client, tarball_dw_filename, tarball_url, total_size, shasum, cp, 0);
     defer tarball.close();
 
-    var tarball_reader = std.io.bufferedReader(tarball.reader());
+    var buf: [4096]u8 = undefined;
+    var tarball_reader = tarball.reader(&buf);
+    const tbl_intf = &tarball_reader.interface;
 
     std.log.info("Extracting {s}", .{tarball_dw_filename});
     try cp.install_dir.deleteTree(try release_name(alloc, rel.*));
-    try extract_xz(alloc, cp, rel.*, tarball_reader.reader());
+    try extract_xz(alloc, cp, rel.*, tbl_intf);
 
     try cp.download_dir.deleteFile(tarball_dw_filename);
 }
@@ -58,11 +61,13 @@ fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: [
     // open the file with .truncate = false and then later move the file cursor to the end of the file using seekFromEnd().
     // This is basically Zig's equivalent to *open in append mode*.
     var tarball = try cp.download_dir.createFile(tarball_dw_filename, .{ .read = true, .truncate = force_redownload });
-    const tarball_size = if (force_redownload) 0 else (try tarball.metadata()).size();
+    const tarball_size = if (force_redownload) 0 else try tarball.getEndPos();
+
+    var buf: [4096]u8 = undefined;
 
     if (tarball_size < total_size or force_redownload) {
         try tarball.seekTo(tarball_size);
-        var tarball_writer = std.io.bufferedWriter(tarball.writer());
+        var tarball_writer = tarball.writer(&buf);
         try download_tarball(
             alloc,
             client,
@@ -76,8 +81,9 @@ fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: [
         std.log.info("Found already existing tarball, using that", .{});
     }
 
-    var tarball_reader = std.io.bufferedReader(tarball.reader());
-    const hash_matched = try check_hash(shasum, tarball_reader.reader());
+    var tarball_reader = tarball.reader(&buf);
+    const tbl_intf = &tarball_reader.interface;
+    const hash_matched = try check_hash(shasum, tbl_intf);
 
     if (!hash_matched) {
         if (tries < 3) {
@@ -92,7 +98,7 @@ fn get_correct_tarball(alloc: Allocator, client: *Client, tarball_dw_filename: [
     return tarball;
 }
 
-pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, tb_writer: anytype, tarball_size: u64, total_size: usize) !void {
+pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, tb_writer: *std.fs.File.Writer, tarball_size: u64, total_size: usize) !void {
     std.log.info("Downloading {s}", .{tb_url});
     const tarball_uri = try std.Uri.parse(tb_url);
 
@@ -105,17 +111,15 @@ pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, t
 
     // Attach the Range header for partial downloads
     if (tarball_size > 0) {
-        var size = std.ArrayList(u8).init(alloc);
-        try size.appendSlice("bytes=");
-        var size_writer = size.writer();
-        try std.fmt.formatInt(tarball_size, 10, .lower, .{}, &size_writer);
-        try size.append('-');
+        var size: std.ArrayListUnmanaged(u8) = .empty;
+        try size.print(alloc, "bytes={}-", .{tarball_size});
         req.?.extra_headers = &.{http.Header{ .name = "Range", .value = size.items }};
     }
 
-    try req.?.send();
-    try req.?.wait();
-    var reader = req.?.reader();
+    try req.?.sendBodiless();
+    var response = try req.?.receiveHead(&.{});
+
+    var reader = response.reader(&.{});
 
     var buff: [1024]u8 = undefined;
 
@@ -125,21 +129,24 @@ pub fn download_tarball(alloc: Allocator, client: *Client, tb_url: []const u8, t
     const tarball_size_d: f64 = @floatFromInt(tarball_size);
 
     const progress_thread = try std.Thread.spawn(.{}, download_progress_bar, .{ &dlnow, tarball_size_d, total_size_d });
+    const tbw_intf = &tb_writer.interface;
     while (tarball_size_d + dlnow.load(AtomicOrder.monotonic) <= total_size_d) {
-        const len = try reader.read(&buff);
+        const len = try reader.readSliceShort(&buff);
         if (len == 0) {
             break;
         }
-        _ = try tb_writer.write(buff[0..len]);
+        _ = try tbw_intf.write(buff[0..len]);
 
         _ = dlnow.fetchAdd(@floatFromInt(len), AtomicOrder.monotonic);
     }
     progress_thread.join();
-    try tb_writer.flush();
+    try tb_writer.end();
 }
 
 pub fn download_progress_bar(dlnow: *std.atomic.Value(f32), tarball_size: f64, total_size: f64) !void {
-    var stderr_writer = std.io.getStdErr().writer();
+    const stderr = std.fs.File.stderr();
+    var stderrw = std.fs.File.Writer.init(stderr, &.{});
+    const stderr_writer = &stderrw.interface;
     var progress_bar: [150]u8 = ("░" ** 50).*;
     var bars: u8 = 0;
     var timer = try time.Timer.start();
@@ -157,7 +164,7 @@ pub fn download_progress_bar(dlnow: *std.atomic.Value(f32), tarball_size: f64, t
 
         if (downloaded + tarball_size >= total_size) break;
 
-        std.time.sleep(500 * time.ns_per_ms);
+        std.Thread.sleep(500 * time.ns_per_ms);
         downloaded = dlnow.load(AtomicOrder.monotonic);
     }
     try stderr_writer.print("\n", .{});
@@ -174,40 +181,39 @@ pub fn get_json_dslist(client: *Client) anyerror!JsonResponse {
         std.process.exit(1);
     }
 
-    try req.?.send();
-    try req.?.wait();
+    try req.?.sendBodiless();
+    var response = try req.?.receiveHead(&.{});
 
     var json_buff: [1024 * 100]u8 = undefined;
-    const bytes_read = try req.?.reader().readAll(&json_buff);
+    const res_r = response.reader(&.{});
+    const bytes_read = try res_r.readSliceShort(&json_buff);
 
     return JsonResponse{ .body = json_buff, .length = bytes_read };
 }
 
 pub fn make_request(client: *Client, uri: std.Uri) ?Client.Request {
+    // TODO: REMOVE THIS IF UNUSED
     var http_header_buff: [8192]u8 = undefined;
+    _ = &http_header_buff;
     for (0..5) |i| {
-        const tryreq = client.open(
-            http.Method.GET,
-            uri,
-            Client.RequestOptions{ .server_header_buffer = &http_header_buff },
-        );
+        const tryreq = client.request(http.Method.GET, uri, .{});
         if (tryreq) |r| {
             return r;
         } else |err| {
             std.log.warn("{}. Retrying again [{}/5]", .{ err, i + 1 });
-            std.time.sleep(std.time.ns_per_ms * 500);
+            std.Thread.sleep(std.time.ns_per_ms * 500);
         }
     }
     return null;
 }
 
-pub fn check_hash(hashstr: *const [64]u8, reader: anytype) !bool {
+pub fn check_hash(hashstr: *const [64]u8, reader: *std.Io.Reader) !bool {
     var buff: [1024]u8 = undefined;
 
     var hasher = Sha256.init(.{});
 
     while (true) {
-        const len = try reader.read(&buff);
+        const len = try reader.readSliceShort(&buff);
         if (len == 0) {
             break;
         }
@@ -218,10 +224,14 @@ pub fn check_hash(hashstr: *const [64]u8, reader: anytype) !bool {
     return std.mem.eql(u8, &hasher.finalResult(), &hash);
 }
 
-inline fn extract_xz(alloc: Allocator, dirs: CommonPaths, rel: Release, reader: anytype) !void {
-    var xz = try std.compress.xz.decompress(alloc, reader);
+inline fn extract_xz(alloc: Allocator, dirs: CommonPaths, rel: Release, reader: *std.Io.Reader) !void {
+    // HACK: Use the older interface until Zig upgrades this
+    const r = reader.adaptToOldInterface();
+    var xz = try std.compress.xz.decompress(alloc, r);
     const release_dir = try dirs.install_dir.makeOpenPath(try release_name(alloc, rel), .{});
-    try std.tar.pipeToFileSystem(release_dir, xz.reader(), .{ .strip_components = 1 });
+    var adpt = xz.reader().adaptToNewApi(&.{});
+    const intf = &adpt.new_interface;
+    try std.tar.pipeToFileSystem(release_dir, intf, .{ .strip_components = 1 });
 }
 
 pub fn target_name() []const u8 {

src/main.zig

@@ -98,9 +98,9 @@ fn open_std(alloc: Allocator, cp: CommonPaths, ver: ?[]const u8) !void {
         "zig",
     });
 
-    var executable = std.ArrayList([]const u8).init(alloc);
-    try executable.append(zig_path);
-    try executable.append("std");
+    var executable: std.ArrayListUnmanaged([]const u8) = .empty;
+    try executable.append(alloc, zig_path);
+    try executable.append(alloc, "std");
     var child = std.process.Child.init(executable.items, alloc);
     const term = try child.spawnAndWait();
     std.process.exit(term.Exited);
@@ -132,9 +132,9 @@ fn open_reference(alloc: Allocator, cp: CommonPaths, ver: ?[]const u8) !void {
         else => "xdg-open",
     };
 
-    var executable = std.ArrayList([]const u8).init(alloc);
-    try executable.append(main_exe);
-    try executable.append(langref_path);
+    var executable: std.ArrayListUnmanaged([]const u8) = .empty;
+    try executable.append(alloc, main_exe);
+    try executable.append(alloc, langref_path);
     var child = std.process.Child.init(executable.items, alloc);
     try child.spawn();
 }
@@ -199,14 +199,14 @@ fn override_rm(alloc: Allocator, cp: CommonPaths, directory: []const u8) !void {
 
 fn installed_versions(alloc: Allocator, cp: CommonPaths) ![][]const u8 {
     var iter = cp.install_dir.iterate();
-    var versions = std.ArrayList([]const u8).init(alloc);
+    var versions: std.ArrayList([]const u8) = .empty;
     while (try iter.next()) |i| {
         if (!utils.check_install_name(i.name)) continue;
         var components = std.mem.splitScalar(u8, i.name[4..], '-');
         _ = components.next();
         _ = components.next();
         const version = components.next() orelse unreachable;
-        try versions.append(try alloc.dupe(u8, version));
+        try versions.append(alloc, try alloc.dupe(u8, version));
     }
     return versions.items;
 }
@@ -238,8 +238,8 @@ fn update_zig_installation(alloc: Allocator, cp: CommonPaths, version_possible:
         versions = @constCast(&[1][]const u8{v});
     } else versions = try installed_versions(alloc, cp);
 
-    var updated_now = std.ArrayList([]const u8).init(alloc);
-    var already_update = std.ArrayList([]const u8).init(alloc);
+    var updated_now: std.ArrayList([]const u8) = .empty;
+    var already_update: std.ArrayList([]const u8) = .empty;
     var client = Client{ .allocator = alloc };
     defer client.deinit();
     const resp = try install.get_json_dslist(&client);
@@ -270,21 +270,21 @@ fn update_zig_installation(alloc: Allocator, cp: CommonPaths, version_possible:
             } else {
                 var zig_version = try std.SemanticVersion.parse((try get_version_from_exe(alloc, release_name)).items);
                 var format_buf: [32]u8 = undefined;
-                var format_buf_stream = std.io.fixedBufferStream(&format_buf);
+                var format_buf_stream = std.Io.Writer.fixed(&format_buf);
                 zig_version.patch += 1;
-                try zig_version.format("", .{}, format_buf_stream.writer());
-                to_update = releases.object.contains(format_buf_stream.getWritten());
-                while (releases.object.contains(format_buf_stream.getWritten())) {
+                try zig_version.format(&format_buf_stream);
+                to_update = releases.object.contains(format_buf_stream.buffered());
+                while (releases.object.contains(format_buf_stream.buffered())) {
                     zig_version.patch += 1;
-                    try format_buf_stream.seekTo(0);
-                    try zig_version.format("", .{}, format_buf_stream.writer());
+                    format_buf_stream.end = 0;
+                    try zig_version.format(&format_buf_stream);
                 }
             }
             if (to_update) {
-                try updated_now.append(v);
+                try updated_now.append(alloc, v);
                 try install.install_release(alloc, &client, releases, &rel, cp);
             } else {
-                try already_update.append(v);
+                try already_update.append(alloc, v);
             }
         } else |_| {
             try install.install_release(alloc, &client, releases, &rel, cp);