update all occurrences of close() to close(io)

21 files changed, 298 insertions, 246 deletions

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 931a0b2d14..df64dee19f 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -721,13 +721,13 @@ pub const Directories = struct {
     /// This may be the same as `global_cache`.
     local_cache: Cache.Directory,
 
-    pub fn deinit(dirs: *Directories) void {
+    pub fn deinit(dirs: *Directories, io: Io) void {
         // The local and global caches could be the same.
         const close_local = dirs.local_cache.handle.fd != dirs.global_cache.handle.fd;
 
-        dirs.global_cache.handle.close();
-        if (close_local) dirs.local_cache.handle.close();
-        dirs.zig_lib.handle.close();
+        dirs.global_cache.handle.close(io);
+        if (close_local) dirs.local_cache.handle.close(io);
+        dirs.zig_lib.handle.close(io);
     }
 
     /// Returns a `Directories` where `local_cache` is replaced with `global_cache`, intended for
@@ -1105,7 +1105,7 @@ pub const CObject = struct {
                 if (diag.src_loc.offset == 0 or diag.src_loc.column == 0) break :source_line 0;
 
                 const file = fs.cwd().openFile(file_name, .{}) catch break :source_line 0;
-                defer file.close();
+                defer file.close(io);
                 var buffer: [1024]u8 = undefined;
                 var file_reader = file.reader(io, &buffer);
                 file_reader.seekTo(diag.src_loc.offset + 1 - diag.src_loc.column) catch break :source_line 0;
@@ -1180,7 +1180,7 @@ pub const CObject = struct {
 
                 var buffer: [1024]u8 = undefined;
                 const file = try fs.cwd().openFile(path, .{});
-                defer file.close();
+                defer file.close(io);
                 var file_reader = file.reader(io, &buffer);
                 var bc = std.zig.llvm.BitcodeReader.init(gpa, .{ .reader = &file_reader.interface });
                 defer bc.deinit();
@@ -1617,13 +1617,13 @@ const CacheUse = union(CacheMode) {
         }
     };
 
-    fn deinit(cu: CacheUse) void {
+    fn deinit(cu: CacheUse, io: Io) void {
         switch (cu) {
             .none => |none| {
                 assert(none.tmp_artifact_directory == null);
             },
             .incremental => |incremental| {
-                incremental.artifact_directory.handle.close();
+                incremental.artifact_directory.handle.close(io);
             },
             .whole => |whole| {
                 assert(whole.tmp_artifact_directory == null);
@@ -2113,7 +2113,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
         cache.addPrefix(options.dirs.zig_lib);
         cache.addPrefix(options.dirs.local_cache);
         cache.addPrefix(options.dirs.global_cache);
-        errdefer cache.manifest_dir.close();
+        errdefer cache.manifest_dir.close(io);
 
         // This is shared hasher state common to zig source and all C source files.
         cache.hash.addBytes(build_options.version);
@@ -2157,7 +2157,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             var local_zir_dir = options.dirs.local_cache.handle.makeOpenPath(zir_sub_dir, .{}) catch |err| {
                 return diag.fail(.{ .create_cache_path = .{ .which = .local, .sub = zir_sub_dir, .err = err } });
             };
-            errdefer local_zir_dir.close();
+            errdefer local_zir_dir.close(io);
             const local_zir_cache: Cache.Directory = .{
                 .handle = local_zir_dir,
                 .path = try options.dirs.local_cache.join(arena, &.{zir_sub_dir}),
@@ -2165,7 +2165,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             var global_zir_dir = options.dirs.global_cache.handle.makeOpenPath(zir_sub_dir, .{}) catch |err| {
                 return diag.fail(.{ .create_cache_path = .{ .which = .global, .sub = zir_sub_dir, .err = err } });
             };
-            errdefer global_zir_dir.close();
+            errdefer global_zir_dir.close(io);
             const global_zir_cache: Cache.Directory = .{
                 .handle = global_zir_dir,
                 .path = try options.dirs.global_cache.join(arena, &.{zir_sub_dir}),
@@ -2436,7 +2436,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
                 var artifact_dir = options.dirs.local_cache.handle.makeOpenPath(artifact_sub_dir, .{}) catch |err| {
                     return diag.fail(.{ .create_cache_path = .{ .which = .local, .sub = artifact_sub_dir, .err = err } });
                 };
-                errdefer artifact_dir.close();
+                errdefer artifact_dir.close(io);
                 const artifact_directory: Cache.Directory = .{
                     .handle = artifact_dir,
                     .path = try options.dirs.local_cache.join(arena, &.{artifact_sub_dir}),
@@ -2689,6 +2689,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
 
 pub fn destroy(comp: *Compilation) void {
     const gpa = comp.gpa;
+    const io = comp.io;
 
     if (comp.bin_file) |lf| lf.destroy();
     if (comp.zcu) |zcu| zcu.deinit();
@@ -2760,7 +2761,7 @@ pub fn destroy(comp: *Compilation) void {
 
     comp.clearMiscFailures();
 
-    comp.cache_parent.manifest_dir.close();
+    comp.cache_parent.manifest_dir.close(io);
 }
 
 pub fn clearMiscFailures(comp: *Compilation) void {
@@ -2791,10 +2792,12 @@ pub fn hotCodeSwap(
 }
 
 fn cleanupAfterUpdate(comp: *Compilation, tmp_dir_rand_int: u64) void {
+    const io = comp.io;
+
     switch (comp.cache_use) {
         .none => |none| {
             if (none.tmp_artifact_directory) |*tmp_dir| {
-                tmp_dir.handle.close();
+                tmp_dir.handle.close(io);
                 none.tmp_artifact_directory = null;
                 if (dev.env == .bootstrap) {
                     // zig1 uses `CacheMode.none`, but it doesn't need to know how to delete
@@ -2834,7 +2837,7 @@ fn cleanupAfterUpdate(comp: *Compilation, tmp_dir_rand_int: u64) void {
                 comp.bin_file = null;
             }
             if (whole.tmp_artifact_directory) |*tmp_dir| {
-                tmp_dir.handle.close();
+                tmp_dir.handle.close(io);
                 whole.tmp_artifact_directory = null;
                 const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(tmp_dir_rand_int);
                 comp.dirs.local_cache.handle.deleteTree(tmp_dir_sub_path) catch |err| {
@@ -3152,7 +3155,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
                         // the file handle and re-open it in the follow up call to
                         // `makeWritable`.
                         if (lf.file) |f| {
-                            f.close();
+                            f.close(io);
                             lf.file = null;
 
                             if (lf.closeDebugInfo()) break :w .lf_and_debug;
@@ -3165,7 +3168,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) UpdateE
 
             // Rename the temporary directory into place.
             // Close tmp dir and link.File to avoid open handle during rename.
-            whole.tmp_artifact_directory.?.handle.close();
+            whole.tmp_artifact_directory.?.handle.close(io);
             whole.tmp_artifact_directory = null;
             const s = fs.path.sep_str;
             const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(tmp_dir_rand_int);
@@ -5258,6 +5261,7 @@ fn workerDocsCopy(comp: *Compilation) void {
 
 fn docsCopyFallible(comp: *Compilation) anyerror!void {
     const zcu = comp.zcu orelse return comp.lockAndSetMiscFailure(.docs_copy, "no Zig code to document", .{});
+    const io = comp.io;
 
     const docs_path = comp.resolveEmitPath(comp.emit_docs.?);
     var out_dir = docs_path.root_dir.handle.makeOpenPath(docs_path.sub_path, .{}) catch |err| {
@@ -5267,7 +5271,7 @@ fn docsCopyFallible(comp: *Compilation) anyerror!void {
             .{ docs_path, @errorName(err) },
         );
     };
-    defer out_dir.close();
+    defer out_dir.close(io);
 
     for (&[_][]const u8{ "docs/main.js", "docs/index.html" }) |sub_path| {
         const basename = fs.path.basename(sub_path);
@@ -5287,7 +5291,7 @@ fn docsCopyFallible(comp: *Compilation) anyerror!void {
             .{ docs_path, @errorName(err) },
         );
     };
-    defer tar_file.close();
+    defer tar_file.close(io);
 
     var buffer: [1024]u8 = undefined;
     var tar_file_writer = tar_file.writer(&buffer);
@@ -5331,7 +5335,7 @@ fn docsCopyModule(
     } catch |err| {
         return comp.lockAndSetMiscFailure(.docs_copy, "unable to open directory '{f}': {t}", .{ root.fmt(comp), err });
     };
-    defer mod_dir.close();
+    defer mod_dir.close(io);
 
     var walker = try mod_dir.walk(comp.gpa);
     defer walker.deinit();
@@ -5355,7 +5359,7 @@ fn docsCopyModule(
                 root.fmt(comp), entry.path, err,
             });
         };
-        defer file.close();
+        defer file.close(io);
         const stat = try file.stat();
         var file_reader: fs.File.Reader = .initSize(file.adaptToNewApi(), io, &buffer, stat.size);
 
@@ -5510,7 +5514,7 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) SubU
         );
         return error.AlreadyReported;
     };
-    defer out_dir.close();
+    defer out_dir.close(io);
 
     crt_file.full_object_path.root_dir.handle.copyFile(
         crt_file.full_object_path.sub_path,
@@ -5693,7 +5697,7 @@ pub fn translateC(
     const tmp_sub_path = "tmp" ++ fs.path.sep_str ++ tmp_basename;
     const cache_dir = comp.dirs.local_cache.handle;
     var cache_tmp_dir = try cache_dir.makeOpenPath(tmp_sub_path, .{});
-    defer cache_tmp_dir.close();
+    defer cache_tmp_dir.close(io);
 
     const translated_path = try comp.dirs.local_cache.join(arena, &.{ tmp_sub_path, translated_basename });
     const source_path = switch (source) {
@@ -6268,7 +6272,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
         // so we need a temporary filename.
         const out_obj_path = try comp.tmpFilePath(arena, o_basename);
         var zig_cache_tmp_dir = try comp.dirs.local_cache.handle.makeOpenPath("tmp", .{});
-        defer zig_cache_tmp_dir.close();
+        defer zig_cache_tmp_dir.close(io);
 
         const out_diag_path = if (comp.clang_passthrough_mode or !ext.clangSupportsDiagnostics())
             null
@@ -6433,7 +6437,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
         const digest = man.final();
         const o_sub_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest });
         var o_dir = try comp.dirs.local_cache.handle.makeOpenPath(o_sub_path, .{});
-        defer o_dir.close();
+        defer o_dir.close(io);
         const tmp_basename = fs.path.basename(out_obj_path);
         try fs.rename(zig_cache_tmp_dir, tmp_basename, o_dir, o_basename);
         break :blk digest;
@@ -6477,8 +6481,6 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
     const tracy_trace = trace(@src());
     defer tracy_trace.end();
 
-    const io = comp.io;
-
     const src_path = switch (win32_resource.src) {
         .rc => |rc_src| rc_src.src_path,
         .manifest => |src_path| src_path,
@@ -6487,6 +6489,8 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
 
     log.debug("updating win32 resource: {s}", .{src_path});
 
+    const io = comp.io;
+
     var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
@@ -6522,7 +6526,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
 
             const o_sub_path = try fs.path.join(arena, &.{ "o", &digest });
             var o_dir = try comp.dirs.local_cache.handle.makeOpenPath(o_sub_path, .{});
-            defer o_dir.close();
+            defer o_dir.close(io);
 
             const in_rc_path = try comp.dirs.local_cache.join(comp.gpa, &.{
                 o_sub_path, rc_basename,
@@ -6610,7 +6614,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
 
     const digest = if (try man.hit()) man.final() else blk: {
         var zig_cache_tmp_dir = try comp.dirs.local_cache.handle.makeOpenPath("tmp", .{});
-        defer zig_cache_tmp_dir.close();
+        defer zig_cache_tmp_dir.close(io);
 
         const res_filename = try std.fmt.allocPrint(arena, "{s}.res", .{rc_basename_noext});
 
@@ -6681,7 +6685,7 @@ fn updateWin32Resource(comp: *Compilation, win32_resource: *Win32Resource, win32
         const digest = man.final();
         const o_sub_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest });
         var o_dir = try comp.dirs.local_cache.handle.makeOpenPath(o_sub_path, .{});
-        defer o_dir.close();
+        defer o_dir.close(io);
         const tmp_basename = fs.path.basename(out_res_path);
         try fs.rename(zig_cache_tmp_dir, tmp_basename, o_dir, res_filename);
         break :blk digest;
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 9b7c83cc39..58f970abe5 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -513,7 +513,7 @@ fn runResource(
                 break :handle dir;
             },
         };
-        defer tmp_directory.handle.close();
+        defer tmp_directory.handle.close(io);
 
         // Fetch and unpack a resource into a temporary directory.
         var unpack_result = try unpackResource(f, resource, uri_path, tmp_directory);
@@ -523,7 +523,7 @@ fn runResource(
         // Apply btrfs workaround if needed. Reopen tmp_directory.
         if (native_os == .linux and f.job_queue.work_around_btrfs_bug) {
             // https://github.com/ziglang/zig/issues/17095
-            pkg_path.root_dir.handle.close();
+            pkg_path.root_dir.handle.close(io);
             pkg_path.root_dir.handle = cache_root.handle.makeOpenPath(tmp_dir_sub_path, .{
                 .iterate = true,
             }) catch @panic("btrfs workaround failed");
@@ -885,7 +885,7 @@ const Resource = union(enum) {
     file: fs.File.Reader,
     http_request: HttpRequest,
     git: Git,
-    dir: fs.Dir,
+    dir: Io.Dir,
 
     const Git = struct {
         session: git.Session,
@@ -908,7 +908,7 @@ const Resource = union(enum) {
             .git => |*git_resource| {
                 git_resource.fetch_stream.deinit();
             },
-            .dir => |*dir| dir.close(),
+            .dir => |*dir| dir.close(io),
         }
         resource.* = undefined;
     }
@@ -1247,13 +1247,14 @@ fn unpackResource(
     }
 }
 
-fn unpackTarball(f: *Fetch, out_dir: fs.Dir, reader: *Io.Reader) RunError!UnpackResult {
+fn unpackTarball(f: *Fetch, out_dir: Io.Dir, reader: *Io.Reader) RunError!UnpackResult {
     const eb = &f.error_bundle;
     const arena = f.arena.allocator();
+    const io = f.job_queue.io;
 
     var diagnostics: std.tar.Diagnostics = .{ .allocator = arena };
 
-    std.tar.pipeToFileSystem(out_dir, reader, .{
+    std.tar.pipeToFileSystem(io, out_dir, reader, .{
         .diagnostics = &diagnostics,
         .strip_components = 0,
         .mode_mode = .ignore,
@@ -1280,7 +1281,7 @@ fn unpackTarball(f: *Fetch, out_dir: fs.Dir, reader: *Io.Reader) RunError!Unpack
 
 fn unzip(
     f: *Fetch,
-    out_dir: fs.Dir,
+    out_dir: Io.Dir,
     reader: *Io.Reader,
 ) error{ ReadFailed, OutOfMemory, Canceled, FetchFailed }!UnpackResult {
     // We write the entire contents to a file first because zip files
@@ -1314,7 +1315,7 @@ fn unzip(
             ),
         };
     };
-    defer zip_file.close();
+    defer zip_file.close(io);
     var zip_file_buffer: [4096]u8 = undefined;
     var zip_file_reader = b: {
         var zip_file_writer = zip_file.writer(&zip_file_buffer);
@@ -1349,7 +1350,7 @@ fn unzip(
     return .{ .root_dir = diagnostics.root_dir };
 }
 
-fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource.Git) anyerror!UnpackResult {
+fn unpackGitPack(f: *Fetch, out_dir: Io.Dir, resource: *Resource.Git) anyerror!UnpackResult {
     const io = f.job_queue.io;
     const arena = f.arena.allocator();
     // TODO don't try to get a gpa from an arena. expose this dependency higher up
@@ -1363,9 +1364,9 @@ fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource.Git) anyerror!U
     // directory, since that isn't relevant for fetching a package.
     {
         var pack_dir = try out_dir.makeOpenPath(".git", .{});
-        defer pack_dir.close();
+        defer pack_dir.close(io);
         var pack_file = try pack_dir.createFile("pkg.pack", .{ .read = true });
-        defer pack_file.close();
+        defer pack_file.close(io);
         var pack_file_buffer: [4096]u8 = undefined;
         var pack_file_reader = b: {
             var pack_file_writer = pack_file.writer(&pack_file_buffer);
@@ -1376,7 +1377,7 @@ fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource.Git) anyerror!U
         };
 
         var index_file = try pack_dir.createFile("pkg.idx", .{ .read = true });
-        defer index_file.close();
+        defer index_file.close(io);
         var index_file_buffer: [2000]u8 = undefined;
         var index_file_writer = index_file.writer(&index_file_buffer);
         {
@@ -1393,7 +1394,7 @@ fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource.Git) anyerror!U
             try repository.init(gpa, object_format, &pack_file_reader, &index_file_reader);
             defer repository.deinit();
             var diagnostics: git.Diagnostics = .{ .allocator = arena };
-            try repository.checkout(out_dir, resource.want_oid, &diagnostics);
+            try repository.checkout(io, out_dir, resource.want_oid, &diagnostics);
 
             if (diagnostics.errors.items.len > 0) {
                 try res.allocErrors(arena, diagnostics.errors.items.len, "unable to unpack packfile");
@@ -1411,7 +1412,7 @@ fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource.Git) anyerror!U
     return res;
 }
 
-fn recursiveDirectoryCopy(f: *Fetch, dir: fs.Dir, tmp_dir: fs.Dir) anyerror!void {
+fn recursiveDirectoryCopy(f: *Fetch, dir: Io.Dir, tmp_dir: Io.Dir) anyerror!void {
     const gpa = f.arena.child_allocator;
     // Recursive directory copy.
     var it = try dir.walk(gpa);
@@ -1451,7 +1452,7 @@ fn recursiveDirectoryCopy(f: *Fetch, dir: fs.Dir, tmp_dir: fs.Dir) anyerror!void
     }
 }
 
-pub fn renameTmpIntoCache(cache_dir: fs.Dir, tmp_dir_sub_path: []const u8, dest_dir_sub_path: []const u8) !void {
+pub fn renameTmpIntoCache(cache_dir: Io.Dir, tmp_dir_sub_path: []const u8, dest_dir_sub_path: []const u8) !void {
     assert(dest_dir_sub_path[1] == fs.path.sep);
     var handled_missing_dir = false;
     while (true) {
@@ -1660,15 +1661,15 @@ fn dumpHashInfo(all_files: []const *const HashedFile) !void {
     try w.flush();
 }
 
-fn workerHashFile(dir: fs.Dir, hashed_file: *HashedFile) void {
+fn workerHashFile(dir: Io.Dir, hashed_file: *HashedFile) void {
     hashed_file.failure = hashFileFallible(dir, hashed_file);
 }
 
-fn workerDeleteFile(dir: fs.Dir, deleted_file: *DeletedFile) void {
+fn workerDeleteFile(dir: Io.Dir, deleted_file: *DeletedFile) void {
     deleted_file.failure = deleteFileFallible(dir, deleted_file);
 }
 
-fn hashFileFallible(dir: fs.Dir, hashed_file: *HashedFile) HashedFile.Error!void {
+fn hashFileFallible(io: Io, dir: Io.Dir, hashed_file: *HashedFile) HashedFile.Error!void {
     var buf: [8000]u8 = undefined;
     var hasher = Package.Hash.Algo.init(.{});
     hasher.update(hashed_file.normalized_path);
@@ -1677,7 +1678,7 @@ fn hashFileFallible(dir: fs.Dir, hashed_file: *HashedFile) HashedFile.Error!void
     switch (hashed_file.kind) {
         .file => {
             var file = try dir.openFile(hashed_file.fs_path, .{});
-            defer file.close();
+            defer file.close(io);
             // Hard-coded false executable bit: https://github.com/ziglang/zig/issues/17463
             hasher.update(&.{ 0, 0 });
             var file_header: FileHeader = .{};
@@ -1707,7 +1708,7 @@ fn hashFileFallible(dir: fs.Dir, hashed_file: *HashedFile) HashedFile.Error!void
     hashed_file.size = file_size;
 }
 
-fn deleteFileFallible(dir: fs.Dir, deleted_file: *DeletedFile) DeletedFile.Error!void {
+fn deleteFileFallible(dir: Io.Dir, deleted_file: *DeletedFile) DeletedFile.Error!void {
     try dir.deleteFile(deleted_file.fs_path);
 }
 
@@ -1724,8 +1725,8 @@ const DeletedFile = struct {
     failure: Error!void,
 
     const Error =
-        fs.Dir.DeleteFileError ||
-        fs.Dir.DeleteDirError;
+        Io.Dir.DeleteFileError ||
+        Io.Dir.DeleteDirError;
 };
 
 const HashedFile = struct {
@@ -1741,7 +1742,7 @@ const HashedFile = struct {
         fs.File.ReadError ||
         fs.File.StatError ||
         fs.File.ChmodError ||
-        fs.Dir.ReadLinkError;
+        Io.Dir.ReadLinkError;
 
     const Kind = enum { file, link };
 
@@ -2074,7 +2075,7 @@ test "tarball with duplicate paths" {
     defer tmp.cleanup();
 
     const tarball_name = "duplicate_paths.tar.gz";
-    try saveEmbedFile(tarball_name, tmp.dir);
+    try saveEmbedFile(io, tarball_name, tmp.dir);
     const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
     defer gpa.free(tarball_path);
 
@@ -2107,7 +2108,7 @@ test "tarball with excluded duplicate paths" {
     defer tmp.cleanup();
 
     const tarball_name = "duplicate_paths_excluded.tar.gz";
-    try saveEmbedFile(tarball_name, tmp.dir);
+    try saveEmbedFile(io, tarball_name, tmp.dir);
     const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
     defer gpa.free(tarball_path);
 
@@ -2153,7 +2154,7 @@ test "tarball without root folder" {
     defer tmp.cleanup();
 
     const tarball_name = "no_root.tar.gz";
-    try saveEmbedFile(tarball_name, tmp.dir);
+    try saveEmbedFile(io, tarball_name, tmp.dir);
     const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
     defer gpa.free(tarball_path);
 
@@ -2186,7 +2187,7 @@ test "set executable bit based on file content" {
     defer tmp.cleanup();
 
     const tarball_name = "executables.tar.gz";
-    try saveEmbedFile(tarball_name, tmp.dir);
+    try saveEmbedFile(io, tarball_name, tmp.dir);
     const tarball_path = try std.fmt.allocPrint(gpa, ".zig-cache/tmp/{s}/{s}", .{ tmp.sub_path, tarball_name });
     defer gpa.free(tarball_path);
 
@@ -2210,7 +2211,7 @@ test "set executable bit based on file content" {
     );
 
     var out = try fb.packageDir();
-    defer out.close();
+    defer out.close(io);
     const S = std.posix.S;
     // expect executable bit not set
     try std.testing.expect((try out.statFile("file1")).mode & S.IXUSR == 0);
@@ -2231,11 +2232,11 @@ test "set executable bit based on file content" {
     // -rwxrwxr-x 1    17 Apr   script_with_shebang_without_exec_bit
 }
 
-fn saveEmbedFile(comptime tarball_name: []const u8, dir: fs.Dir) !void {
+fn saveEmbedFile(io: Io, comptime tarball_name: []const u8, dir: Io.Dir) !void {
     //const tarball_name = "duplicate_paths_excluded.tar.gz";
     const tarball_content = @embedFile("Fetch/testdata/" ++ tarball_name);
     var tmp_file = try dir.createFile(tarball_name, .{});
-    defer tmp_file.close();
+    defer tmp_file.close(io);
     try tmp_file.writeAll(tarball_content);
 }
 
@@ -2250,7 +2251,7 @@ const TestFetchBuilder = struct {
         self: *TestFetchBuilder,
         allocator: std.mem.Allocator,
         io: Io,
-        cache_parent_dir: std.fs.Dir,
+        cache_parent_dir: std.Io.Dir,
         path_or_url: []const u8,
     ) !*Fetch {
         const cache_dir = try cache_parent_dir.makeOpenPath("zig-global-cache", .{});
@@ -2301,14 +2302,15 @@ const TestFetchBuilder = struct {
     }
 
     fn deinit(self: *TestFetchBuilder) void {
+        const io = self.job_queue.io;
         self.fetch.deinit();
         self.job_queue.deinit();
         self.fetch.prog_node.end();
-        self.global_cache_directory.handle.close();
+        self.global_cache_directory.handle.close(io);
         self.http_client.deinit();
     }
 
-    fn packageDir(self: *TestFetchBuilder) !fs.Dir {
+    fn packageDir(self: *TestFetchBuilder) !Io.Dir {
         const root = self.fetch.package_root;
         return try root.root_dir.handle.openDir(root.sub_path, .{ .iterate = true });
     }
@@ -2316,8 +2318,10 @@ const TestFetchBuilder = struct {
     // Test helper, asserts thet package dir constains expected_files.
     // expected_files must be sorted.
     fn expectPackageFiles(self: *TestFetchBuilder, expected_files: []const []const u8) !void {
+        const io = self.job_queue.io;
+
         var package_dir = try self.packageDir();
-        defer package_dir.close();
+        defer package_dir.close(io);
 
         var actual_files: std.ArrayList([]u8) = .empty;
         defer actual_files.deinit(std.testing.allocator);
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig
index a2ea870c3f..864865bd19 100644
--- a/src/Package/Fetch/git.zig
+++ b/src/Package/Fetch/git.zig
@@ -213,6 +213,7 @@ pub const Repository = struct {
     /// Checks out the repository at `commit_oid` to `worktree`.
     pub fn checkout(
         repository: *Repository,
+        io: Io,
         worktree: std.fs.Dir,
         commit_oid: Oid,
         diagnostics: *Diagnostics,
@@ -223,12 +224,13 @@ pub const Repository = struct {
             if (commit_object.type != .commit) return error.NotACommit;
             break :tree_oid try getCommitTree(repository.odb.format, commit_object.data);
         };
-        try repository.checkoutTree(worktree, tree_oid, "", diagnostics);
+        try repository.checkoutTree(io, worktree, tree_oid, "", diagnostics);
     }
 
     /// Checks out the tree at `tree_oid` to `worktree`.
     fn checkoutTree(
         repository: *Repository,
+        io: Io,
         dir: std.fs.Dir,
         tree_oid: Oid,
         current_path: []const u8,
@@ -253,10 +255,10 @@ pub const Repository = struct {
                 .directory => {
                     try dir.makeDir(entry.name);
                     var subdir = try dir.openDir(entry.name, .{});
-                    defer subdir.close();
+                    defer subdir.close(io);
                     const sub_path = try std.fs.path.join(repository.odb.allocator, &.{ current_path, entry.name });
                     defer repository.odb.allocator.free(sub_path);
-                    try repository.checkoutTree(subdir, entry.oid, sub_path, diagnostics);
+                    try repository.checkoutTree(io, subdir, entry.oid, sub_path, diagnostics);
                 },
                 .file => {
                     try repository.odb.seekOid(entry.oid);
@@ -271,7 +273,7 @@ pub const Repository = struct {
                         } });
                         continue;
                     };
-                    defer file.close();
+                    defer file.close(io);
                     try file.writeAll(file_object.data);
                 },
                 .symlink => {
@@ -1583,14 +1585,14 @@ fn runRepositoryTest(io: Io, comptime format: Oid.Format, head_commit: []const u
     var git_dir = testing.tmpDir(.{});
     defer git_dir.cleanup();
     var pack_file = try git_dir.dir.createFile("testrepo.pack", .{ .read = true });
-    defer pack_file.close();
+    defer pack_file.close(io);
     try pack_file.writeAll(testrepo_pack);
 
     var pack_file_buffer: [2000]u8 = undefined;
     var pack_file_reader = pack_file.reader(io, &pack_file_buffer);
 
     var index_file = try git_dir.dir.createFile("testrepo.idx", .{ .read = true });
-    defer index_file.close();
+    defer index_file.close(io);
     var index_file_buffer: [2000]u8 = undefined;
     var index_file_writer = index_file.writer(&index_file_buffer);
     try indexPack(testing.allocator, format, &pack_file_reader, &index_file_writer);
@@ -1621,7 +1623,7 @@ fn runRepositoryTest(io: Io, comptime format: Oid.Format, head_commit: []const u
 
     var diagnostics: Diagnostics = .{ .allocator = testing.allocator };
     defer diagnostics.deinit();
-    try repository.checkout(worktree.dir, commit_id, &diagnostics);
+    try repository.checkout(io, worktree.dir, commit_id, &diagnostics);
     try testing.expect(diagnostics.errors.items.len == 0);
 
     const expected_files: []const []const u8 = &.{
@@ -1713,20 +1715,20 @@ pub fn main() !void {
     const format = std.meta.stringToEnum(Oid.Format, args[1]) orelse return error.InvalidFormat;
 
     var pack_file = try std.fs.cwd().openFile(args[2], .{});
-    defer pack_file.close();
+    defer pack_file.close(io);
     var pack_file_buffer: [4096]u8 = undefined;
     var pack_file_reader = pack_file.reader(io, &pack_file_buffer);
 
     const commit = try Oid.parse(format, args[3]);
     var worktree = try std.fs.cwd().makeOpenPath(args[4], .{});
-    defer worktree.close();
+    defer worktree.close(io);
 
     var git_dir = try worktree.makeOpenPath(".git", .{});
-    defer git_dir.close();
+    defer git_dir.close(io);
 
     std.debug.print("Starting index...\n", .{});
     var index_file = try git_dir.createFile("idx", .{ .read = true });
-    defer index_file.close();
+    defer index_file.close(io);
     var index_file_buffer: [4096]u8 = undefined;
     var index_file_writer = index_file.writer(&index_file_buffer);
     try indexPack(allocator, format, &pack_file_reader, &index_file_writer);
@@ -1738,7 +1740,7 @@ pub fn main() !void {
     defer repository.deinit();
     var diagnostics: Diagnostics = .{ .allocator = allocator };
     defer diagnostics.deinit();
-    try repository.checkout(worktree, commit, &diagnostics);
+    try repository.checkout(io, worktree, commit, &diagnostics);
 
     for (diagnostics.errors.items) |err| {
         std.debug.print("Diagnostic: {}\n", .{err});
diff --git a/src/Zcu.zig b/src/Zcu.zig
index 137b4d8b59..58d884afe3 100644
--- a/src/Zcu.zig
+++ b/src/Zcu.zig
@@ -1078,7 +1078,7 @@ pub const File = struct {
             const dir, const sub_path = file.path.openInfo(zcu.comp.dirs);
             break :f try dir.openFile(sub_path, .{});
         };
-        defer f.close();
+        defer f.close(io);
 
         const stat = f.stat() catch |err| switch (err) {
             error.Streaming => {
@@ -2813,8 +2813,8 @@ pub fn init(zcu: *Zcu, gpa: Allocator, io: Io, thread_count: usize) !void {
 
 pub fn deinit(zcu: *Zcu) void {
     const comp = zcu.comp;
-    const gpa = comp.gpa;
     const io = comp.io;
+    const gpa = zcu.gpa;
     {
         const pt: Zcu.PerThread = .activate(zcu, .main);
         defer pt.deactivate();
@@ -2835,8 +2835,8 @@ pub fn deinit(zcu: *Zcu) void {
         }
         zcu.embed_table.deinit(gpa);
 
-        zcu.local_zir_cache.handle.close();
-        zcu.global_zir_cache.handle.close();
+        zcu.local_zir_cache.handle.close(io);
+        zcu.global_zir_cache.handle.close(io);
 
         for (zcu.failed_analysis.values()) |value| value.destroy(gpa);
         for (zcu.failed_codegen.values()) |value| value.destroy(gpa);
@@ -2900,7 +2900,7 @@ pub fn deinit(zcu: *Zcu) void {
 
         if (zcu.resolved_references) |*r| r.deinit(gpa);
 
-        if (zcu.comp.debugIncremental()) {
+        if (comp.debugIncremental()) {
             zcu.incremental_debug_state.deinit(gpa);
         }
     }
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 2ad5bac01c..d2ca004058 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -96,7 +96,7 @@ pub fn updateFile(
         const dir, const sub_path = file.path.openInfo(comp.dirs);
         break :f try dir.openFile(sub_path, .{});
     };
-    defer source_file.close();
+    defer source_file.close(io);
 
     const stat = try source_file.stat();
 
@@ -215,7 +215,7 @@ pub fn updateFile(
             else => |e| return e, // Retryable errors are handled at callsite.
         };
     };
-    defer cache_file.close();
+    defer cache_file.close(io);
 
     // Under `--time-report`, ignore cache hits; do the work anyway for those juicy numbers.
     const ignore_hit = comp.time_report != null;
@@ -2468,7 +2468,7 @@ fn updateEmbedFileInner(
         const dir, const sub_path = ef.path.openInfo(zcu.comp.dirs);
         break :f try dir.openFile(sub_path, .{});
     };
-    defer file.close();
+    defer file.close(io);
 
     const stat: Cache.File.Stat = .fromFs(try file.stat());
 
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 5dc55b74f6..cb4fe0459f 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -799,6 +799,7 @@ pub const Object = struct {
     pub fn emit(o: *Object, pt: Zcu.PerThread, options: EmitOptions) error{ LinkFailure, OutOfMemory }!void {
         const zcu = pt.zcu;
         const comp = zcu.comp;
+        const io = comp.io;
         const diags = &comp.link_diags;
 
         {
@@ -979,7 +980,7 @@ pub const Object = struct {
             if (options.pre_bc_path) |path| {
                 var file = std.fs.cwd().createFile(path, .{}) catch |err|
                     return diags.fail("failed to create '{s}': {s}", .{ path, @errorName(err) });
-                defer file.close();
+                defer file.close(io);
 
                 const ptr: [*]const u8 = @ptrCast(bitcode.ptr);
                 file.writeAll(ptr[0..(bitcode.len * 4)]) catch |err|
@@ -992,7 +993,7 @@ pub const Object = struct {
             if (options.post_bc_path) |path| {
                 var file = std.fs.cwd().createFile(path, .{}) catch |err|
                     return diags.fail("failed to create '{s}': {s}", .{ path, @errorName(err) });
-                defer file.close();
+                defer file.close(io);
 
                 const ptr: [*]const u8 = @ptrCast(bitcode.ptr);
                 file.writeAll(ptr[0..(bitcode.len * 4)]) catch |err|
diff --git a/src/fmt.zig b/src/fmt.zig
index 80925200d6..907c7885ad 100644
--- a/src/fmt.zig
+++ b/src/fmt.zig
@@ -187,7 +187,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
             // On Windows, statFile does not work for directories
             error.IsDir => dir: {
                 var dir = try fs.cwd().openDir(file_path, .{});
-                defer dir.close();
+                defer dir.close(io);
                 break :dir try dir.stat();
             },
             else => |e| return e,
@@ -222,8 +222,10 @@ fn fmtPathDir(
     parent_dir: fs.Dir,
     parent_sub_path: []const u8,
 ) !void {
+    const io = fmt.io;
+
     var dir = try parent_dir.openDir(parent_sub_path, .{ .iterate = true });
-    defer dir.close();
+    defer dir.close(io);
 
     const stat = try dir.stat();
     if (try fmt.seen.fetchPut(stat.inode, {})) |_| return;
@@ -262,7 +264,7 @@ fn fmtPathFile(
 
     const source_file = try dir.openFile(sub_path, .{});
     var file_closed = false;
-    errdefer if (!file_closed) source_file.close();
+    errdefer if (!file_closed) source_file.close(io);
 
     const stat = try source_file.stat();
 
@@ -280,7 +282,7 @@ fn fmtPathFile(
     };
     defer gpa.free(source_code);
 
-    source_file.close();
+    source_file.close(io);
     file_closed = true;
 
     // Add to set after no longer possible to get error.IsDir.
diff --git a/src/introspect.zig b/src/introspect.zig
index 8467b566c6..9b6797e7d8 100644
--- a/src/introspect.zig
+++ b/src/introspect.zig
@@ -1,18 +1,21 @@
-const std = @import("std");
 const builtin = @import("builtin");
+const build_options = @import("build_options");
+
+const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
-const Allocator = mem.Allocator;
+const Allocator = std.mem.Allocator;
 const os = std.os;
 const fs = std.fs;
 const Cache = std.Build.Cache;
+
 const Compilation = @import("Compilation.zig");
 const Package = @import("Package.zig");
-const build_options = @import("build_options");
 
 /// Returns the sub_path that worked, or `null` if none did.
 /// The path of the returned Directory is relative to `base`.
 /// The handle of the returned Directory is open.
-fn testZigInstallPrefix(base_dir: fs.Dir) ?Cache.Directory {
+fn testZigInstallPrefix(io: Io, base_dir: Io.Dir) ?Cache.Directory {
     const test_index_file = "std" ++ fs.path.sep_str ++ "std.zig";
 
     zig_dir: {
@@ -20,31 +23,31 @@ fn testZigInstallPrefix(base_dir: fs.Dir) ?Cache.Directory {
         const lib_zig = "lib" ++ fs.path.sep_str ++ "zig";
         var test_zig_dir = base_dir.openDir(lib_zig, .{}) catch break :zig_dir;
         const file = test_zig_dir.openFile(test_index_file, .{}) catch {
-            test_zig_dir.close();
+            test_zig_dir.close(io);
             break :zig_dir;
         };
-        file.close();
+        file.close(io);
         return .{ .handle = test_zig_dir, .path = lib_zig };
     }
 
     // Try lib/std/std.zig
     var test_zig_dir = base_dir.openDir("lib", .{}) catch return null;
     const file = test_zig_dir.openFile(test_index_file, .{}) catch {
-        test_zig_dir.close();
+        test_zig_dir.close(io);
         return null;
     };
-    file.close();
+    file.close(io);
     return .{ .handle = test_zig_dir, .path = "lib" };
 }
 
 /// Both the directory handle and the path are newly allocated resources which the caller now owns.
-pub fn findZigLibDir(gpa: Allocator) !Cache.Directory {
+pub fn findZigLibDir(gpa: Allocator, io: Io) !Cache.Directory {
     const cwd_path = try getResolvedCwd(gpa);
     defer gpa.free(cwd_path);
     const self_exe_path = try fs.selfExePathAlloc(gpa);
     defer gpa.free(self_exe_path);
 
-    return findZigLibDirFromSelfExe(gpa, cwd_path, self_exe_path);
+    return findZigLibDirFromSelfExe(gpa, io, cwd_path, self_exe_path);
 }
 
 /// Like `std.process.getCwdAlloc`, but also resolves the path with `std.fs.path.resolve`. This
@@ -73,6 +76,7 @@ pub fn getResolvedCwd(gpa: Allocator) error{
 /// Both the directory handle and the path are newly allocated resources which the caller now owns.
 pub fn findZigLibDirFromSelfExe(
     allocator: Allocator,
+    io: Io,
     /// The return value of `getResolvedCwd`.
     /// Passed as an argument to avoid pointlessly repeating the call.
     cwd_path: []const u8,
@@ -82,9 +86,9 @@ pub fn findZigLibDirFromSelfExe(
     var cur_path: []const u8 = self_exe_path;
     while (fs.path.dirname(cur_path)) |dirname| : (cur_path = dirname) {
         var base_dir = cwd.openDir(dirname, .{}) catch continue;
-        defer base_dir.close();
+        defer base_dir.close(io);
 
-        const sub_directory = testZigInstallPrefix(base_dir) orelse continue;
+        const sub_directory = testZigInstallPrefix(io, base_dir) orelse continue;
         const p = try fs.path.join(allocator, &.{ dirname, sub_directory.path.? });
         defer allocator.free(p);
 
diff --git a/src/libs/freebsd.zig b/src/libs/freebsd.zig
index afeb5b3282..8c5e0afe4b 100644
--- a/src/libs/freebsd.zig
+++ b/src/libs/freebsd.zig
@@ -449,7 +449,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
-    defer cache.manifest_dir.close();
+    defer cache.manifest_dir.close(io);
 
     var man = cache.obtain();
     defer man.deinit();
@@ -480,7 +480,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .handle = try comp.dirs.global_cache.handle.makeOpenPath(o_sub_path, .{}),
         .path = try comp.dirs.global_cache.join(arena, &.{o_sub_path}),
     };
-    defer o_directory.handle.close();
+    defer o_directory.handle.close(io);
 
     const abilists_contents = man.files.keys()[abilists_index].contents.?;
     const metadata = try loadMetaData(gpa, abilists_contents);
diff --git a/src/libs/glibc.zig b/src/libs/glibc.zig
index 64d0fdbeac..bec20ff3d4 100644
--- a/src/libs/glibc.zig
+++ b/src/libs/glibc.zig
@@ -684,7 +684,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
-    defer cache.manifest_dir.close();
+    defer cache.manifest_dir.close(io);
 
     var man = cache.obtain();
     defer man.deinit();
@@ -715,7 +715,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .handle = try comp.dirs.global_cache.handle.makeOpenPath(o_sub_path, .{}),
         .path = try comp.dirs.global_cache.join(arena, &.{o_sub_path}),
     };
-    defer o_directory.handle.close();
+    defer o_directory.handle.close(io);
 
     const abilists_contents = man.files.keys()[abilists_index].contents.?;
     const metadata = try loadMetaData(gpa, abilists_contents);
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index b3c018996a..005696e1fc 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -262,7 +262,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
-    defer cache.manifest_dir.close();
+    defer cache.manifest_dir.close(io);
 
     cache.hash.addBytes(build_options.version);
     cache.hash.addOptionalBytes(comp.dirs.zig_lib.path);
@@ -297,7 +297,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     const digest = man.final();
     const o_sub_path = try std.fs.path.join(arena, &[_][]const u8{ "o", &digest });
     var o_dir = try comp.dirs.global_cache.handle.makeOpenPath(o_sub_path, .{});
-    defer o_dir.close();
+    defer o_dir.close(io);
 
     const aro = @import("aro");
     var diagnostics: aro.Diagnostics = .{
@@ -377,7 +377,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
 
     {
         const lib_final_file = try o_dir.createFile(final_lib_basename, .{ .truncate = true });
-        defer lib_final_file.close();
+        defer lib_final_file.close(io);
         var buffer: [1024]u8 = undefined;
         var file_writer = lib_final_file.writer(&buffer);
         try implib.writeCoffArchive(gpa, &file_writer.interface, members);
diff --git a/src/libs/netbsd.zig b/src/libs/netbsd.zig
index 8d35e3bd71..67e6a2f903 100644
--- a/src/libs/netbsd.zig
+++ b/src/libs/netbsd.zig
@@ -390,7 +390,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
     cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
-    defer cache.manifest_dir.close();
+    defer cache.manifest_dir.close(io);
 
     var man = cache.obtain();
     defer man.deinit();
@@ -421,7 +421,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .handle = try comp.dirs.global_cache.handle.makeOpenPath(o_sub_path, .{}),
         .path = try comp.dirs.global_cache.join(arena, &.{o_sub_path}),
     };
-    defer o_directory.handle.close();
+    defer o_directory.handle.close(io);
 
     const abilists_contents = man.files.keys()[abilists_index].contents.?;
     const metadata = try loadMetaData(gpa, abilists_contents);
diff --git a/src/link.zig b/src/link.zig
index 6ac96504c7..ef095987c9 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -687,7 +687,7 @@ pub const File = struct {
             .lld => assert(base.file == null),
             .elf => if (base.file) |f| {
                 dev.check(.elf_linker);
-                f.close();
+                f.close(io);
                 base.file = null;
 
                 if (base.child_pid) |pid| {
@@ -701,7 +701,7 @@ pub const File = struct {
             },
             .macho, .wasm => if (base.file) |f| {
                 dev.checkAny(&.{ .coff_linker, .macho_linker, .plan9_linker, .wasm_linker });
-                f.close();
+                f.close(io);
                 base.file = null;
 
                 if (base.child_pid) |pid| {
@@ -866,8 +866,9 @@ pub const File = struct {
     }
 
     pub fn destroy(base: *File) void {
+        const io = base.comp.io;
         base.releaseLock();
-        if (base.file) |f| f.close();
+        if (base.file) |f| f.close(io);
         switch (base.tag) {
             .plan9 => unreachable,
             inline else => |tag| {
@@ -1060,9 +1061,10 @@ pub const File = struct {
     /// Opens a path as an object file and parses it into the linker.
     fn openLoadObject(base: *File, path: Path) anyerror!void {
         if (base.tag == .lld) return;
+        const io = base.comp.io;
         const diags = &base.comp.link_diags;
-        const input = try openObjectInput(diags, path);
-        errdefer input.object.file.close();
+        const input = try openObjectInput(io, diags, path);
+        errdefer input.object.file.close(io);
         try loadInput(base, input);
     }
 
@@ -1070,21 +1072,22 @@ pub const File = struct {
     /// If `query` is non-null, allows GNU ld scripts.
     fn openLoadArchive(base: *File, path: Path, opt_query: ?UnresolvedInput.Query) anyerror!void {
         if (base.tag == .lld) return;
+        const io = base.comp.io;
         if (opt_query) |query| {
-            const archive = try openObject(path, query.must_link, query.hidden);
-            errdefer archive.file.close();
+            const archive = try openObject(io, path, query.must_link, query.hidden);
+            errdefer archive.file.close(io);
             loadInput(base, .{ .archive = archive }) catch |err| switch (err) {
                 error.BadMagic, error.UnexpectedEndOfFile => {
                     if (base.tag != .elf and base.tag != .elf2) return err;
                     try loadGnuLdScript(base, path, query, archive.file);
-                    archive.file.close();
+                    archive.file.close(io);
                     return;
                 },
                 else => return err,
             };
         } else {
-            const archive = try openObject(path, false, false);
-            errdefer archive.file.close();
+            const archive = try openObject(io, path, false, false);
+            errdefer archive.file.close(io);
             try loadInput(base, .{ .archive = archive });
         }
     }
@@ -1093,13 +1096,14 @@ pub const File = struct {
     /// Handles GNU ld scripts.
     fn openLoadDso(base: *File, path: Path, query: UnresolvedInput.Query) anyerror!void {
         if (base.tag == .lld) return;
-        const dso = try openDso(path, query.needed, query.weak, query.reexport);
-        errdefer dso.file.close();
+        const io = base.comp.io;
+        const dso = try openDso(io, path, query.needed, query.weak, query.reexport);
+        errdefer dso.file.close(io);
         loadInput(base, .{ .dso = dso }) catch |err| switch (err) {
             error.BadMagic, error.UnexpectedEndOfFile => {
                 if (base.tag != .elf and base.tag != .elf2) return err;
                 try loadGnuLdScript(base, path, query, dso.file);
-                dso.file.close();
+                dso.file.close(io);
                 return;
             },
             else => return err,
@@ -1735,6 +1739,7 @@ pub fn hashInputs(man: *Cache.Manifest, link_inputs: []const Input) !void {
 pub fn resolveInputs(
     gpa: Allocator,
     arena: Allocator,
+    io: Io,
     target: *const std.Target,
     /// This function mutates this array but does not take ownership.
     /// Allocated with `gpa`.
@@ -1784,6 +1789,7 @@ pub fn resolveInputs(
                         for (lib_directories) |lib_directory| switch (try resolveLibInput(
                             gpa,
                             arena,
+                            io,
                             unresolved_inputs,
                             resolved_inputs,
                             &checked_paths,
@@ -1810,6 +1816,7 @@ pub fn resolveInputs(
                         for (lib_directories) |lib_directory| switch (try resolveLibInput(
                             gpa,
                             arena,
+                            io,
                             unresolved_inputs,
                             resolved_inputs,
                             &checked_paths,
@@ -1837,6 +1844,7 @@ pub fn resolveInputs(
                             switch (try resolveLibInput(
                                 gpa,
                                 arena,
+                                io,
                                 unresolved_inputs,
                                 resolved_inputs,
                                 &checked_paths,
@@ -1855,6 +1863,7 @@ pub fn resolveInputs(
                             switch (try resolveLibInput(
                                 gpa,
                                 arena,
+                                io,
                                 unresolved_inputs,
                                 resolved_inputs,
                                 &checked_paths,
@@ -1886,6 +1895,7 @@ pub fn resolveInputs(
                 if (try resolvePathInput(
                     gpa,
                     arena,
+                    io,
                     unresolved_inputs,
                     resolved_inputs,
                     &ld_script_bytes,
@@ -1903,6 +1913,7 @@ pub fn resolveInputs(
                                 switch ((try resolvePathInput(
                                     gpa,
                                     arena,
+                                    io,
                                     unresolved_inputs,
                                     resolved_inputs,
                                     &ld_script_bytes,
@@ -1930,6 +1941,7 @@ pub fn resolveInputs(
                 if (try resolvePathInput(
                     gpa,
                     arena,
+                    io,
                     unresolved_inputs,
                     resolved_inputs,
                     &ld_script_bytes,
@@ -1969,6 +1981,7 @@ const fatal = std.process.fatal;
 fn resolveLibInput(
     gpa: Allocator,
     arena: Allocator,
+    io: Io,
     /// Allocated via `gpa`.
     unresolved_inputs: *std.ArrayList(UnresolvedInput),
     /// Allocated via `gpa`.
@@ -1998,7 +2011,7 @@ fn resolveLibInput(
             error.FileNotFound => break :tbd,
             else => |e| fatal("unable to search for tbd library '{f}': {s}", .{ test_path, @errorName(e) }),
         };
-        errdefer file.close();
+        errdefer file.close(io);
         return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
     }
 
@@ -2013,7 +2026,7 @@ fn resolveLibInput(
             }),
         };
         try checked_paths.print(gpa, "\n  {f}", .{test_path});
-        switch (try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, .{
+        switch (try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, target, .{
             .path = test_path,
             .query = name_query.query,
         }, link_mode, color)) {
@@ -2036,7 +2049,7 @@ fn resolveLibInput(
                 test_path, @errorName(e),
             }),
         };
-        errdefer file.close();
+        errdefer file.close(io);
         return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
     }
 
@@ -2052,7 +2065,7 @@ fn resolveLibInput(
             error.FileNotFound => break :mingw,
             else => |e| fatal("unable to search for static library '{f}': {s}", .{ test_path, @errorName(e) }),
         };
-        errdefer file.close();
+        errdefer file.close(io);
         return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, name_query.query);
     }
 
@@ -2087,6 +2100,7 @@ fn finishResolveLibInput(
 fn resolvePathInput(
     gpa: Allocator,
     arena: Allocator,
+    io: Io,
     /// Allocated with `gpa`.
     unresolved_inputs: *std.ArrayList(UnresolvedInput),
     /// Allocated with `gpa`.
@@ -2098,12 +2112,12 @@ fn resolvePathInput(
     color: std.zig.Color,
 ) Allocator.Error!?ResolveLibInputResult {
     switch (Compilation.classifyFileExt(pq.path.sub_path)) {
-        .static_library => return try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .static, color),
-        .shared_library => return try resolvePathInputLib(gpa, arena, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .dynamic, color),
+        .static_library => return try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .static, color),
+        .shared_library => return try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .dynamic, color),
         .object => {
             var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
                 fatal("failed to open object {f}: {s}", .{ pq.path, @errorName(err) });
-            errdefer file.close();
+            errdefer file.close(io);
             try resolved_inputs.append(gpa, .{ .object = .{
                 .path = pq.path,
                 .file = file,
@@ -2115,7 +2129,7 @@ fn resolvePathInput(
         .res => {
             var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
                 fatal("failed to open windows resource {f}: {s}", .{ pq.path, @errorName(err) });
-            errdefer file.close();
+            errdefer file.close(io);
             try resolved_inputs.append(gpa, .{ .res = .{
                 .path = pq.path,
                 .file = file,
@@ -2129,6 +2143,7 @@ fn resolvePathInput(
 fn resolvePathInputLib(
     gpa: Allocator,
     arena: Allocator,
+    io: Io,
     /// Allocated with `gpa`.
     unresolved_inputs: *std.ArrayList(UnresolvedInput),
     /// Allocated with `gpa`.
@@ -2155,7 +2170,7 @@ fn resolvePathInputLib(
                 @tagName(link_mode), std.fmt.alt(test_path, .formatEscapeChar), @errorName(e),
             }),
         };
-        errdefer file.close();
+        errdefer file.close(io);
         try ld_script_bytes.resize(gpa, @max(std.elf.MAGIC.len, std.elf.ARMAG.len));
         const n = file.preadAll(ld_script_bytes.items, 0) catch |err| fatal("failed to read '{f}': {s}", .{
             std.fmt.alt(test_path, .formatEscapeChar), @errorName(err),
@@ -2223,7 +2238,7 @@ fn resolvePathInputLib(
                 } });
             }
         }
-        file.close();
+        file.close(io);
         return .ok;
     }
 
@@ -2233,13 +2248,13 @@ fn resolvePathInputLib(
             @tagName(link_mode), test_path, @errorName(e),
         }),
     };
-    errdefer file.close();
+    errdefer file.close(io);
     return finishResolveLibInput(resolved_inputs, test_path, file, link_mode, pq.query);
 }
 
-pub fn openObject(path: Path, must_link: bool, hidden: bool) !Input.Object {
+pub fn openObject(io: Io, path: Path, must_link: bool, hidden: bool) !Input.Object {
     var file = try path.root_dir.handle.openFile(path.sub_path, .{});
-    errdefer file.close();
+    errdefer file.close(io);
     return .{
         .path = path,
         .file = file,
@@ -2248,9 +2263,9 @@ pub fn openObject(path: Path, must_link: bool, hidden: bool) !Input.Object {
     };
 }
 
-pub fn openDso(path: Path, needed: bool, weak: bool, reexport: bool) !Input.Dso {
+pub fn openDso(io: Io, path: Path, needed: bool, weak: bool, reexport: bool) !Input.Dso {
     var file = try path.root_dir.handle.openFile(path.sub_path, .{});
-    errdefer file.close();
+    errdefer file.close(io);
     return .{
         .path = path,
         .file = file,
@@ -2260,20 +2275,20 @@ pub fn openDso(path: Path, needed: bool, weak: bool, reexport: bool) !Input.Dso
     };
 }
 
-pub fn openObjectInput(diags: *Diags, path: Path) error{LinkFailure}!Input {
-    return .{ .object = openObject(path, false, false) catch |err| {
+pub fn openObjectInput(io: Io, diags: *Diags, path: Path) error{LinkFailure}!Input {
+    return .{ .object = openObject(io, path, false, false) catch |err| {
         return diags.failParse(path, "failed to open {f}: {s}", .{ path, @errorName(err) });
     } };
 }
 
-pub fn openArchiveInput(diags: *Diags, path: Path, must_link: bool, hidden: bool) error{LinkFailure}!Input {
-    return .{ .archive = openObject(path, must_link, hidden) catch |err| {
+pub fn openArchiveInput(io: Io, diags: *Diags, path: Path, must_link: bool, hidden: bool) error{LinkFailure}!Input {
+    return .{ .archive = openObject(io, path, must_link, hidden) catch |err| {
         return diags.failParse(path, "failed to open {f}: {s}", .{ path, @errorName(err) });
     } };
 }
 
-pub fn openDsoInput(diags: *Diags, path: Path, needed: bool, weak: bool, reexport: bool) error{LinkFailure}!Input {
-    return .{ .dso = openDso(path, needed, weak, reexport) catch |err| {
+pub fn openDsoInput(io: Io, diags: *Diags, path: Path, needed: bool, weak: bool, reexport: bool) error{LinkFailure}!Input {
+    return .{ .dso = openDso(io, path, needed, weak, reexport) catch |err| {
         return diags.failParse(path, "failed to open {f}: {s}", .{ path, @errorName(err) });
     } };
 }
diff --git a/src/link/C.zig b/src/link/C.zig
index ce48e85851..04c92443e5 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -124,6 +124,7 @@ pub fn createEmpty(
     emit: Path,
     options: link.File.OpenOptions,
 ) !*C {
+    const io = comp.io;
     const target = &comp.root_mod.resolved_target.result;
     assert(target.ofmt == .c);
     const optimize_mode = comp.root_mod.optimize_mode;
@@ -139,7 +140,7 @@ pub fn createEmpty(
         // Truncation is done on `flush`.
         .truncate = false,
     });
-    errdefer file.close();
+    errdefer file.close(io);
 
     const c_file = try arena.create(C);
 
@@ -763,6 +764,7 @@ pub fn flushEmitH(zcu: *Zcu) !void {
     if (true) return; // emit-h is regressed
 
     const emit_h = zcu.emit_h orelse return;
+    const io = zcu.comp.io;
 
     // We collect a list of buffers to write, and write them all at once with pwritev 😎
     const num_buffers = emit_h.decl_table.count() + 1;
@@ -795,7 +797,7 @@ pub fn flushEmitH(zcu: *Zcu) !void {
         // make it easier on the file system by doing 1 reallocation instead of two.
         .truncate = false,
     });
-    defer file.close();
+    defer file.close(io);
 
     try file.setEndPos(file_size);
     try file.pwritevAll(all_buffers.items, 0);
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 69acbe034b..ae7d631f09 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -406,10 +406,12 @@ pub fn open(
 }
 
 pub fn deinit(self: *Elf) void {
-    const gpa = self.base.comp.gpa;
+    const comp = self.base.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
 
     for (self.file_handles.items) |fh| {
-        fh.close();
+        fh.close(io);
     }
     self.file_handles.deinit(gpa);
 
diff --git a/src/link/Lld.zig b/src/link/Lld.zig
index 2345090482..66b032e0a9 100644
--- a/src/link/Lld.zig
+++ b/src/link/Lld.zig
@@ -1628,7 +1628,7 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
                 defer comp.dirs.local_cache.handle.deleteFileZ(rsp_path) catch |err|
                     log.warn("failed to delete response file {s}: {s}", .{ rsp_path, @errorName(err) });
                 {
-                    defer rsp_file.close();
+                    defer rsp_file.close(io);
                     var rsp_file_buffer: [1024]u8 = undefined;
                     var rsp_file_writer = rsp_file.writer(&rsp_file_buffer);
                     const rsp_writer = &rsp_file_writer.interface;
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index 2c4ffd6632..471465cea1 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -267,14 +267,16 @@ pub fn open(
 }
 
 pub fn deinit(self: *MachO) void {
-    const gpa = self.base.comp.gpa;
+    const comp = self.base.comp;
+    const gpa = comp.gpa;
+    const io = comp.io;
 
     if (self.d_sym) |*d_sym| {
         d_sym.deinit();
     }
 
     for (self.file_handles.items) |handle| {
-        handle.close();
+        handle.close(io);
     }
     self.file_handles.deinit(gpa);
 
@@ -3257,8 +3259,10 @@ const InitMetadataOptions = struct {
 };
 
 pub fn closeDebugInfo(self: *MachO) bool {
+    const comp = self.base.comp;
+    const io = comp.io;
     const d_sym = &(self.d_sym orelse return false);
-    d_sym.file.?.close();
+    d_sym.file.?.close(io);
     d_sym.file = null;
     return true;
 }
@@ -3269,7 +3273,9 @@ pub fn reopenDebugInfo(self: *MachO) !void {
     assert(!self.base.comp.config.use_llvm);
     assert(self.base.comp.config.debug_format == .dwarf);
 
-    const gpa = self.base.comp.gpa;
+    const comp = self.base.comp;
+    const io = comp.io;
+    const gpa = comp.gpa;
     const sep = fs.path.sep_str;
     const d_sym_path = try std.fmt.allocPrint(
         gpa,
@@ -3279,7 +3285,7 @@ pub fn reopenDebugInfo(self: *MachO) !void {
     defer gpa.free(d_sym_path);
 
     var d_sym_bundle = try self.base.emit.root_dir.handle.makeOpenPath(d_sym_path, .{});
-    defer d_sym_bundle.close();
+    defer d_sym_bundle.close(io);
 
     self.d_sym.?.file = try d_sym_bundle.createFile(fs.path.basename(self.base.emit.sub_path), .{
         .truncate = false,
diff --git a/src/link/MachO/DebugSymbols.zig b/src/link/MachO/DebugSymbols.zig
index 5d7b9b88c3..8a97f2844f 100644
--- a/src/link/MachO/DebugSymbols.zig
+++ b/src/link/MachO/DebugSymbols.zig
@@ -1,5 +1,28 @@
+const DebugSymbols = @This();
+
+const std = @import("std");
+const Io = std.Io;
+const assert = std.debug.assert;
+const fs = std.fs;
+const log = std.log.scoped(.link_dsym);
+const macho = std.macho;
+const makeStaticString = MachO.makeStaticString;
+const math = std.math;
+const mem = std.mem;
+const Writer = std.Io.Writer;
+const Allocator = std.mem.Allocator;
+
+const link = @import("../../link.zig");
+const MachO = @import("../MachO.zig");
+const StringTable = @import("../StringTable.zig");
+const Type = @import("../../Type.zig");
+const trace = @import("../../tracy.zig").trace;
+const load_commands = @import("load_commands.zig");
+const padToIdeal = MachO.padToIdeal;
+
+io: Io,
 allocator: Allocator,
-file: ?fs.File,
+file: ?Io.File,
 
 symtab_cmd: macho.symtab_command = .{},
 uuid_cmd: macho.uuid_command = .{ .uuid = [_]u8{0} ** 16 },
@@ -208,7 +231,8 @@ pub fn flush(self: *DebugSymbols, macho_file: *MachO) !void {
 
 pub fn deinit(self: *DebugSymbols) void {
     const gpa = self.allocator;
-    if (self.file) |file| file.close();
+    const io = self.io;
+    if (self.file) |file| file.close(io);
     self.segments.deinit(gpa);
     self.sections.deinit(gpa);
     self.relocs.deinit(gpa);
@@ -443,25 +467,3 @@ pub fn getSection(self: DebugSymbols, sect: u8) macho.section_64 {
     assert(sect < self.sections.items.len);
     return self.sections.items[sect];
 }
-
-const DebugSymbols = @This();
-
-const std = @import("std");
-const build_options = @import("build_options");
-const assert = std.debug.assert;
-const fs = std.fs;
-const link = @import("../../link.zig");
-const load_commands = @import("load_commands.zig");
-const log = std.log.scoped(.link_dsym);
-const macho = std.macho;
-const makeStaticString = MachO.makeStaticString;
-const math = std.math;
-const mem = std.mem;
-const padToIdeal = MachO.padToIdeal;
-const trace = @import("../../tracy.zig").trace;
-const Writer = std.Io.Writer;
-
-const Allocator = mem.Allocator;
-const MachO = @import("../MachO.zig");
-const StringTable = @import("../StringTable.zig");
-const Type = @import("../../Type.zig");
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 92307ec40c..160e6cdcc6 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -3032,7 +3032,7 @@ fn parseObject(wasm: *Wasm, obj: link.Input.Object) !void {
     const io = wasm.base.comp.io;
     const gc_sections = wasm.base.gc_sections;
 
-    defer obj.file.close();
+    defer obj.file.close(io);
 
     var file_reader = obj.file.reader(io, &.{});
 
@@ -3060,7 +3060,7 @@ fn parseArchive(wasm: *Wasm, obj: link.Input.Object) !void {
     const io = wasm.base.comp.io;
     const gc_sections = wasm.base.gc_sections;
 
-    defer obj.file.close();
+    defer obj.file.close(io);
 
     var file_reader = obj.file.reader(io, &.{});
 
diff --git a/src/main.zig b/src/main.zig
index a897f2a847..3ca64881f8 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -328,21 +328,21 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
             .prepend_global_cache_path = true,
         });
     } else if (mem.eql(u8, cmd, "init")) {
-        return cmdInit(gpa, arena, cmd_args);
+        return cmdInit(gpa, arena, io, cmd_args);
     } else if (mem.eql(u8, cmd, "targets")) {
         dev.check(.targets_command);
         const host = std.zig.resolveTargetQueryOrFatal(io, .{});
-        var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
-        try @import("print_targets.zig").cmdTargets(arena, cmd_args, &stdout_writer.interface, &host);
+        var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
+        try @import("print_targets.zig").cmdTargets(arena, io, cmd_args, &stdout_writer.interface, &host);
         return stdout_writer.interface.flush();
     } else if (mem.eql(u8, cmd, "version")) {
         dev.check(.version_command);
-        try fs.File.stdout().writeAll(build_options.version ++ "\n");
+        try Io.File.stdout().writeAll(build_options.version ++ "\n");
         return;
     } else if (mem.eql(u8, cmd, "env")) {
         dev.check(.env_command);
         const host = std.zig.resolveTargetQueryOrFatal(io, .{});
-        var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
+        var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
         try @import("print_env.zig").cmdEnv(
             arena,
             &stdout_writer.interface,
@@ -358,10 +358,10 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
         });
     } else if (mem.eql(u8, cmd, "zen")) {
         dev.check(.zen_command);
-        return fs.File.stdout().writeAll(info_zen);
+        return Io.File.stdout().writeAll(info_zen);
     } else if (mem.eql(u8, cmd, "help") or mem.eql(u8, cmd, "-h") or mem.eql(u8, cmd, "--help")) {
         dev.check(.help_command);
-        return fs.File.stdout().writeAll(usage);
+        return Io.File.stdout().writeAll(usage);
     } else if (mem.eql(u8, cmd, "ast-check")) {
         return cmdAstCheck(arena, io, cmd_args);
     } else if (mem.eql(u8, cmd, "detect-cpu")) {
@@ -698,7 +698,7 @@ const Emit = union(enum) {
     yes: []const u8,
 
     const OutputToCacheReason = enum { listen, @"zig run", @"zig test" };
-    fn resolve(emit: Emit, default_basename: []const u8, output_to_cache: ?OutputToCacheReason) Compilation.CreateOptions.Emit {
+    fn resolve(io: Io, emit: Emit, default_basename: []const u8, output_to_cache: ?OutputToCacheReason) Compilation.CreateOptions.Emit {
         return switch (emit) {
             .no => .no,
             .yes_default_path => if (output_to_cache != null) .yes_cache else .{ .yes_path = default_basename },
@@ -716,7 +716,7 @@ const Emit = union(enum) {
                     var dir = fs.cwd().openDir(dir_path, .{}) catch |err| {
                         fatal("unable to open output directory '{s}': {s}", .{ dir_path, @errorName(err) });
                     };
-                    dir.close();
+                    dir.close(io);
                 }
                 break :e .{ .yes_path = path };
             },
@@ -1034,7 +1034,7 @@ fn buildOutputType(
                     };
                 } else if (mem.startsWith(u8, arg, "-")) {
                     if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                        try fs.File.stdout().writeAll(usage_build_generic);
+                        try Io.File.stdout().writeAll(usage_build_generic);
                         return cleanExit();
                     } else if (mem.eql(u8, arg, "--")) {
                         if (arg_mode == .run) {
@@ -2834,9 +2834,9 @@ fn buildOutputType(
                 } else if (mem.eql(u8, arg, "-V")) {
                     warn("ignoring request for supported emulations: unimplemented", .{});
                 } else if (mem.eql(u8, arg, "-v")) {
-                    try fs.File.stdout().writeAll("zig ld " ++ build_options.version ++ "\n");
+                    try Io.File.stdout().writeAll("zig ld " ++ build_options.version ++ "\n");
                 } else if (mem.eql(u8, arg, "--version")) {
-                    try fs.File.stdout().writeAll("zig ld " ++ build_options.version ++ "\n");
+                    try Io.File.stdout().writeAll("zig ld " ++ build_options.version ++ "\n");
                     process.exit(0);
                 } else {
                     fatal("unsupported linker arg: {s}", .{arg});
@@ -3251,8 +3251,8 @@ fn buildOutputType(
         }
     }
 
-    var cleanup_emit_bin_dir: ?fs.Dir = null;
-    defer if (cleanup_emit_bin_dir) |*dir| dir.close();
+    var cleanup_emit_bin_dir: ?Io.Dir = null;
+    defer if (cleanup_emit_bin_dir) |*dir| dir.close(io);
 
     // For `zig run` and `zig test`, we don't want to put the binary in the cwd by default. So, if
     // the binary is requested with no explicit path (as is the default), we emit to the cache.
@@ -3307,7 +3307,7 @@ fn buildOutputType(
                 var dir = fs.cwd().openDir(dir_path, .{}) catch |err| {
                     fatal("unable to open output directory '{s}': {s}", .{ dir_path, @errorName(err) });
                 };
-                dir.close();
+                dir.close(io);
             }
             break :emit .{ .yes_path = path };
         },
@@ -3390,7 +3390,7 @@ fn buildOutputType(
         // will be a hash of its contents — so multiple invocations of
         // `zig cc -` will result in the same temp file name.
         var f = try dirs.local_cache.handle.createFile(dump_path, .{});
-        defer f.close();
+        defer f.close(io);
 
         // Re-using the hasher from Cache, since the functional requirements
         // for the hashing algorithm here and in the cache are the same.
@@ -3399,7 +3399,7 @@ fn buildOutputType(
         var file_writer = f.writer(&.{});
         var buffer: [1000]u8 = undefined;
         var hasher = file_writer.interface.hashed(Cache.Hasher.init("0123456789abcdef"), &buffer);
-        var stdin_reader = fs.File.stdin().readerStreaming(io, &.{});
+        var stdin_reader = Io.File.stdin().readerStreaming(io, &.{});
         _ = hasher.writer.sendFileAll(&stdin_reader, .unlimited) catch |err| switch (err) {
             error.WriteFailed => fatal("failed to write {s}: {t}", .{ dump_path, file_writer.err.? }),
             else => fatal("failed to pipe stdin to {s}: {t}", .{ dump_path, err }),
@@ -3630,13 +3630,13 @@ fn buildOutputType(
     if (show_builtin) {
         const builtin_opts = comp.root_mod.getBuiltinOptions(comp.config);
         const source = try builtin_opts.generate(arena);
-        return fs.File.stdout().writeAll(source);
+        return Io.File.stdout().writeAll(source);
     }
     switch (listen) {
         .none => {},
         .stdio => {
-            var stdin_reader = fs.File.stdin().reader(io, &stdin_buffer);
-            var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
+            var stdin_reader = Io.File.stdin().reader(io, &stdin_buffer);
+            var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
             try serve(
                 comp,
                 &stdin_reader.interface,
@@ -4034,6 +4034,7 @@ fn createModule(
         link.resolveInputs(
             gpa,
             arena,
+            io,
             target,
             &unresolved_link_inputs,
             &create_module.link_inputs,
@@ -4689,8 +4690,8 @@ fn cmdTranslateC(
                 @errorName(err),
             });
         };
-        defer zig_file.close();
-        var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
+        defer zig_file.close(io);
+        var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
         var file_reader = zig_file.reader(io, &.{});
         _ = try stdout_writer.interface.sendFileAll(&file_reader, .unlimited);
         try stdout_writer.interface.flush();
@@ -4728,7 +4729,7 @@ const usage_init =
     \\
 ;
 
-fn cmdInit(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
+fn cmdInit(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !void {
     dev.check(.init_command);
 
     var template: enum { example, minimal } = .example;
@@ -4740,7 +4741,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
                 if (mem.eql(u8, arg, "-m") or mem.eql(u8, arg, "--minimal")) {
                     template = .minimal;
                 } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                    try fs.File.stdout().writeAll(usage_init);
+                    try Io.File.stdout().writeAll(usage_init);
                     return cleanExit();
                 } else {
                     fatal("unrecognized parameter: '{s}'", .{arg});
@@ -4759,7 +4760,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
 
     switch (template) {
         .example => {
-            var templates = findTemplates(gpa, arena);
+            var templates = findTemplates(gpa, arena, io);
             defer templates.deinit();
 
             const s = fs.path.sep_str;
@@ -4789,7 +4790,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
             return cleanExit();
         },
         .minimal => {
-            writeSimpleTemplateFile(Package.Manifest.basename,
+            writeSimpleTemplateFile(io, Package.Manifest.basename,
                 \\.{{
                 \\    .name = .{s},
                 \\    .version = "0.0.1",
@@ -4806,7 +4807,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
                 else => fatal("failed to create '{s}': {s}", .{ Package.Manifest.basename, @errorName(err) }),
                 error.PathAlreadyExists => fatal("refusing to overwrite '{s}'", .{Package.Manifest.basename}),
             };
-            writeSimpleTemplateFile(Package.build_zig_basename,
+            writeSimpleTemplateFile(io, Package.build_zig_basename,
                 \\const std = @import("std");
                 \\
                 \\pub fn build(b: *std.Build) void {{
@@ -5203,8 +5204,8 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)
                 .parent = root_mod,
             });
 
-            var cleanup_build_dir: ?fs.Dir = null;
-            defer if (cleanup_build_dir) |*dir| dir.close();
+            var cleanup_build_dir: ?Io.Dir = null;
+            defer if (cleanup_build_dir) |*dir| dir.close(io);
 
             if (dev.env.supports(.fetch_command)) {
                 const fetch_prog_node = root_prog_node.start("Fetch Packages", 0);
@@ -5296,6 +5297,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)
                 try job_queue.createDependenciesSource(&source_buf);
                 const deps_mod = try createDependenciesModule(
                     arena,
+                    io,
                     source_buf.items,
                     root_mod,
                     dirs,
@@ -5357,6 +5359,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)
                 }
             } else try createEmptyDependenciesModule(
                 arena,
+                io,
                 root_mod,
                 dirs,
                 config,
@@ -5623,7 +5626,7 @@ fn jitCmd(
         defer comp.destroy();
 
         if (options.server) {
-            var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
+            var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
             var server: std.zig.Server = .{
                 .out = &stdout_writer.interface,
                 .in = undefined, // won't be receiving messages
@@ -6156,7 +6159,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
         const arg = args[i];
         if (mem.startsWith(u8, arg, "-")) {
             if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                try fs.File.stdout().writeAll(usage_ast_check);
+                try Io.File.stdout().writeAll(usage_ast_check);
                 return cleanExit();
             } else if (mem.eql(u8, arg, "-t")) {
                 want_output_text = true;
@@ -6187,9 +6190,9 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
             break :file fs.cwd().openFile(p, .{}) catch |err| {
                 fatal("unable to open file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });
             };
-        } else fs.File.stdin();
-        defer if (zig_source_path != null) f.close();
-        var file_reader: fs.File.Reader = f.reader(io, &stdin_buffer);
+        } else Io.File.stdin();
+        defer if (zig_source_path != null) f.close(io);
+        var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);
         break :s std.zig.readSourceFileToEndAlloc(arena, &file_reader) catch |err| {
             fatal("unable to load file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });
         };
@@ -6207,7 +6210,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
 
     const tree = try Ast.parse(arena, source, mode);
 
-    var stdout_writer = fs.File.stdout().writerStreaming(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writerStreaming(&stdout_buffer);
     const stdout_bw = &stdout_writer.interface;
     switch (mode) {
         .zig => {
@@ -6330,7 +6333,7 @@ fn cmdDetectCpu(io: Io, args: []const []const u8) !void {
             const arg = args[i];
             if (mem.startsWith(u8, arg, "-")) {
                 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                    try fs.File.stdout().writeAll(detect_cpu_usage);
+                    try Io.File.stdout().writeAll(detect_cpu_usage);
                     return cleanExit();
                 } else if (mem.eql(u8, arg, "--llvm")) {
                     use_llvm = true;
@@ -6422,7 +6425,7 @@ fn detectNativeCpuWithLLVM(
 }
 
 fn printCpu(cpu: std.Target.Cpu) !void {
-    var stdout_writer = fs.File.stdout().writerStreaming(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writerStreaming(&stdout_buffer);
     const stdout_bw = &stdout_writer.interface;
 
     if (cpu.model.llvm_name) |llvm_name| {
@@ -6471,7 +6474,7 @@ fn cmdDumpLlvmInts(
     const dl = tm.createTargetDataLayout();
     const context = llvm.Context.create();
 
-    var stdout_writer = fs.File.stdout().writerStreaming(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writerStreaming(&stdout_buffer);
     const stdout_bw = &stdout_writer.interface;
     for ([_]u16{ 1, 8, 16, 32, 64, 128, 256 }) |bits| {
         const int_type = context.intType(bits);
@@ -6494,10 +6497,10 @@ fn cmdDumpZir(arena: Allocator, io: Io, args: []const []const u8) !void {
     var f = fs.cwd().openFile(cache_file, .{}) catch |err| {
         fatal("unable to open zir cache file for dumping '{s}': {s}", .{ cache_file, @errorName(err) });
     };
-    defer f.close();
+    defer f.close(io);
 
     const zir = try Zcu.loadZirCache(arena, io, f);
-    var stdout_writer = fs.File.stdout().writerStreaming(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writerStreaming(&stdout_buffer);
     const stdout_bw = &stdout_writer.interface;
     {
         const instruction_bytes = zir.instructions.len *
@@ -6540,16 +6543,16 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
     const old_source = source: {
         var f = fs.cwd().openFile(old_source_path, .{}) catch |err|
             fatal("unable to open old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
-        defer f.close();
-        var file_reader: fs.File.Reader = f.reader(io, &stdin_buffer);
+        defer f.close(io);
+        var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);
         break :source std.zig.readSourceFileToEndAlloc(arena, &file_reader) catch |err|
             fatal("unable to read old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
     };
     const new_source = source: {
         var f = fs.cwd().openFile(new_source_path, .{}) catch |err|
             fatal("unable to open new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
-        defer f.close();
-        var file_reader: fs.File.Reader = f.reader(io, &stdin_buffer);
+        defer f.close(io);
+        var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);
         break :source std.zig.readSourceFileToEndAlloc(arena, &file_reader) catch |err|
             fatal("unable to read new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
     };
@@ -6581,7 +6584,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
     var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;
     try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);
 
-    var stdout_writer = fs.File.stdout().writerStreaming(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writerStreaming(&stdout_buffer);
     const stdout_bw = &stdout_writer.interface;
     {
         try stdout_bw.print("Instruction mappings:\n", .{});
@@ -6912,7 +6915,7 @@ fn cmdFetch(
             const arg = args[i];
             if (mem.startsWith(u8, arg, "-")) {
                 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                    try fs.File.stdout().writeAll(usage_fetch);
+                    try Io.File.stdout().writeAll(usage_fetch);
                     return cleanExit();
                 } else if (mem.eql(u8, arg, "--global-cache-dir")) {
                     if (i + 1 >= args.len) fatal("expected argument after '{s}'", .{arg});
@@ -6958,7 +6961,7 @@ fn cmdFetch(
             .path = p,
         };
     };
-    defer global_cache_directory.handle.close();
+    defer global_cache_directory.handle.close(io);
 
     var job_queue: Package.Fetch.JobQueue = .{
         .io = io,
@@ -7021,7 +7024,7 @@ fn cmdFetch(
 
     const name = switch (save) {
         .no => {
-            var stdout = fs.File.stdout().writerStreaming(&stdout_buffer);
+            var stdout = Io.File.stdout().writerStreaming(&stdout_buffer);
             try stdout.interface.print("{s}\n", .{package_hash_slice});
             try stdout.interface.flush();
             return cleanExit();
@@ -7043,7 +7046,7 @@ fn cmdFetch(
 
     // The name to use in case the manifest file needs to be created now.
     const init_root_name = fs.path.basename(build_root.directory.path orelse cwd_path);
-    var manifest, var ast = try loadManifest(gpa, arena, .{
+    var manifest, var ast = try loadManifest(gpa, arena, io, .{
         .root_name = try sanitizeExampleName(arena, init_root_name),
         .dir = build_root.directory.handle,
         .color = color,
@@ -7168,6 +7171,7 @@ fn cmdFetch(
 
 fn createEmptyDependenciesModule(
     arena: Allocator,
+    io: Io,
     main_mod: *Package.Module,
     dirs: Compilation.Directories,
     global_options: Compilation.Config,
@@ -7176,6 +7180,7 @@ fn createEmptyDependenciesModule(
     try Package.Fetch.JobQueue.createEmptyDependenciesSource(&source);
     _ = try createDependenciesModule(
         arena,
+        io,
         source.items,
         main_mod,
         dirs,
@@ -7187,6 +7192,7 @@ fn createEmptyDependenciesModule(
 /// build runner to obtain via `@import("@dependencies")`.
 fn createDependenciesModule(
     arena: Allocator,
+    io: Io,
     source: []const u8,
     main_mod: *Package.Module,
     dirs: Compilation.Directories,
@@ -7198,7 +7204,7 @@ fn createDependenciesModule(
     const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ std.fmt.hex(rand_int);
     {
         var tmp_dir = try dirs.local_cache.handle.makeOpenPath(tmp_dir_sub_path, .{});
-        defer tmp_dir.close();
+        defer tmp_dir.close(io);
         try tmp_dir.writeFile(.{ .sub_path = basename, .data = source });
     }
 
@@ -7232,10 +7238,10 @@ fn createDependenciesModule(
 const BuildRoot = struct {
     directory: Cache.Directory,
     build_zig_basename: []const u8,
-    cleanup_build_dir: ?fs.Dir,
+    cleanup_build_dir: ?Io.Dir,
 
-    fn deinit(br: *BuildRoot) void {
-        if (br.cleanup_build_dir) |*dir| dir.close();
+    fn deinit(br: *BuildRoot, io: Io) void {
+        if (br.cleanup_build_dir) |*dir| dir.close(io);
         br.* = undefined;
     }
 };
@@ -7304,13 +7310,14 @@ fn findBuildRoot(arena: Allocator, options: FindBuildRootOptions) !BuildRoot {
 
 const LoadManifestOptions = struct {
     root_name: []const u8,
-    dir: fs.Dir,
+    dir: Io.Dir,
     color: Color,
 };
 
 fn loadManifest(
     gpa: Allocator,
     arena: Allocator,
+    io: Io,
     options: LoadManifestOptions,
 ) !struct { Package.Manifest, Ast } {
     const manifest_bytes = while (true) {
@@ -7322,7 +7329,7 @@ fn loadManifest(
             0,
         ) catch |err| switch (err) {
             error.FileNotFound => {
-                writeSimpleTemplateFile(Package.Manifest.basename,
+                writeSimpleTemplateFile(io, Package.Manifest.basename,
                     \\.{{
                     \\    .name = .{s},
                     \\    .version = "{s}",
@@ -7374,12 +7381,12 @@ fn loadManifest(
 
 const Templates = struct {
     zig_lib_directory: Cache.Directory,
-    dir: fs.Dir,
+    dir: Io.Dir,
     buffer: std.array_list.Managed(u8),
 
-    fn deinit(templates: *Templates) void {
-        templates.zig_lib_directory.handle.close();
-        templates.dir.close();
+    fn deinit(templates: *Templates, io: Io) void {
+        templates.zig_lib_directory.handle.close(io);
+        templates.dir.close(io);
         templates.buffer.deinit();
         templates.* = undefined;
     }
@@ -7387,7 +7394,7 @@ const Templates = struct {
     fn write(
         templates: *Templates,
         arena: Allocator,
-        out_dir: fs.Dir,
+        out_dir: Io.Dir,
         root_name: []const u8,
         template_path: []const u8,
         fingerprint: Package.Fingerprint,
@@ -7435,23 +7442,23 @@ const Templates = struct {
         });
     }
 };
-fn writeSimpleTemplateFile(file_name: []const u8, comptime fmt: []const u8, args: anytype) !void {
+fn writeSimpleTemplateFile(io: Io, file_name: []const u8, comptime fmt: []const u8, args: anytype) !void {
     const f = try fs.cwd().createFile(file_name, .{ .exclusive = true });
-    defer f.close();
+    defer f.close(io);
     var buf: [4096]u8 = undefined;
     var fw = f.writer(&buf);
     try fw.interface.print(fmt, args);
     try fw.interface.flush();
 }
 
-fn findTemplates(gpa: Allocator, arena: Allocator) Templates {
+fn findTemplates(gpa: Allocator, arena: Allocator, io: Io) Templates {
     const cwd_path = introspect.getResolvedCwd(arena) catch |err| {
         fatal("unable to get cwd: {s}", .{@errorName(err)});
     };
     const self_exe_path = fs.selfExePathAlloc(arena) catch |err| {
         fatal("unable to find self exe path: {s}", .{@errorName(err)});
     };
-    var zig_lib_directory = introspect.findZigLibDirFromSelfExe(arena, cwd_path, self_exe_path) catch |err| {
+    var zig_lib_directory = introspect.findZigLibDirFromSelfExe(arena, io, cwd_path, self_exe_path) catch |err| {
         fatal("unable to find zig installation directory '{s}': {s}", .{ self_exe_path, @errorName(err) });
     };
 
diff --git a/src/print_targets.zig b/src/print_targets.zig
index d9118b901b..2f80187de1 100644
--- a/src/print_targets.zig
+++ b/src/print_targets.zig
@@ -12,6 +12,7 @@ const introspect = @import("introspect.zig");
 
 pub fn cmdTargets(
     allocator: Allocator,
+    io: Io,
     args: []const []const u8,
     out: *std.Io.Writer,
     native_target: *const Target,
@@ -20,7 +21,7 @@ pub fn cmdTargets(
     var zig_lib_directory = introspect.findZigLibDir(allocator) catch |err| {
         fatal("unable to find zig installation directory: {s}\n", .{@errorName(err)});
     };
-    defer zig_lib_directory.handle.close();
+    defer zig_lib_directory.handle.close(io);
     defer allocator.free(zig_lib_directory.path.?);
 
     const abilists_contents = zig_lib_directory.handle.readFileAlloc(