Merge pull request 'std: migrate all `fs` APIs to `Io`' (#30232) from std.Io-fs into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30232

1 files changed, 103 insertions, 128 deletions

diff --git a/lib/std/Build/Cache.zig b/lib/std/Build/Cache.zig
index 5e8412cfcf..b384ab13ff 100644
--- a/lib/std/Build/Cache.zig
+++ b/lib/std/Build/Cache.zig
@@ -8,7 +8,6 @@ const builtin = @import("builtin");
 const std = @import("std");
 const Io = std.Io;
 const crypto = std.crypto;
-const fs = std.fs;
 const assert = std.debug.assert;
 const testing = std.testing;
 const mem = std.mem;
@@ -18,7 +17,7 @@ const log = std.log.scoped(.cache);
 
 gpa: Allocator,
 io: Io,
-manifest_dir: fs.Dir,
+manifest_dir: Io.Dir,
 hash: HashHelper = .{},
 /// This value is accessed from multiple threads, protected by mutex.
 recent_problematic_timestamp: Io.Timestamp = .zero,
@@ -71,7 +70,7 @@ const PrefixedPath = struct {
 
 fn findPrefix(cache: *const Cache, file_path: []const u8) !PrefixedPath {
     const gpa = cache.gpa;
-    const resolved_path = try fs.path.resolve(gpa, &.{file_path});
+    const resolved_path = try std.fs.path.resolve(gpa, &.{file_path});
     errdefer gpa.free(resolved_path);
     return findPrefixResolved(cache, resolved_path);
 }
@@ -102,9 +101,9 @@ fn findPrefixResolved(cache: *const Cache, resolved_path: []u8) !PrefixedPath {
 }
 
 fn getPrefixSubpath(allocator: Allocator, prefix: []const u8, path: []u8) ![]u8 {
-    const relative = try fs.path.relative(allocator, prefix, path);
+    const relative = try std.fs.path.relative(allocator, prefix, path);
     errdefer allocator.free(relative);
-    var component_iterator = fs.path.NativeComponentIterator.init(relative);
+    var component_iterator = std.fs.path.NativeComponentIterator.init(relative);
     if (component_iterator.root() != null) {
         return error.NotASubPath;
     }
@@ -145,17 +144,17 @@ pub const File = struct {
     max_file_size: ?usize,
     /// Populated if the user calls `addOpenedFile`.
     /// The handle is not owned here.
-    handle: ?fs.File,
+    handle: ?Io.File,
     stat: Stat,
     bin_digest: BinDigest,
     contents: ?[]const u8,
 
     pub const Stat = struct {
-        inode: fs.File.INode,
+        inode: Io.File.INode,
         size: u64,
         mtime: Io.Timestamp,
 
-        pub fn fromFs(fs_stat: fs.File.Stat) Stat {
+        pub fn fromFs(fs_stat: Io.File.Stat) Stat {
             return .{
                 .inode = fs_stat.inode,
                 .size = fs_stat.size,
@@ -178,7 +177,7 @@ pub const File = struct {
         file.max_file_size = if (file.max_file_size) |old| @max(old, new) else new;
     }
 
-    pub fn updateHandle(file: *File, new_handle: ?fs.File) void {
+    pub fn updateHandle(file: *File, new_handle: ?Io.File) void {
         const handle = new_handle orelse return;
         file.handle = handle;
     }
@@ -293,16 +292,16 @@ pub fn binToHex(bin_digest: BinDigest) HexDigest {
 }
 
 pub const Lock = struct {
-    manifest_file: fs.File,
+    manifest_file: Io.File,
 
-    pub fn release(lock: *Lock) void {
+    pub fn release(lock: *Lock, io: Io) void {
         if (builtin.os.tag == .windows) {
             // Windows does not guarantee that locks are immediately unlocked when
             // the file handle is closed. See LockFileEx documentation.
-            lock.manifest_file.unlock();
+            lock.manifest_file.unlock(io);
         }
 
-        lock.manifest_file.close();
+        lock.manifest_file.close(io);
         lock.* = undefined;
     }
 };
@@ -311,7 +310,7 @@ pub const Manifest = struct {
     cache: *Cache,
     /// Current state for incremental hashing.
     hash: HashHelper,
-    manifest_file: ?fs.File,
+    manifest_file: ?Io.File,
     manifest_dirty: bool,
     /// Set this flag to true before calling hit() in order to indicate that
     /// upon a cache hit, the code using the cache will not modify the files
@@ -332,9 +331,9 @@ pub const Manifest = struct {
 
     pub const Diagnostic = union(enum) {
         none,
-        manifest_create: fs.File.OpenError,
-        manifest_read: fs.File.ReadError,
-        manifest_lock: fs.File.LockError,
+        manifest_create: Io.File.OpenError,
+        manifest_read: Io.File.Reader.Error,
+        manifest_lock: Io.File.LockError,
         file_open: FileOp,
         file_stat: FileOp,
         file_read: FileOp,
@@ -393,10 +392,10 @@ pub const Manifest = struct {
     }
 
     /// Same as `addFilePath` except the file has already been opened.
-    pub fn addOpenedFile(m: *Manifest, path: Path, handle: ?fs.File, max_file_size: ?usize) !usize {
+    pub fn addOpenedFile(m: *Manifest, path: Path, handle: ?Io.File, max_file_size: ?usize) !usize {
         const gpa = m.cache.gpa;
         try m.files.ensureUnusedCapacity(gpa, 1);
-        const resolved_path = try fs.path.resolve(gpa, &.{
+        const resolved_path = try std.fs.path.resolve(gpa, &.{
             path.root_dir.path orelse ".",
             path.subPathOrDot(),
         });
@@ -417,7 +416,7 @@ pub const Manifest = struct {
         return addFileInner(self, prefixed_path, null, max_file_size);
     }
 
-    fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, handle: ?fs.File, max_file_size: ?usize) usize {
+    fn addFileInner(self: *Manifest, prefixed_path: PrefixedPath, handle: ?Io.File, max_file_size: ?usize) usize {
         const gop = self.files.getOrPutAssumeCapacityAdapted(prefixed_path, FilesAdapter{});
         if (gop.found_existing) {
             self.cache.gpa.free(prefixed_path.sub_path);
@@ -460,7 +459,7 @@ pub const Manifest = struct {
         }
     }
 
-    pub fn addDepFile(self: *Manifest, dir: fs.Dir, dep_file_sub_path: []const u8) !void {
+    pub fn addDepFile(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {
         assert(self.manifest_file == null);
         return self.addDepFileMaybePost(dir, dep_file_sub_path);
     }
@@ -503,11 +502,13 @@ pub const Manifest = struct {
         @memcpy(manifest_file_path[0..self.hex_digest.len], &self.hex_digest);
         manifest_file_path[hex_digest_len..][0..ext.len].* = ext.*;
 
+        const io = self.cache.io;
+
         // We'll try to open the cache with an exclusive lock, but if that would block
         // and `want_shared_lock` is set, a shared lock might be sufficient, so we'll
         // open with a shared lock instead.
         while (true) {
-            if (self.cache.manifest_dir.createFile(&manifest_file_path, .{
+            if (self.cache.manifest_dir.createFile(io, &manifest_file_path, .{
                 .read = true,
                 .truncate = false,
                 .lock = .exclusive,
@@ -518,7 +519,7 @@ pub const Manifest = struct {
                 break;
             } else |err| switch (err) {
                 error.WouldBlock => {
-                    self.manifest_file = self.cache.manifest_dir.openFile(&manifest_file_path, .{
+                    self.manifest_file = self.cache.manifest_dir.openFile(io, &manifest_file_path, .{
                         .mode = .read_write,
                         .lock = .shared,
                     }) catch |e| {
@@ -542,7 +543,7 @@ pub const Manifest = struct {
                         return error.CacheCheckFailed;
                     }
 
-                    if (self.cache.manifest_dir.createFile(&manifest_file_path, .{
+                    if (self.cache.manifest_dir.createFile(io, &manifest_file_path, .{
                         .read = true,
                         .truncate = false,
                         .lock = .exclusive,
@@ -702,7 +703,7 @@ pub const Manifest = struct {
             const file_path = iter.rest();
 
             const stat_size = fmt.parseInt(u64, size, 10) catch return error.InvalidFormat;
-            const stat_inode = fmt.parseInt(fs.File.INode, inode, 10) catch return error.InvalidFormat;
+            const stat_inode = fmt.parseInt(Io.File.INode, inode, 10) catch return error.InvalidFormat;
             const stat_mtime = fmt.parseInt(i64, mtime_nsec_str, 10) catch return error.InvalidFormat;
             const file_bin_digest = b: {
                 if (digest_str.len != hex_digest_len) return error.InvalidFormat;
@@ -758,7 +759,7 @@ pub const Manifest = struct {
 
             const pp = cache_hash_file.prefixed_path;
             const dir = self.cache.prefixes()[pp.prefix].handle;
-            const this_file = dir.openFile(pp.sub_path, .{ .mode = .read_only }) catch |err| switch (err) {
+            const this_file = dir.openFile(io, pp.sub_path, .{ .mode = .read_only }) catch |err| switch (err) {
                 error.FileNotFound => {
                     // Every digest before this one has been populated successfully.
                     return .{ .miss = .{ .file_digests_populated = idx } };
@@ -772,9 +773,9 @@ pub const Manifest = struct {
                     return error.CacheCheckFailed;
                 },
             };
-            defer this_file.close();
+            defer this_file.close(io);
 
-            const actual_stat = this_file.stat() catch |err| {
+            const actual_stat = this_file.stat(io) catch |err| {
                 self.diagnostic = .{ .file_stat = .{
                     .file_index = idx,
                     .err = err,
@@ -799,7 +800,7 @@ pub const Manifest = struct {
                 }
 
                 var actual_digest: BinDigest = undefined;
-                hashFile(this_file, &actual_digest) catch |err| {
+                hashFile(io, this_file, &actual_digest) catch |err| {
                     self.diagnostic = .{ .file_read = .{
                         .file_index = idx,
                         .err = err,
@@ -872,17 +873,17 @@ pub const Manifest = struct {
         if (man.want_refresh_timestamp) {
             man.want_refresh_timestamp = false;
 
-            var file = man.cache.manifest_dir.createFile("timestamp", .{
+            var file = man.cache.manifest_dir.createFile(io, "timestamp", .{
                 .read = true,
                 .truncate = true,
             }) catch |err| switch (err) {
                 error.Canceled => return error.Canceled,
                 else => return true,
             };
-            defer file.close();
+            defer file.close(io);
 
             // Save locally and also save globally (we still hold the global lock).
-            const stat = file.stat() catch |err| switch (err) {
+            const stat = file.stat(io) catch |err| switch (err) {
                 error.Canceled => return error.Canceled,
                 else => return true,
             };
@@ -894,19 +895,24 @@ pub const Manifest = struct {
     }
 
     fn populateFileHash(self: *Manifest, ch_file: *File) !void {
+        const io = self.cache.io;
+
         if (ch_file.handle) |handle| {
             return populateFileHashHandle(self, ch_file, handle);
         } else {
             const pp = ch_file.prefixed_path;
             const dir = self.cache.prefixes()[pp.prefix].handle;
-            const handle = try dir.openFile(pp.sub_path, .{});
-            defer handle.close();
+            const handle = try dir.openFile(io, pp.sub_path, .{});
+            defer handle.close(io);
             return populateFileHashHandle(self, ch_file, handle);
         }
     }
 
-    fn populateFileHashHandle(self: *Manifest, ch_file: *File, handle: fs.File) !void {
-        const actual_stat = try handle.stat();
+    fn populateFileHashHandle(self: *Manifest, ch_file: *File, io_file: Io.File) !void {
+        const io = self.cache.io;
+        const gpa = self.cache.gpa;
+
+        const actual_stat = try io_file.stat(io);
         ch_file.stat = .{
             .size = actual_stat.size,
             .mtime = actual_stat.mtime,
@@ -920,19 +926,17 @@ pub const Manifest = struct {
         }
 
         if (ch_file.max_file_size) |max_file_size| {
-            if (ch_file.stat.size > max_file_size) {
-                return error.FileTooBig;
-            }
+            if (ch_file.stat.size > max_file_size) return error.FileTooBig;
 
-            const contents = try self.cache.gpa.alloc(u8, @as(usize, @intCast(ch_file.stat.size)));
-            errdefer self.cache.gpa.free(contents);
+            // Hash while reading from disk, to keep the contents in the cpu
+            // cache while doing hashing.
+            const contents = try gpa.alloc(u8, @intCast(ch_file.stat.size));
+            errdefer gpa.free(contents);
 
-            // Hash while reading from disk, to keep the contents in the cpu cache while
-            // doing hashing.
             var hasher = hasher_init;
             var off: usize = 0;
             while (true) {
-                const bytes_read = try handle.pread(contents[off..], off);
+                const bytes_read = try io_file.readPositional(io, &.{contents[off..]}, off);
                 if (bytes_read == 0) break;
                 hasher.update(contents[off..][0..bytes_read]);
                 off += bytes_read;
@@ -941,7 +945,7 @@ pub const Manifest = struct {
 
             ch_file.contents = contents;
         } else {
-            try hashFile(handle, &ch_file.bin_digest);
+            try hashFile(io, io_file, &ch_file.bin_digest);
         }
 
         self.hash.hasher.update(&ch_file.bin_digest);
@@ -1064,14 +1068,15 @@ pub const Manifest = struct {
         self.hash.hasher.update(&new_file.bin_digest);
     }
 
-    pub fn addDepFilePost(self: *Manifest, dir: fs.Dir, dep_file_sub_path: []const u8) !void {
+    pub fn addDepFilePost(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {
         assert(self.manifest_file != null);
         return self.addDepFileMaybePost(dir, dep_file_sub_path);
     }
 
-    fn addDepFileMaybePost(self: *Manifest, dir: fs.Dir, dep_file_sub_path: []const u8) !void {
+    fn addDepFileMaybePost(self: *Manifest, dir: Io.Dir, dep_file_sub_path: []const u8) !void {
         const gpa = self.cache.gpa;
-        const dep_file_contents = try dir.readFileAlloc(dep_file_sub_path, gpa, .limited(manifest_file_size_max));
+        const io = self.cache.io;
+        const dep_file_contents = try dir.readFileAlloc(io, dep_file_sub_path, gpa, .limited(manifest_file_size_max));
         defer gpa.free(dep_file_contents);
 
         var error_buf: std.ArrayList(u8) = .empty;
@@ -1130,13 +1135,13 @@ pub const Manifest = struct {
     /// lock from exclusive to shared.
     pub fn writeManifest(self: *Manifest) !void {
         assert(self.have_exclusive_lock);
-
+        const io = self.cache.io;
         const manifest_file = self.manifest_file.?;
         if (self.manifest_dirty) {
             self.manifest_dirty = false;
 
             var buffer: [4000]u8 = undefined;
-            var fw = manifest_file.writer(&buffer);
+            var fw = manifest_file.writer(io, &buffer);
             writeDirtyManifestToStream(self, &fw) catch |err| switch (err) {
                 error.WriteFailed => return fw.err.?,
                 else => |e| return e,
@@ -1148,7 +1153,7 @@ pub const Manifest = struct {
         }
     }
 
-    fn writeDirtyManifestToStream(self: *Manifest, fw: *fs.File.Writer) !void {
+    fn writeDirtyManifestToStream(self: *Manifest, fw: *Io.File.Writer) !void {
         try fw.interface.writeAll(manifest_header ++ "\n");
         for (self.files.keys()) |file| {
             try fw.interface.print("{d} {d} {d} {x} {d} {s}\n", .{
@@ -1165,13 +1170,11 @@ pub const Manifest = struct {
 
     fn downgradeToSharedLock(self: *Manifest) !void {
         if (!self.have_exclusive_lock) return;
+        const io = self.cache.io;
 
-        // WASI does not currently support flock, so we bypass it here.
-        // TODO: If/when flock is supported on WASI, this check should be removed.
-        //       See https://github.com/WebAssembly/wasi-filesystem/issues/2
-        if (builtin.os.tag != .wasi or std.process.can_spawn or !builtin.single_threaded) {
+        if (std.process.can_spawn or !builtin.single_threaded) {
             const manifest_file = self.manifest_file.?;
-            try manifest_file.downgradeLock();
+            try manifest_file.downgradeLock(io);
         }
 
         self.have_exclusive_lock = false;
@@ -1180,16 +1183,14 @@ pub const Manifest = struct {
     fn upgradeToExclusiveLock(self: *Manifest) error{CacheCheckFailed}!bool {
         if (self.have_exclusive_lock) return false;
         assert(self.manifest_file != null);
+        const io = self.cache.io;
 
-        // WASI does not currently support flock, so we bypass it here.
-        // TODO: If/when flock is supported on WASI, this check should be removed.
-        //       See https://github.com/WebAssembly/wasi-filesystem/issues/2
-        if (builtin.os.tag != .wasi or std.process.can_spawn or !builtin.single_threaded) {
+        if (std.process.can_spawn or !builtin.single_threaded) {
             const manifest_file = self.manifest_file.?;
             // Here we intentionally have a period where the lock is released, in case there are
             // other processes holding a shared lock.
-            manifest_file.unlock();
-            manifest_file.lock(.exclusive) catch |err| {
+            manifest_file.unlock(io);
+            manifest_file.lock(io, .exclusive) catch |err| {
                 self.diagnostic = .{ .manifest_lock = err };
                 return error.CacheCheckFailed;
             };
@@ -1202,25 +1203,23 @@ pub const Manifest = struct {
     /// The `Manifest` remains safe to deinit.
     /// Don't forget to call `writeManifest` before this!
     pub fn toOwnedLock(self: *Manifest) Lock {
-        const lock: Lock = .{
-            .manifest_file = self.manifest_file.?,
-        };
-
-        self.manifest_file = null;
-        return lock;
+        defer self.manifest_file = null;
+        return .{ .manifest_file = self.manifest_file.? };
     }
 
     /// Releases the manifest file and frees any memory the Manifest was using.
     /// `Manifest.hit` must be called first.
     /// Don't forget to call `writeManifest` before this!
     pub fn deinit(self: *Manifest) void {
+        const io = self.cache.io;
+
         if (self.manifest_file) |file| {
             if (builtin.os.tag == .windows) {
                 // See Lock.release for why this is required on Windows
-                file.unlock();
+                file.unlock(io);
             }
 
-            file.close();
+            file.close(io);
         }
         for (self.files.keys()) |*file| {
             file.deinit(self.cache.gpa);
@@ -1278,57 +1277,33 @@ pub const Manifest = struct {
     }
 };
 
-/// On operating systems that support symlinks, does a readlink. On other operating systems,
-/// uses the file contents. Windows supports symlinks but only with elevated privileges, so
-/// it is treated as not supporting symlinks.
-pub fn readSmallFile(dir: fs.Dir, sub_path: []const u8, buffer: []u8) ![]u8 {
-    if (builtin.os.tag == .windows) {
-        return dir.readFile(sub_path, buffer);
-    } else {
-        return dir.readLink(sub_path, buffer);
-    }
-}
-
-/// On operating systems that support symlinks, does a symlink. On other operating systems,
-/// uses the file contents. Windows supports symlinks but only with elevated privileges, so
-/// it is treated as not supporting symlinks.
-/// `data` must be a valid UTF-8 encoded file path and 255 bytes or fewer.
-pub fn writeSmallFile(dir: fs.Dir, sub_path: []const u8, data: []const u8) !void {
-    assert(data.len <= 255);
-    if (builtin.os.tag == .windows) {
-        return dir.writeFile(.{ .sub_path = sub_path, .data = data });
-    } else {
-        return dir.symLink(data, sub_path, .{});
-    }
-}
-
-fn hashFile(file: fs.File, bin_digest: *[Hasher.mac_length]u8) fs.File.PReadError!void {
-    var buf: [1024]u8 = undefined;
+fn hashFile(io: Io, file: Io.File, bin_digest: *[Hasher.mac_length]u8) Io.File.ReadPositionalError!void {
+    var buffer: [2048]u8 = undefined;
     var hasher = hasher_init;
-    var off: u64 = 0;
+    var offset: u64 = 0;
     while (true) {
-        const bytes_read = try file.pread(&buf, off);
-        if (bytes_read == 0) break;
-        hasher.update(buf[0..bytes_read]);
-        off += bytes_read;
+        const n = try file.readPositional(io, &.{&buffer}, offset);
+        if (n == 0) break;
+        hasher.update(buffer[0..n]);
+        offset += n;
     }
     hasher.final(bin_digest);
 }
 
 // Create/Write a file, close it, then grab its stat.mtime timestamp.
-fn testGetCurrentFileTimestamp(dir: fs.Dir) !Io.Timestamp {
+fn testGetCurrentFileTimestamp(io: Io, dir: Io.Dir) !Io.Timestamp {
     const test_out_file = "test-filetimestamp.tmp";
 
-    var file = try dir.createFile(test_out_file, .{
+    var file = try dir.createFile(io, test_out_file, .{
         .read = true,
         .truncate = true,
     });
     defer {
-        file.close();
-        dir.deleteFile(test_out_file) catch {};
+        file.close(io);
+        dir.deleteFile(io, test_out_file) catch {};
     }
 
-    return (try file.stat()).mtime;
+    return (try file.stat(io)).mtime;
 }
 
 test "cache file and then recall it" {
@@ -1340,11 +1315,11 @@ test "cache file and then recall it" {
     const temp_file = "test.txt";
     const temp_manifest_dir = "temp_manifest_dir";
 
-    try tmp.dir.writeFile(.{ .sub_path = temp_file, .data = "Hello, world!\n" });
+    try tmp.dir.writeFile(io, .{ .sub_path = temp_file, .data = "Hello, world!\n" });
 
     // Wait for file timestamps to tick
-    const initial_time = try testGetCurrentFileTimestamp(tmp.dir);
-    while ((try testGetCurrentFileTimestamp(tmp.dir)).nanoseconds == initial_time.nanoseconds) {
+    const initial_time = try testGetCurrentFileTimestamp(io, tmp.dir);
+    while ((try testGetCurrentFileTimestamp(io, tmp.dir)).nanoseconds == initial_time.nanoseconds) {
         try std.Io.Clock.Duration.sleep(.{ .clock = .boot, .raw = .fromNanoseconds(1) }, io);
     }
 
@@ -1355,10 +1330,10 @@ test "cache file and then recall it" {
         var cache: Cache = .{
             .io = io,
             .gpa = testing.allocator,
-            .manifest_dir = try tmp.dir.makeOpenPath(temp_manifest_dir, .{}),
+            .manifest_dir = try tmp.dir.createDirPathOpen(io, temp_manifest_dir, .{}),
         };
         cache.addPrefix(.{ .path = null, .handle = tmp.dir });
-        defer cache.manifest_dir.close();
+        defer cache.manifest_dir.close(io);
 
         {
             var ch = cache.obtain();
@@ -1406,11 +1381,11 @@ test "check that changing a file makes cache fail" {
     const original_temp_file_contents = "Hello, world!\n";
     const updated_temp_file_contents = "Hello, world; but updated!\n";
 
-    try tmp.dir.writeFile(.{ .sub_path = temp_file, .data = original_temp_file_contents });
+    try tmp.dir.writeFile(io, .{ .sub_path = temp_file, .data = original_temp_file_contents });
 
     // Wait for file timestamps to tick
-    const initial_time = try testGetCurrentFileTimestamp(tmp.dir);
-    while ((try testGetCurrentFileTimestamp(tmp.dir)).nanoseconds == initial_time.nanoseconds) {
+    const initial_time = try testGetCurrentFileTimestamp(io, tmp.dir);
+    while ((try testGetCurrentFileTimestamp(io, tmp.dir)).nanoseconds == initial_time.nanoseconds) {
         try std.Io.Clock.Duration.sleep(.{ .clock = .boot, .raw = .fromNanoseconds(1) }, io);
     }
 
@@ -1421,10 +1396,10 @@ test "check that changing a file makes cache fail" {
         var cache: Cache = .{
             .io = io,
             .gpa = testing.allocator,
-            .manifest_dir = try tmp.dir.makeOpenPath(temp_manifest_dir, .{}),
+            .manifest_dir = try tmp.dir.createDirPathOpen(io, temp_manifest_dir, .{}),
         };
         cache.addPrefix(.{ .path = null, .handle = tmp.dir });
-        defer cache.manifest_dir.close();
+        defer cache.manifest_dir.close(io);
 
         {
             var ch = cache.obtain();
@@ -1443,7 +1418,7 @@ test "check that changing a file makes cache fail" {
             try ch.writeManifest();
         }
 
-        try tmp.dir.writeFile(.{ .sub_path = temp_file, .data = updated_temp_file_contents });
+        try tmp.dir.writeFile(io, .{ .sub_path = temp_file, .data = updated_temp_file_contents });
 
         {
             var ch = cache.obtain();
@@ -1481,10 +1456,10 @@ test "no file inputs" {
     var cache: Cache = .{
         .io = io,
         .gpa = testing.allocator,
-        .manifest_dir = try tmp.dir.makeOpenPath(temp_manifest_dir, .{}),
+        .manifest_dir = try tmp.dir.createDirPathOpen(io, temp_manifest_dir, .{}),
     };
     cache.addPrefix(.{ .path = null, .handle = tmp.dir });
-    defer cache.manifest_dir.close();
+    defer cache.manifest_dir.close(io);
 
     {
         var man = cache.obtain();
@@ -1523,12 +1498,12 @@ test "Manifest with files added after initial hash work" {
     const temp_file2 = "cache_hash_post_file_test2.txt";
     const temp_manifest_dir = "cache_hash_post_file_manifest_dir";
 
-    try tmp.dir.writeFile(.{ .sub_path = temp_file1, .data = "Hello, world!\n" });
-    try tmp.dir.writeFile(.{ .sub_path = temp_file2, .data = "Hello world the second!\n" });
+    try tmp.dir.writeFile(io, .{ .sub_path = temp_file1, .data = "Hello, world!\n" });
+    try tmp.dir.writeFile(io, .{ .sub_path = temp_file2, .data = "Hello world the second!\n" });
 
     // Wait for file timestamps to tick
-    const initial_time = try testGetCurrentFileTimestamp(tmp.dir);
-    while ((try testGetCurrentFileTimestamp(tmp.dir)).nanoseconds == initial_time.nanoseconds) {
+    const initial_time = try testGetCurrentFileTimestamp(io, tmp.dir);
+    while ((try testGetCurrentFileTimestamp(io, tmp.dir)).nanoseconds == initial_time.nanoseconds) {
         try std.Io.Clock.Duration.sleep(.{ .clock = .boot, .raw = .fromNanoseconds(1) }, io);
     }
 
@@ -1540,10 +1515,10 @@ test "Manifest with files added after initial hash work" {
         var cache: Cache = .{
             .io = io,
             .gpa = testing.allocator,
-            .manifest_dir = try tmp.dir.makeOpenPath(temp_manifest_dir, .{}),
+            .manifest_dir = try tmp.dir.createDirPathOpen(io, temp_manifest_dir, .{}),
         };
         cache.addPrefix(.{ .path = null, .handle = tmp.dir });
-        defer cache.manifest_dir.close();
+        defer cache.manifest_dir.close(io);
 
         {
             var ch = cache.obtain();
@@ -1575,11 +1550,11 @@ test "Manifest with files added after initial hash work" {
         try testing.expect(mem.eql(u8, &digest1, &digest2));
 
         // Modify the file added after initial hash
-        try tmp.dir.writeFile(.{ .sub_path = temp_file2, .data = "Hello world the second, updated\n" });
+        try tmp.dir.writeFile(io, .{ .sub_path = temp_file2, .data = "Hello world the second, updated\n" });
 
         // Wait for file timestamps to tick
-        const initial_time2 = try testGetCurrentFileTimestamp(tmp.dir);
-        while ((try testGetCurrentFileTimestamp(tmp.dir)).nanoseconds == initial_time2.nanoseconds) {
+        const initial_time2 = try testGetCurrentFileTimestamp(io, tmp.dir);
+        while ((try testGetCurrentFileTimestamp(io, tmp.dir)).nanoseconds == initial_time2.nanoseconds) {
             try std.Io.Clock.Duration.sleep(.{ .clock = .boot, .raw = .fromNanoseconds(1) }, io);
         }