chore: Update to zig 0.16.0

.gitignore

@@ -1,2 +1,3 @@
 .zig-cache
 zig-out
+zig-pkg

build.zig.zon

@@ -1,7 +1,7 @@
 .{
     .name = .dipm,
     .version = "0.32.0",
-    .minimum_zig_version = "0.16.0-dev.2145+ec25b1384",
+    .minimum_zig_version = "0.16.0",
     .fingerprint = 0xce3a2bf46fc8eacf,
     .dependencies = .{
         .spaghet = .{

src/Diagnostics.zig

@@ -1,5 +1,6 @@
+io: std.Io,
 arena_alloc: std.heap.ArenaAllocator,
-lock: std.Thread.Mutex,
+lock: std.Io.Mutex,
 
 successes: struct {
     donate: std.ArrayListUnmanaged(PackageDonate),
@@ -25,30 +26,31 @@ failures: struct {
     generic_error: std.ArrayListUnmanaged(GenericError),
 },
 
-pub fn init(alloc: std.mem.Allocator) Diagnostics {
+pub fn init(io: std.Io, alloc: std.mem.Allocator) Diagnostics {
     return .{
+        .io = io,
         .arena_alloc = std.heap.ArenaAllocator.init(alloc),
-        .lock = .{},
+        .lock = .init,
         .successes = .{
-            .donate = .{},
-            .installs = .{},
-            .updates = .{},
-            .uninstalls = .{},
+            .donate = .empty,
+            .installs = .empty,
+            .updates = .empty,
+            .uninstalls = .empty,
         },
         .warnings = .{
-            .already_installed = .{},
-            .not_installed = .{},
-            .not_found = .{},
-            .not_found_for_target = .{},
-            .up_to_date = .{},
+            .already_installed = .empty,
+            .not_installed = .empty,
+            .not_found = .empty,
+            .not_found_for_target = .empty,
+            .up_to_date = .empty,
         },
         .failures = .{
-            .no_version_found = .{},
-            .hash_mismatches = .{},
-            .downloads = .{},
-            .downloads_with_status = .{},
-            .path_already_exists = .{},
-            .generic_error = .{},
+            .no_version_found = .empty,
+            .hash_mismatches = .empty,
+            .downloads = .empty,
+            .downloads_with_status = .empty,
+            .path_already_exists = .empty,
+            .generic_error = .empty,
         },
     };
 }
@@ -87,8 +89,8 @@ pub const ReportOptions = struct {
 };
 
 pub fn report(diag: *Diagnostics, writer: *std.Io.Writer, opt: ReportOptions) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
 
     const esc = opt.escapes;
     inline for (@typeInfo(@TypeOf(diag.successes)).@"struct".fields) |field| {
@@ -121,8 +123,8 @@ pub fn hasFailed(diag: Diagnostics) bool {
 }
 
 pub fn donate(diag: *Diagnostics, pkg: PackageDonate) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.successes.donate.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
         .version = try diag.arena().dupe(u8, pkg.version),
@@ -131,17 +133,17 @@ pub fn donate(diag: *Diagnostics, pkg: PackageDonate) !void {
 }
 
 pub fn installSucceeded(diag: *Diagnostics, pkg: PackageInstall) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.successes.installs.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
         .version = try diag.arena().dupe(u8, pkg.version),
     });
 }
 
 pub fn updateSucceeded(diag: *Diagnostics, pkg: PackageFromTo) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.successes.updates.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
         .from_version = try diag.arena().dupe(u8, pkg.from_version),
@@ -150,68 +152,68 @@ pub fn updateSucceeded(diag: *Diagnostics, pkg: PackageFromTo) !void {
 }
 
 pub fn uninstallSucceeded(diag: *Diagnostics, pkg: PackageUninstall) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.successes.uninstalls.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
         .version = try diag.arena().dupe(u8, pkg.version),
     });
 }
 
 pub fn alreadyInstalled(diag: *Diagnostics, pkg: PackageAlreadyInstalled) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.warnings.already_installed.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
     });
 }
 
 pub fn notInstalled(diag: *Diagnostics, pkg: PackageNotInstalled) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.warnings.not_installed.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
     });
 }
 
 pub fn notFound(diag: *Diagnostics, pkg: PackageNotFound) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.warnings.not_found.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
     });
 }
 
 pub fn notFoundForTarget(diag: *Diagnostics, not_found: PackageTarget) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.warnings.not_found_for_target.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, not_found.name),
         .target = not_found.target,
     });
 }
 
 pub fn upToDate(diag: *Diagnostics, pkg: PackageUpToDate) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.warnings.up_to_date.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
         .version = try diag.arena().dupe(u8, pkg.version),
     });
 }
 
 pub fn noVersionFound(diag: *Diagnostics, pkg: PackageError) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.failures.no_version_found.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, pkg.name),
         .err = pkg.err,
     });
 }
 
 pub fn hashMismatch(diag: *Diagnostics, mismatch: HashMismatch) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.failures.hash_mismatches.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, mismatch.name),
         .version = try diag.arena().dupe(u8, mismatch.version),
@@ -221,8 +223,8 @@ pub fn hashMismatch(diag: *Diagnostics, mismatch: HashMismatch) !void {
 }
 
 pub fn downloadFailed(diag: *Diagnostics, failure: DownloadFailed) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.failures.downloads.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, failure.name),
         .version = try diag.arena().dupe(u8, failure.version),
@@ -232,8 +234,8 @@ pub fn downloadFailed(diag: *Diagnostics, failure: DownloadFailed) !void {
 }
 
 pub fn downloadFailedWithStatus(diag: *Diagnostics, failure: DownloadFailedWithStatus) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.failures.downloads_with_status.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, failure.name),
         .version = try diag.arena().dupe(u8, failure.version),
@@ -243,17 +245,17 @@ pub fn downloadFailedWithStatus(diag: *Diagnostics, failure: DownloadFailedWithS
 }
 
 pub fn pathAlreadyExists(diag: *Diagnostics, failure: PathAlreadyExists) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.failures.path_already_exists.append(diag.gpa(), .{
         .name = try diag.arena().dupe(u8, failure.name),
         .path = try diag.arena().dupe(u8, failure.path),
     });
 }
 
 pub fn genericError(diag: *Diagnostics, failure: GenericError) !void {
-    diag.lock.lock();
-    defer diag.lock.unlock();
+    try diag.lock.lock(diag.io);
+    defer diag.lock.unlock(diag.io);
     return diag.failures.generic_error.append(diag.gpa(), .{
         .id = try diag.arena().dupe(u8, failure.id),
         .msg = try diag.arena().dupe(u8, failure.msg),

src/InstalledPackages.zig

@@ -1,5 +1,5 @@
 arena_alloc: std.heap.ArenaAllocator,
-by_name: std.StringArrayHashMapUnmanaged(InstalledPackage),
+by_name: std.array_hash_map.String(InstalledPackage),
 
 file: ?std.Io.File,
 

src/Package.zig

@@ -1055,7 +1055,7 @@ fn testFromGithub(options: struct {
     try cwd.writeFile(io, .{
         .sub_path = latest_release_file_path,
         .data = blk: {
-            var out = std.ArrayList(u8){};
+            var out = std.ArrayList(u8).empty;
             try out.appendSlice(arena, "{\"tag_name\": \"");
             try out.appendSlice(arena, options.tag_name);
             try out.appendSlice(arena, "\",\"assets\": [{");
@@ -1247,7 +1247,7 @@ fn findBinaries(
     );
     const script_result = try std.process.run(arena, io, .{
         .argv = &.{ "sh", "-c", shell_script },
-        .cwd_dir = dir,
+        .cwd = .{ .dir = dir },
     });
 
     // Deduplicate binaries by their basename
@@ -1423,15 +1423,15 @@ test findShare {
 }
 
 fn findManPages(io: std.Io, arena: std.mem.Allocator, dir: std.Io.Dir) ![]const []const u8 {
-    var res = std.StringArrayHashMap([]const u8).init(arena);
+    var res = std.array_hash_map.String([]const u8).empty;
 
     var walker = try dir.walk(arena);
     while (try walker.next(io)) |file_entry| {
         if (file_entry.kind != .file)
             continue;
 
         const section = path.isManPage(file_entry.basename) orelse continue;
-        const res_entry = try res.getOrPut(file_entry.basename);
+        const res_entry = try res.getOrPut(arena, file_entry.basename);
         if (!res_entry.found_existing)
             res_entry.key_ptr.* = try arena.dupe(u8, file_entry.basename);
 

src/PackageManager.zig

@@ -110,7 +110,7 @@ fn packages(pm: *PackageManager) !*const Packages {
 }
 
 pub fn installMany(pm: *PackageManager, pkg_names: []const []const u8) !void {
-    var pkgs_not_installed = std.ArrayList([]const u8){};
+    var pkgs_not_installed = std.ArrayList([]const u8).empty;
     defer pkgs_not_installed.deinit(pm.gpa);
 
     try pkgs_not_installed.ensureTotalCapacity(pm.gpa, pkg_names.len);
@@ -126,7 +126,7 @@ pub fn installMany(pm: *PackageManager, pkg_names: []const []const u8) !void {
         return;
 
     var pkgs_to_install = try pm.pkgsToInstall(pkgs_not_installed.items);
-    defer pkgs_to_install.deinit();
+    defer pkgs_to_install.deinit(pm.gpa);
 
     const global_progress = switch (pkgs_to_install.count()) {
         0 => return,
@@ -173,14 +173,14 @@ pub fn installMany(pm: *PackageManager, pkg_names: []const []const u8) !void {
     try pm.installed.flush(pm.io);
 }
 
-const PkgsToInstall = std.StringArrayHashMap(Package.Specific);
+const PkgsToInstall = std.array_hash_map.String(Package.Specific);
 
 fn pkgsToInstall(pm: *PackageManager, pkg_names: []const []const u8) !PkgsToInstall {
-    var pkgs_to_install = std.StringArrayHashMap(Package.Specific).init(pm.gpa);
-    errdefer pkgs_to_install.deinit();
+    var pkgs_to_install = std.array_hash_map.String(Package.Specific).empty;
+    errdefer pkgs_to_install.deinit(pm.gpa);
 
     // First, deduplicate. The value is undefined and set later
-    try pkgs_to_install.ensureTotalCapacity(pkg_names.len);
+    try pkgs_to_install.ensureTotalCapacity(pm.gpa, pkg_names.len);
     for (pkg_names) |pkg_name|
         pkgs_to_install.putAssumeCapacity(pkg_name, undefined);
 
@@ -292,7 +292,7 @@ fn installExtractedPackage(
     from_dir: std.Io.Dir,
     pkg: Package.Specific,
 ) !void {
-    var locations = std.ArrayList([]const u8){};
+    var locations = std.ArrayList([]const u8).empty;
     try locations.ensureUnusedCapacity(pm.installed.arena(), pkg.install.install_bin.len +
         pkg.install.install_lib.len +
         pkg.install.install_share.len);
@@ -431,7 +431,7 @@ fn installFile(
 
 pub fn uninstallMany(pm: *PackageManager, pkg_names: []const []const u8) !void {
     var pkgs_to_uninstall = try pm.pkgsToUninstall(pkg_names);
-    defer pkgs_to_uninstall.deinit();
+    defer pkgs_to_uninstall.deinit(pm.gpa);
 
     for (pkgs_to_uninstall.keys(), pkgs_to_uninstall.values()) |pkg_name, pkg| {
         try pm.uninstallOneUnchecked(pkg_name, pkg);
@@ -444,11 +444,11 @@ pub fn uninstallMany(pm: *PackageManager, pkg_names: []const []const u8) !void {
 fn pkgsToUninstall(
     pm: *PackageManager,
     pkg_names: []const []const u8,
-) !std.StringArrayHashMap(InstalledPackage) {
-    var pkgs_to_uninstall = std.StringArrayHashMap(InstalledPackage).init(pm.gpa);
-    errdefer pkgs_to_uninstall.deinit();
+) !std.array_hash_map.String(InstalledPackage) {
+    var pkgs_to_uninstall = std.array_hash_map.String(InstalledPackage).empty;
+    errdefer pkgs_to_uninstall.deinit(pm.gpa);
 
-    try pkgs_to_uninstall.ensureTotalCapacity(pkg_names.len);
+    try pkgs_to_uninstall.ensureTotalCapacity(pm.gpa, pkg_names.len);
     for (pkg_names) |pkg_name| {
         const pkg = pm.installed.by_name.get(pkg_name) orelse {
             try pm.diag.notInstalled((.{ .name = pkg_name }));
@@ -502,10 +502,10 @@ fn updatePackages(pm: *PackageManager, pkg_names: []const []const u8, options: s
     force: bool,
 }) !void {
     var pkgs_to_uninstall = try pm.pkgsToUninstall(pkg_names);
-    defer pkgs_to_uninstall.deinit();
+    defer pkgs_to_uninstall.deinit(pm.gpa);
 
     var pkgs_to_install = try pm.pkgsToInstall(pkgs_to_uninstall.keys());
-    defer pkgs_to_install.deinit();
+    defer pkgs_to_install.deinit(pm.gpa);
 
     const pkgs = try pm.packages();
     if (!options.force) {
@@ -583,7 +583,7 @@ fn updatePackages(pm: *PackageManager, pkg_names: []const []const u8, options: s
 }
 
 const DownloadAndExtractJobs = struct {
-    jobs: std.ArrayList(DownloadAndExtractJob) = .{},
+    jobs: std.ArrayList(DownloadAndExtractJob) = .empty,
 
     fn init(options: struct {
         io: std.Io,

src/Packages.zig

@@ -1,5 +1,5 @@
 arena_alloc: std.heap.ArenaAllocator,
-by_name: std.StringArrayHashMapUnmanaged(Package),
+by_name: std.array_hash_map.String(Package),
 
 pub fn init(gpa: std.mem.Allocator) Packages {
     return .{ .arena_alloc = .init(gpa), .by_name = .{} };
@@ -219,7 +219,7 @@ fn parseInfo(pkgs: *Packages, parser: *ini.Parser) !struct {
 } {
     var parsed = parser.next();
 
-    var donate = std.ArrayList([]const u8){};
+    var donate = std.ArrayList([]const u8).empty;
     var version: ?[]const u8 = null;
     var description: []const u8 = "";