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

12 files changed, 93 insertions, 65 deletions

diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig
index d5f4ebe2d9..9fb8123146 100644
--- a/lib/compiler/aro/aro/Compilation.zig
+++ b/lib/compiler/aro/aro/Compilation.zig
@@ -1639,8 +1639,10 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin
         return error.FileNotFound;
     }
 
+    const io = comp.io;
+
     const file = try comp.cwd.openFile(path, .{});
-    defer file.close();
+    defer file.close(io);
     return comp.addSourceFromFile(file, path, kind);
 }
 
@@ -1971,8 +1973,10 @@ fn getPathContents(comp: *Compilation, path: []const u8, limit: Io.Limit) ![]u8
         return error.FileNotFound;
     }
 
+    const io = comp.io;
+
     const file = try comp.cwd.openFile(path, .{});
-    defer file.close();
+    defer file.close(io);
     return comp.getFileContents(file, limit);
 }
 
diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig
index 6a399ece39..888ade2be4 100644
--- a/lib/compiler/aro/aro/Driver.zig
+++ b/lib/compiler/aro/aro/Driver.zig
@@ -1286,6 +1286,8 @@ fn processSource(
     d.comp.generated_buf.items.len = 0;
     const prev_total = d.diagnostics.errors;
 
+    const io = d.comp.io;
+
     var pp = try Preprocessor.initDefault(d.comp);
     defer pp.deinit();
 
@@ -1328,7 +1330,7 @@ fn processSource(
                 return d.fatal("unable to create dependency file '{s}': {s}", .{ path, errorDescription(er) })
         else
             std.fs.File.stdout();
-        defer if (dep_file_name != null) file.close();
+        defer if (dep_file_name != null) file.close(io);
 
         var file_writer = file.writer(&writer_buf);
         dep_file.write(&file_writer.interface) catch
@@ -1353,7 +1355,7 @@ fn processSource(
                 return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
         else
             std.fs.File.stdout();
-        defer if (d.output_name != null) file.close();
+        defer if (d.output_name != null) file.close(io);
 
         var file_writer = file.writer(&writer_buf);
         pp.prettyPrintTokens(&file_writer.interface, dump_mode) catch
@@ -1404,7 +1406,7 @@ fn processSource(
         if (d.only_preprocess_and_compile) {
             const out_file = d.comp.cwd.createFile(out_file_name, .{}) catch |er|
                 return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
-            defer out_file.close();
+            defer out_file.close(io);
 
             assembly.writeToFile(out_file) catch |er|
                 return d.fatal("unable to write to output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
@@ -1418,7 +1420,7 @@ fn processSource(
         const assembly_out_file_name = try d.getRandomFilename(&assembly_name_buf, ".s");
         const out_file = d.comp.cwd.createFile(assembly_out_file_name, .{}) catch |er|
             return d.fatal("unable to create output file '{s}': {s}", .{ assembly_out_file_name, errorDescription(er) });
-        defer out_file.close();
+        defer out_file.close(io);
         assembly.writeToFile(out_file) catch |er|
             return d.fatal("unable to write to output file '{s}': {s}", .{ assembly_out_file_name, errorDescription(er) });
         try d.invokeAssembler(tc, assembly_out_file_name, out_file_name);
@@ -1454,7 +1456,7 @@ fn processSource(
 
         const out_file = d.comp.cwd.createFile(out_file_name, .{}) catch |er|
             return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
-        defer out_file.close();
+        defer out_file.close(io);
 
         var file_writer = out_file.writer(&writer_buf);
         obj.finish(&file_writer.interface) catch
diff --git a/lib/compiler/aro/aro/Driver/Filesystem.zig b/lib/compiler/aro/aro/Driver/Filesystem.zig
index 87092cb235..19ac9bfe41 100644
--- a/lib/compiler/aro/aro/Driver/Filesystem.zig
+++ b/lib/compiler/aro/aro/Driver/Filesystem.zig
@@ -1,8 +1,10 @@
-const std = @import("std");
-const mem = std.mem;
 const builtin = @import("builtin");
 const is_windows = builtin.os.tag == .windows;
 
+const std = @import("std");
+const Io = std.Io;
+const mem = std.std.mem;
+
 fn readFileFake(entries: []const Filesystem.Entry, path: []const u8, buf: []u8) ?[]const u8 {
     @branchHint(.cold);
     for (entries) |entry| {
@@ -96,7 +98,7 @@ fn findProgramByNamePosix(name: []const u8, path: ?[]const u8, buf: []u8) ?[]con
 }
 
 pub const Filesystem = union(enum) {
-    real: std.fs.Dir,
+    real: std.Io.Dir,
     fake: []const Entry,
 
     const Entry = struct {
@@ -121,7 +123,7 @@ pub const Filesystem = union(enum) {
             base: []const u8,
             i: usize = 0,
 
-            fn next(self: *@This()) !?std.fs.Dir.Entry {
+            fn next(self: *@This()) !?std.Io.Dir.Entry {
                 while (self.i < self.entries.len) {
                     const entry = self.entries[self.i];
                     self.i += 1;
@@ -130,7 +132,7 @@ pub const Filesystem = union(enum) {
                         const remaining = entry.path[self.base.len + 1 ..];
                         if (std.mem.indexOfScalar(u8, remaining, std.fs.path.sep) != null) continue;
                         const extension = std.fs.path.extension(remaining);
-                        const kind: std.fs.Dir.Entry.Kind = if (extension.len == 0) .directory else .file;
+                        const kind: std.Io.Dir.Entry.Kind = if (extension.len == 0) .directory else .file;
                         return .{ .name = remaining, .kind = kind };
                     }
                 }
@@ -140,7 +142,7 @@ pub const Filesystem = union(enum) {
     };
 
     const Dir = union(enum) {
-        dir: std.fs.Dir,
+        dir: std.Io.Dir,
         fake: FakeDir,
 
         pub fn iterate(self: Dir) Iterator {
@@ -150,19 +152,19 @@ pub const Filesystem = union(enum) {
             };
         }
 
-        pub fn close(self: *Dir) void {
+        pub fn close(self: *Dir, io: Io) void {
             switch (self.*) {
-                .dir => |*d| d.close(),
+                .dir => |*d| d.close(io),
                 .fake => {},
             }
         }
     };
 
     const Iterator = union(enum) {
-        iterator: std.fs.Dir.Iterator,
+        iterator: std.Io.Dir.Iterator,
         fake: FakeDir.Iterator,
 
-        pub fn next(self: *Iterator) std.fs.Dir.Iterator.Error!?std.fs.Dir.Entry {
+        pub fn next(self: *Iterator) std.Io.Dir.Iterator.Error!?std.Io.Dir.Entry {
             return switch (self.*) {
                 .iterator => |*it| it.next(),
                 .fake => |*it| it.next(),
@@ -208,11 +210,11 @@ pub const Filesystem = union(enum) {
     /// Read the file at `path` into `buf`.
     /// Returns null if any errors are encountered
     /// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
-    pub fn readFile(fs: Filesystem, path: []const u8, buf: []u8) ?[]const u8 {
+    pub fn readFile(fs: Filesystem, io: Io, path: []const u8, buf: []u8) ?[]const u8 {
         return switch (fs) {
             .real => |cwd| {
                 const file = cwd.openFile(path, .{}) catch return null;
-                defer file.close();
+                defer file.close(io);
 
                 const bytes_read = file.readAll(buf) catch return null;
                 return buf[0..bytes_read];
@@ -221,7 +223,7 @@ pub const Filesystem = union(enum) {
         };
     }
 
-    pub fn openDir(fs: Filesystem, dir_name: []const u8) std.fs.Dir.OpenError!Dir {
+    pub fn openDir(fs: Filesystem, dir_name: []const u8) std.Io.Dir.OpenError!Dir {
         return switch (fs) {
             .real => |cwd| .{ .dir = try cwd.openDir(dir_name, .{ .access_sub_paths = false, .iterate = true }) },
             .fake => |entries| .{ .fake = .{ .entries = entries, .path = dir_name } },
diff --git a/lib/compiler/aro/aro/Toolchain.zig b/lib/compiler/aro/aro/Toolchain.zig
index 326278cc38..ae84369205 100644
--- a/lib/compiler/aro/aro/Toolchain.zig
+++ b/lib/compiler/aro/aro/Toolchain.zig
@@ -497,6 +497,7 @@ pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
     const comp = d.comp;
     const gpa = comp.gpa;
     const arena = comp.arena;
+    const io = comp.io;
     try d.includes.ensureUnusedCapacity(gpa, 1);
     if (d.resource_dir) |resource_dir| {
         const path = try std.fs.path.join(arena, &.{ resource_dir, "include" });
@@ -509,7 +510,7 @@ pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
     var search_path = d.aro_name;
     while (std.fs.path.dirname(search_path)) |dirname| : (search_path = dirname) {
         var base_dir = d.comp.cwd.openDir(dirname, .{}) catch continue;
-        defer base_dir.close();
+        defer base_dir.close(io);
 
         base_dir.access("include/stddef.h", .{}) catch continue;
         const path = try std.fs.path.join(arena, &.{ dirname, "include" });
diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig
index 7cf0f14e42..1608c121b1 100644
--- a/lib/compiler/objcopy.zig
+++ b/lib/compiler/objcopy.zig
@@ -152,7 +152,7 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
     const io = threaded.io();
 
     const input_file = fs.cwd().openFile(input, .{}) catch |err| fatal("failed to open {s}: {t}", .{ input, err });
-    defer input_file.close();
+    defer input_file.close(io);
 
     const stat = input_file.stat() catch |err| fatal("failed to stat {s}: {t}", .{ input, err });
 
@@ -180,7 +180,7 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
     const mode = if (out_fmt != .elf or only_keep_debug) fs.File.default_mode else stat.mode;
 
     var output_file = try fs.cwd().createFile(output, .{ .mode = mode });
-    defer output_file.close();
+    defer output_file.close(io);
 
     var out = output_file.writer(&output_buffer);
 
diff --git a/lib/compiler/resinator/cli.zig b/lib/compiler/resinator/cli.zig
index 59568e9cef..ffaa62e7ca 100644
--- a/lib/compiler/resinator/cli.zig
+++ b/lib/compiler/resinator/cli.zig
@@ -1991,6 +1991,8 @@ test "parse: input and output formats" {
 }
 
 test "maybeAppendRC" {
+    const io = std.testing.io;
+
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
 
@@ -2001,7 +2003,7 @@ test "maybeAppendRC" {
     // Create the file so that it's found. In this scenario, .rc should not get
     // appended.
     var file = try tmp.dir.createFile("foo", .{});
-    file.close();
+    file.close(io);
     try options.maybeAppendRC(tmp.dir);
     try std.testing.expectEqualStrings("foo", options.input_source.filename);
 
diff --git a/lib/compiler/resinator/compile.zig b/lib/compiler/resinator/compile.zig
index 08e161e505..7dc77e5ee1 100644
--- a/lib/compiler/resinator/compile.zig
+++ b/lib/compiler/resinator/compile.zig
@@ -34,7 +34,7 @@ const code_pages = @import("code_pages.zig");
 const errors = @import("errors.zig");
 
 pub const CompileOptions = struct {
-    cwd: std.fs.Dir,
+    cwd: std.Io.Dir,
     diagnostics: *Diagnostics,
     source_mappings: ?*SourceMappings = null,
     /// List of paths (absolute or relative to `cwd`) for every file that the resources within the .rc file depend on.
@@ -107,7 +107,7 @@ pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io
         // the cwd so we don't need to add it as a distinct search path.
         if (std.fs.path.dirname(root_path)) |root_dir_path| {
             var root_dir = try options.cwd.openDir(root_dir_path, .{});
-            errdefer root_dir.close();
+            errdefer root_dir.close(io);
             try search_dirs.append(allocator, .{ .dir = root_dir, .path = try allocator.dupe(u8, root_dir_path) });
         }
     }
@@ -136,7 +136,7 @@ pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io
             // TODO: maybe a warning that the search path is skipped?
             continue;
         };
-        errdefer dir.close();
+        errdefer dir.close(io);
         try search_dirs.append(allocator, .{ .dir = dir, .path = try allocator.dupe(u8, extra_include_path) });
     }
     for (options.system_include_paths) |system_include_path| {
@@ -144,7 +144,7 @@ pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io
             // TODO: maybe a warning that the search path is skipped?
             continue;
         };
-        errdefer dir.close();
+        errdefer dir.close(io);
         try search_dirs.append(allocator, .{ .dir = dir, .path = try allocator.dupe(u8, system_include_path) });
     }
     if (!options.ignore_include_env_var) {
@@ -160,7 +160,7 @@ pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io
         var it = std.mem.tokenizeScalar(u8, INCLUDE, delimiter);
         while (it.next()) |search_path| {
             var dir = openSearchPathDir(options.cwd, search_path) catch continue;
-            errdefer dir.close();
+            errdefer dir.close(io);
             try search_dirs.append(allocator, .{ .dir = dir, .path = try allocator.dupe(u8, search_path) });
         }
     }
@@ -196,7 +196,7 @@ pub const Compiler = struct {
     arena: Allocator,
     allocator: Allocator,
     io: Io,
-    cwd: std.fs.Dir,
+    cwd: std.Io.Dir,
     state: State = .{},
     diagnostics: *Diagnostics,
     dependencies: ?*Dependencies,
@@ -388,7 +388,9 @@ pub const Compiler = struct {
     ///       matching file is invalid. That is, it does not do the `cmd` PATH searching
     ///       thing of continuing to look for matching files until it finds a valid
     ///       one if a matching file is invalid.
-    fn searchForFile(self: *Compiler, path: []const u8) !std.fs.File {
+    fn searchForFile(self: *Compiler, path: []const u8) !std.Io.File {
+        const io = self.io;
+
         // If the path is absolute, then it is not resolved relative to any search
         // paths, so there's no point in checking them.
         //
@@ -405,7 +407,7 @@ pub const Compiler = struct {
         // an absolute path.
         if (std.fs.path.isAbsolute(path)) {
             const file = try utils.openFileNotDir(std.fs.cwd(), path, .{});
-            errdefer file.close();
+            errdefer file.close(io);
 
             if (self.dependencies) |dependencies| {
                 const duped_path = try dependencies.allocator.dupe(u8, path);
@@ -414,10 +416,10 @@ pub const Compiler = struct {
             }
         }
 
-        var first_error: ?(std.fs.File.OpenError || std.fs.File.StatError) = null;
+        var first_error: ?(std.Io.File.OpenError || std.Io.File.StatError) = null;
         for (self.search_dirs) |search_dir| {
             if (utils.openFileNotDir(search_dir.dir, path, .{})) |file| {
-                errdefer file.close();
+                errdefer file.close(io);
 
                 if (self.dependencies) |dependencies| {
                     const searched_file_path = try std.fs.path.join(dependencies.allocator, &.{
@@ -587,7 +589,7 @@ pub const Compiler = struct {
                 });
             },
         };
-        defer file_handle.close();
+        defer file_handle.close(io);
         var file_buffer: [2048]u8 = undefined;
         var file_reader = file_handle.reader(io, &file_buffer);
 
@@ -2892,9 +2894,9 @@ pub const Compiler = struct {
     }
 };
 
-pub const OpenSearchPathError = std.fs.Dir.OpenError;
+pub const OpenSearchPathError = std.Io.Dir.OpenError;
 
-fn openSearchPathDir(dir: std.fs.Dir, path: []const u8) OpenSearchPathError!std.fs.Dir {
+fn openSearchPathDir(dir: std.Io.Dir, path: []const u8) OpenSearchPathError!std.Io.Dir {
     // Validate the search path to avoid possible unreachable on invalid paths,
     // see https://github.com/ziglang/zig/issues/15607 for why this is currently necessary.
     try validateSearchPath(path);
@@ -2927,11 +2929,11 @@ fn validateSearchPath(path: []const u8) error{BadPathName}!void {
 }
 
 pub const SearchDir = struct {
-    dir: std.fs.Dir,
+    dir: std.Io.Dir,
     path: ?[]const u8,
 
-    pub fn deinit(self: *SearchDir, allocator: Allocator) void {
-        self.dir.close();
+    pub fn deinit(self: *SearchDir, allocator: Allocator, io: Io) void {
+        self.dir.close(io);
         if (self.path) |path| {
             allocator.free(path);
         }
diff --git a/lib/compiler/resinator/errors.zig b/lib/compiler/resinator/errors.zig
index 0060990ab6..8509aa610f 100644
--- a/lib/compiler/resinator/errors.zig
+++ b/lib/compiler/resinator/errors.zig
@@ -1221,8 +1221,8 @@ const CorrespondingLines = struct {
         };
     }
 
-    pub fn deinit(self: *CorrespondingLines) void {
-        self.file.close();
+    pub fn deinit(self: *CorrespondingLines, io: Io) void {
+        self.file.close(io);
     }
 };
 
diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig
index 6d6819f45a..42308a8987 100644
--- a/lib/compiler/resinator/main.zig
+++ b/lib/compiler/resinator/main.zig
@@ -296,7 +296,7 @@ pub fn main() !void {
                     error.ParseError, error.CompileError => {
                         try error_handler.emitDiagnostics(gpa, std.fs.cwd(), final_input, &diagnostics, mapping_results.mappings);
                         // Delete the output file on error
-                        res_stream.cleanupAfterError();
+                        res_stream.cleanupAfterError(io);
                         std.process.exit(1);
                     },
                     else => |e| return e,
@@ -315,7 +315,7 @@ pub fn main() !void {
                         try error_handler.emitMessage(gpa, .err, "unable to create depfile '{s}': {s}", .{ depfile_path, @errorName(err) });
                         std.process.exit(1);
                     };
-                    defer depfile.close();
+                    defer depfile.close(io);
 
                     var depfile_buffer: [1024]u8 = undefined;
                     var depfile_writer = depfile.writer(&depfile_buffer);
@@ -402,7 +402,7 @@ pub fn main() !void {
             },
         }
         // Delete the output file on error
-        coff_stream.cleanupAfterError();
+        coff_stream.cleanupAfterError(io);
         std.process.exit(1);
     };
 
@@ -434,11 +434,11 @@ const IoStream = struct {
         self.source.deinit(allocator);
     }
 
-    pub fn cleanupAfterError(self: *IoStream) void {
+    pub fn cleanupAfterError(self: *IoStream, io: Io) void {
         switch (self.source) {
             .file => |file| {
                 // Delete the output file on error
-                file.close();
+                file.close(io);
                 // Failing to delete is not really a big deal, so swallow any errors
                 std.fs.cwd().deleteFile(self.name) catch {};
             },
@@ -465,9 +465,9 @@ const IoStream = struct {
             }
         }
 
-        pub fn deinit(self: *Source, allocator: Allocator) void {
+        pub fn deinit(self: *Source, allocator: Allocator, io: Io) void {
             switch (self.*) {
-                .file => |file| file.close(),
+                .file => |file| file.close(io),
                 .stdio => {},
                 .memory => |*list| list.deinit(allocator),
                 .closed => {},
diff --git a/lib/compiler/resinator/utils.zig b/lib/compiler/resinator/utils.zig
index 021b8cf4de..f8080539cb 100644
--- a/lib/compiler/resinator/utils.zig
+++ b/lib/compiler/resinator/utils.zig
@@ -1,6 +1,8 @@
-const std = @import("std");
 const builtin = @import("builtin");
 
+const std = @import("std");
+const Io = std.Io;
+
 pub const UncheckedSliceWriter = struct {
     const Self = @This();
 
@@ -28,11 +30,12 @@ pub const UncheckedSliceWriter = struct {
 /// TODO: Remove once https://github.com/ziglang/zig/issues/5732 is addressed.
 pub fn openFileNotDir(
     cwd: std.fs.Dir,
+    io: Io,
     path: []const u8,
     flags: std.fs.File.OpenFlags,
 ) (std.fs.File.OpenError || std.fs.File.StatError)!std.fs.File {
-    const file = try cwd.openFile(path, flags);
-    errdefer file.close();
+    const file = try cwd.openFile(io, path, flags);
+    errdefer file.close(io);
     // https://github.com/ziglang/zig/issues/5732
     if (builtin.os.tag != .windows) {
         const stat = try file.stat();
diff --git a/lib/compiler/std-docs.zig b/lib/compiler/std-docs.zig
index 12825146a2..15c17ee59b 100644
--- a/lib/compiler/std-docs.zig
+++ b/lib/compiler/std-docs.zig
@@ -1,12 +1,14 @@
 const builtin = @import("builtin");
+
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const Cache = std.Build.Cache;
 
 fn usage() noreturn {
-    std.fs.File.stdout().writeAll(
+    std.Io.File.stdout().writeAll(
         \\Usage: zig std [options]
         \\
         \\Options:
@@ -27,6 +29,10 @@ pub fn main() !void {
     var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;
     const gpa = general_purpose_allocator.allocator();
 
+    var threaded: std.Io.Threaded = .init(gpa);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     var argv = try std.process.argsWithAllocator(arena);
     defer argv.deinit();
     assert(argv.skip());
@@ -35,7 +41,7 @@ pub fn main() !void {
     const global_cache_path = argv.next().?;
 
     var lib_dir = try std.fs.cwd().openDir(zig_lib_directory, .{});
-    defer lib_dir.close();
+    defer lib_dir.close(io);
 
     var listen_port: u16 = 0;
     var force_open_browser: ?bool = null;
@@ -64,7 +70,7 @@ pub fn main() !void {
     });
     const port = http_server.listen_address.in.getPort();
     const url_with_newline = try std.fmt.allocPrint(arena, "http://127.0.0.1:{d}/\n", .{port});
-    std.fs.File.stdout().writeAll(url_with_newline) catch {};
+    std.Io.File.stdout().writeAll(url_with_newline) catch {};
     if (should_open_browser) {
         openBrowserTab(gpa, url_with_newline[0 .. url_with_newline.len - 1 :'\n']) catch |err| {
             std.log.err("unable to open browser: {s}", .{@errorName(err)});
@@ -73,6 +79,7 @@ pub fn main() !void {
 
     var context: Context = .{
         .gpa = gpa,
+        .io = io,
         .zig_exe_path = zig_exe_path,
         .global_cache_path = global_cache_path,
         .lib_dir = lib_dir,
@@ -83,14 +90,15 @@ pub fn main() !void {
         const connection = try http_server.accept();
         _ = std.Thread.spawn(.{}, accept, .{ &context, connection }) catch |err| {
             std.log.err("unable to accept connection: {s}", .{@errorName(err)});
-            connection.stream.close();
+            connection.stream.close(io);
             continue;
         };
     }
 }
 
 fn accept(context: *Context, connection: std.net.Server.Connection) void {
-    defer connection.stream.close();
+    const io = context.io;
+    defer connection.stream.close(io);
 
     var recv_buffer: [4000]u8 = undefined;
     var send_buffer: [4000]u8 = undefined;
@@ -124,6 +132,7 @@ fn accept(context: *Context, connection: std.net.Server.Connection) void {
 
 const Context = struct {
     gpa: Allocator,
+    io: Io,
     lib_dir: std.fs.Dir,
     zig_lib_directory: []const u8,
     zig_exe_path: []const u8,
@@ -185,6 +194,7 @@ fn serveDocsFile(
 
 fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
     const gpa = context.gpa;
+    const io = context.io;
 
     var send_buffer: [0x4000]u8 = undefined;
     var response = try request.respondStreaming(&send_buffer, .{
@@ -197,7 +207,7 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
     });
 
     var std_dir = try context.lib_dir.openDir("std", .{ .iterate = true });
-    defer std_dir.close();
+    defer std_dir.close(io);
 
     var walker = try std_dir.walk(gpa);
     defer walker.deinit();
@@ -216,11 +226,11 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
             else => continue,
         }
         var file = try entry.dir.openFile(entry.basename, .{});
-        defer file.close();
+        defer file.close(io);
         const stat = try file.stat();
-        var file_reader: std.fs.File.Reader = .{
+        var file_reader: std.Io.File.Reader = .{
             .file = file,
-            .interface = std.fs.File.Reader.initInterface(&.{}),
+            .interface = std.Io.File.Reader.initInterface(&.{}),
             .size = stat.size,
         };
         try archiver.writeFile(entry.path, &file_reader, stat.mtime);
@@ -283,6 +293,7 @@ fn buildWasmBinary(
     optimize_mode: std.builtin.OptimizeMode,
 ) !Cache.Path {
     const gpa = context.gpa;
+    const io = context.io;
 
     var argv: std.ArrayList([]const u8) = .empty;
 
@@ -371,7 +382,7 @@ fn buildWasmBinary(
     }
 
     // Send EOF to stdin.
-    child.stdin.?.close();
+    child.stdin.?.close(io);
     child.stdin = null;
 
     switch (try child.wait()) {
@@ -410,7 +421,7 @@ fn buildWasmBinary(
     };
 }
 
-fn sendMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag) !void {
+fn sendMessage(file: std.Io.File, tag: std.zig.Client.Message.Tag) !void {
     const header: std.zig.Client.Message.Header = .{
         .tag = tag,
         .bytes_len = 0,
diff --git a/lib/compiler/translate-c/main.zig b/lib/compiler/translate-c/main.zig
index b0d7a5d9bd..0c72298b30 100644
--- a/lib/compiler/translate-c/main.zig
+++ b/lib/compiler/translate-c/main.zig
@@ -121,6 +121,7 @@ pub const usage =
 
 fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration: bool) !void {
     const gpa = d.comp.gpa;
+    const io = d.comp.io;
 
     const aro_args = args: {
         var i: usize = 0;
@@ -228,7 +229,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration
                 return d.fatal("unable to create dependency file '{s}': {s}", .{ path, aro.Driver.errorDescription(er) })
         else
             std.fs.File.stdout();
-        defer if (dep_file_name != null) file.close();
+        defer if (dep_file_name != null) file.close(io);
 
         var file_writer = file.writer(&out_buf);
         dep_file.write(&file_writer.interface) catch
@@ -246,7 +247,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration
     var close_out_file = false;
     var out_file_path: []const u8 = "<stdout>";
     var out_file: std.fs.File = .stdout();
-    defer if (close_out_file) out_file.close();
+    defer if (close_out_file) out_file.close(io);
 
     if (d.output_name) |path| blk: {
         if (std.mem.eql(u8, path, "-")) break :blk;