update all std.fs.cwd() to std.Io.Dir.cwd()

20 files changed, 111 insertions, 98 deletions

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 24b994f608..5f15ef5f74 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -450,7 +450,7 @@ pub const Path = struct {
         const dir = switch (p.root) {
             .none => {
                 const cwd_sub_path = absToCwdRelative(p.sub_path, dirs.cwd);
-                return .{ fs.cwd(), cwd_sub_path };
+                return .{ Io.Dir.cwd(), cwd_sub_path };
             },
             .zig_lib => dirs.zig_lib.handle,
             .global_cache => dirs.global_cache.handle,
@@ -723,7 +723,7 @@ pub const Directories = struct {
 
     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;
+        const close_local = dirs.local_cache.handle.handle != dirs.global_cache.handle.handle;
 
         dirs.global_cache.handle.close(io);
         if (close_local) dirs.local_cache.handle.close(io);
@@ -814,7 +814,7 @@ pub const Directories = struct {
         return .{
             .path = if (std.mem.eql(u8, name, ".")) null else name,
             .handle = .{
-                .fd = preopens.find(name) orelse fatal("WASI preopen not found: '{s}'", .{name}),
+                .handle = preopens.find(name) orelse fatal("WASI preopen not found: '{s}'", .{name}),
             },
         };
     }
@@ -824,8 +824,8 @@ pub const Directories = struct {
         };
         const nonempty_path = if (path.len == 0) "." else path;
         const handle_or_err = switch (thing) {
-            .@"zig lib" => fs.cwd().openDir(nonempty_path, .{}),
-            .@"global cache", .@"local cache" => fs.cwd().makeOpenPath(nonempty_path, .{}),
+            .@"zig lib" => Io.Dir.cwd().openDir(nonempty_path, .{}),
+            .@"global cache", .@"local cache" => Io.Dir.cwd().makeOpenPath(nonempty_path, .{}),
         };
         return .{
             .path = if (path.len == 0) null else path,
@@ -1104,7 +1104,7 @@ pub const CObject = struct {
             const source_line = source_line: {
                 if (diag.src_loc.offset == 0 or diag.src_loc.column == 0) break :source_line 0;
 
-                const file = fs.cwd().openFile(io, file_name, .{}) catch break :source_line 0;
+                const file = Io.Dir.cwd().openFile(io, file_name, .{}) catch break :source_line 0;
                 defer file.close(io);
                 var buffer: [1024]u8 = undefined;
                 var file_reader = file.reader(io, &buffer);
@@ -1179,7 +1179,7 @@ pub const CObject = struct {
                 };
 
                 var buffer: [1024]u8 = undefined;
-                const file = try fs.cwd().openFile(io, path, .{});
+                const file = try Io.Dir.cwd().openFile(io, path, .{});
                 defer file.close(io);
                 var file_reader = file.reader(io, &buffer);
                 var bc = std.zig.llvm.BitcodeReader.init(gpa, .{ .reader = &file_reader.interface });
@@ -2109,7 +2109,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic,
             },
         };
         // These correspond to std.zig.Server.Message.PathPrefix.
-        cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
+        cache.addPrefix(.{ .path = null, .handle = Io.Dir.cwd() });
         cache.addPrefix(options.dirs.zig_lib);
         cache.addPrefix(options.dirs.local_cache);
         cache.addPrefix(options.dirs.global_cache);
@@ -5220,7 +5220,7 @@ fn createDepFile(
     binfile: Cache.Path,
 ) anyerror!void {
     var buf: [4096]u8 = undefined;
-    var af = try std.fs.cwd().atomicFile(depfile, .{ .write_buffer = &buf });
+    var af = try Io.Dir.cwd().atomicFile(depfile, .{ .write_buffer = &buf });
     defer af.deinit();
 
     comp.writeDepFile(binfile, &af.file_writer.interface) catch return af.file_writer.err.?;
@@ -5284,7 +5284,7 @@ fn docsCopyFallible(comp: *Compilation) anyerror!void {
         };
     }
 
-    var tar_file = out_dir.createFile("sources.tar", .{}) catch |err| {
+    var tar_file = out_dir.createFile(io, "sources.tar", .{}) catch |err| {
         return comp.lockAndSetMiscFailure(
             .docs_copy,
             "unable to create '{f}/sources.tar': {s}",
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index 3bd05120ff..8a30529bc5 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -383,14 +383,14 @@ pub fn run(f: *Fetch) RunError!void {
         },
         .remote => |remote| remote,
         .path_or_url => |path_or_url| {
-            if (fs.cwd().openDir(path_or_url, .{ .iterate = true })) |dir| {
+            if (Io.Dir.cwd().openDir(path_or_url, .{ .iterate = true })) |dir| {
                 var resource: Resource = .{ .dir = dir };
                 return f.runResource(path_or_url, &resource, null);
             } else |dir_err| {
                 var server_header_buffer: [init_resource_buffer_size]u8 = undefined;
 
                 const file_err = if (dir_err == error.NotDir) e: {
-                    if (fs.cwd().openFile(io, path_or_url, .{})) |file| {
+                    if (Io.Dir.cwd().openFile(io, path_or_url, .{})) |file| {
                         var resource: Resource = .{ .file = file.reader(io, &server_header_buffer) };
                         return f.runResource(path_or_url, &resource, null);
                     } else |err| break :e err;
@@ -1303,7 +1303,7 @@ fn unzip(
         const random_integer = std.crypto.random.int(u64);
         zip_path[prefix.len..][0..random_len].* = std.fmt.hex(random_integer);
 
-        break cache_root.handle.createFile(&zip_path, .{
+        break cache_root.handle.createFile(io, &zip_path, .{
             .exclusive = true,
             .read = true,
         }) catch |err| switch (err) {
@@ -1365,7 +1365,7 @@ fn unpackGitPack(f: *Fetch, out_dir: Io.Dir, resource: *Resource.Git) anyerror!U
     {
         var pack_dir = try out_dir.makeOpenPath(".git", .{});
         defer pack_dir.close(io);
-        var pack_file = try pack_dir.createFile("pkg.pack", .{ .read = true });
+        var pack_file = try pack_dir.createFile(io, "pkg.pack", .{ .read = true });
         defer pack_file.close(io);
         var pack_file_buffer: [4096]u8 = undefined;
         var pack_file_reader = b: {
@@ -1376,7 +1376,7 @@ fn unpackGitPack(f: *Fetch, out_dir: Io.Dir, resource: *Resource.Git) anyerror!U
             break :b pack_file_writer.moveToReader(io);
         };
 
-        var index_file = try pack_dir.createFile("pkg.idx", .{ .read = true });
+        var index_file = try pack_dir.createFile(io, "pkg.idx", .{ .read = true });
         defer index_file.close(io);
         var index_file_buffer: [2000]u8 = undefined;
         var index_file_writer = index_file.writer(&index_file_buffer);
@@ -2235,7 +2235,7 @@ test "set executable bit based on file content" {
 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, .{});
+    var tmp_file = try dir.createFile(io, tarball_name, .{});
     defer tmp_file.close(io);
     try tmp_file.writeAll(tarball_content);
 }
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig
index ccae9440e2..7b08a89cae 100644
--- a/src/Package/Fetch/git.zig
+++ b/src/Package/Fetch/git.zig
@@ -264,7 +264,7 @@ pub const Repository = struct {
                     try repository.odb.seekOid(entry.oid);
                     const file_object = try repository.odb.readObject();
                     if (file_object.type != .blob) return error.InvalidFile;
-                    var file = dir.createFile(entry.name, .{ .exclusive = true }) catch |e| {
+                    var file = dir.createFile(io, entry.name, .{ .exclusive = true }) catch |e| {
                         const file_name = try std.fs.path.join(diagnostics.allocator, &.{ current_path, entry.name });
                         errdefer diagnostics.allocator.free(file_name);
                         try diagnostics.errors.append(diagnostics.allocator, .{ .unable_to_create_file = .{
@@ -1584,14 +1584,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 });
+    var pack_file = try git_dir.dir.createFile(io, "testrepo.pack", .{ .read = true });
     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 });
+    var index_file = try git_dir.dir.createFile(io, "testrepo.idx", .{ .read = true });
     defer index_file.close(io);
     var index_file_buffer: [2000]u8 = undefined;
     var index_file_writer = index_file.writer(&index_file_buffer);
@@ -1714,20 +1714,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(io, args[2], .{});
+    var pack_file = try Io.Dir.cwd().openFile(io, args[2], .{});
     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], .{});
+    var worktree = try Io.Dir.cwd().makeOpenPath(args[4], .{});
     defer worktree.close(io);
 
     var git_dir = try worktree.makeOpenPath(".git", .{});
     defer git_dir.close(io);
 
     std.debug.print("Starting index...\n", .{});
-    var index_file = try git_dir.createFile("idx", .{ .read = true });
+    var index_file = try git_dir.createFile(io, "idx", .{ .read = true });
     defer index_file.close(io);
     var index_file_buffer: [4096]u8 = undefined;
     var index_file_writer = index_file.writer(&index_file_buffer);
diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig
index 45b1302138..9a75b2096e 100644
--- a/src/Zcu/PerThread.zig
+++ b/src/Zcu/PerThread.zig
@@ -170,7 +170,7 @@ pub fn updateFile(
     // version. Likewise if we're working on AstGen and another process asks for
     // the cached file, they'll get it.
     const cache_file = while (true) {
-        break zir_dir.createFile(&hex_digest, .{
+        break zir_dir.createFile(io, &hex_digest, .{
             .read = true,
             .truncate = false,
             .lock = lock,
@@ -196,7 +196,7 @@ pub fn updateFile(
                         cache_directory,
                     });
                 }
-                break zir_dir.createFile(&hex_digest, .{
+                break zir_dir.createFile(io, &hex_digest, .{
                     .read = true,
                     .truncate = false,
                     .lock = lock,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index cb4fe0459f..4fc58c2c4b 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1,19 +1,22 @@
-const std = @import("std");
 const builtin = @import("builtin");
+
+const std = @import("std");
+const Io = std.Io;
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const log = std.log.scoped(.codegen);
 const math = std.math;
 const DW = std.dwarf;
-
 const Builder = std.zig.llvm.Builder;
+
+const build_options = @import("build_options");
 const llvm = if (build_options.have_llvm)
     @import("llvm/bindings.zig")
 else
     @compileError("LLVM unavailable");
+
 const link = @import("../link.zig");
 const Compilation = @import("../Compilation.zig");
-const build_options = @import("build_options");
 const Zcu = @import("../Zcu.zig");
 const InternPool = @import("../InternPool.zig");
 const Package = @import("../Package.zig");
@@ -964,7 +967,7 @@ pub const Object = struct {
                 if (std.mem.eql(u8, path, "-")) {
                     o.builder.dump();
                 } else {
-                    o.builder.printToFilePath(std.fs.cwd(), path) catch |err| {
+                    o.builder.printToFilePath(Io.Dir.cwd(), path) catch |err| {
                         log.err("failed printing LLVM module to \"{s}\": {s}", .{ path, @errorName(err) });
                     };
                 }
@@ -978,7 +981,7 @@ pub const Object = struct {
             o.builder.clearAndFree();
 
             if (options.pre_bc_path) |path| {
-                var file = std.fs.cwd().createFile(path, .{}) catch |err|
+                var file = Io.Dir.cwd().createFile(io, path, .{}) catch |err|
                     return diags.fail("failed to create '{s}': {s}", .{ path, @errorName(err) });
                 defer file.close(io);
 
@@ -991,7 +994,7 @@ pub const Object = struct {
                 options.post_ir_path == null and options.post_bc_path == null) return;
 
             if (options.post_bc_path) |path| {
-                var file = std.fs.cwd().createFile(path, .{}) catch |err|
+                var file = Io.Dir.cwd().createFile(io, path, .{}) catch |err|
                     return diags.fail("failed to create '{s}': {s}", .{ path, @errorName(err) });
                 defer file.close(io);
 
@@ -2711,7 +2714,7 @@ pub const Object = struct {
     }
 
     fn allocTypeName(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error![:0]const u8 {
-        var aw: std.Io.Writer.Allocating = .init(o.gpa);
+        var aw: Io.Writer.Allocating = .init(o.gpa);
         defer aw.deinit();
         ty.print(&aw.writer, pt, null) catch |err| switch (err) {
             error.WriteFailed => return error.OutOfMemory,
diff --git a/src/fmt.zig b/src/fmt.zig
index ce8a31fa4c..36a3833986 100644
--- a/src/fmt.zig
+++ b/src/fmt.zig
@@ -182,11 +182,11 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
     // Mark any excluded files/directories as already seen,
     // so that they are skipped later during actual processing
     for (excluded_files.items) |file_path| {
-        const stat = fs.cwd().statFile(file_path) catch |err| switch (err) {
+        const stat = Io.Dir.cwd().statFile(file_path) catch |err| switch (err) {
             error.FileNotFound => continue,
             // On Windows, statFile does not work for directories
             error.IsDir => dir: {
-                var dir = try fs.cwd().openDir(file_path, .{});
+                var dir = try Io.Dir.cwd().openDir(file_path, .{});
                 defer dir.close(io);
                 break :dir try dir.stat();
             },
@@ -196,7 +196,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
     }
 
     for (input_files.items) |file_path| {
-        try fmtPath(&fmt, file_path, check_flag, fs.cwd(), file_path);
+        try fmtPath(&fmt, file_path, check_flag, Io.Dir.cwd(), file_path);
     }
     try fmt.stdout_writer.interface.flush();
     if (fmt.any_error) {
diff --git a/src/introspect.zig b/src/introspect.zig
index d2faa9a55c..04ddf47e8a 100644
--- a/src/introspect.zig
+++ b/src/introspect.zig
@@ -82,7 +82,7 @@ pub fn findZigLibDirFromSelfExe(
     cwd_path: []const u8,
     self_exe_path: []const u8,
 ) error{ OutOfMemory, FileNotFound }!Cache.Directory {
-    const cwd = fs.cwd();
+    const cwd = Io.Dir.cwd();
     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;
@@ -206,7 +206,7 @@ pub fn resolveSuitableLocalCacheDir(arena: Allocator, cwd: []const u8) Allocator
     var cur_dir = cwd;
     while (true) {
         const joined = try fs.path.join(arena, &.{ cur_dir, Package.build_zig_basename });
-        if (fs.cwd().access(joined, .{})) |_| {
+        if (Io.Dir.cwd().access(joined, .{})) |_| {
             return try fs.path.join(arena, &.{ cur_dir, default_local_zig_cache_basename });
         } else |err| switch (err) {
             error.FileNotFound => {
diff --git a/src/libs/freebsd.zig b/src/libs/freebsd.zig
index 8c5e0afe4b..cfd8d5554c 100644
--- a/src/libs/freebsd.zig
+++ b/src/libs/freebsd.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const mem = std.mem;
 const log = std.log;
-const fs = std.fs;
-const path = fs.path;
+const path = std.Io.Dir.path;
 const assert = std.debug.assert;
 const Version = std.SemanticVersion;
 const Path = std.Build.Cache.Path;
@@ -446,7 +446,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .io = io,
         .manifest_dir = try comp.dirs.global_cache.handle.makeOpenPath("h", .{}),
     };
-    cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
+    cache.addPrefix(.{ .path = null, .handle = Io.Dir.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
     defer cache.manifest_dir.close(io);
@@ -468,7 +468,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
             .lock = man.toOwnedLock(),
             .dir_path = .{
                 .root_dir = comp.dirs.global_cache,
-                .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+                .sub_path = try gpa.dupe(u8, "o" ++ path.sep_str ++ digest),
             },
         });
     }
@@ -986,7 +986,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .lock = man.toOwnedLock(),
         .dir_path = .{
             .root_dir = comp.dirs.global_cache,
-            .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+            .sub_path = try gpa.dupe(u8, "o" ++ path.sep_str ++ digest),
         },
     });
 }
@@ -1014,7 +1014,7 @@ fn queueSharedObjects(comp: *Compilation, so_files: BuiltSharedObjects) std.Io.C
             const so_path: Path = .{
                 .root_dir = so_files.dir_path.root_dir,
                 .sub_path = std.fmt.allocPrint(comp.arena, "{s}{c}lib{s}.so.{d}", .{
-                    so_files.dir_path.sub_path, fs.path.sep, lib.name, lib.getSoVersion(&target.os),
+                    so_files.dir_path.sub_path, path.sep, lib.name, lib.getSoVersion(&target.os),
                 }) catch return comp.setAllocFailure(),
             };
             task_buffer[task_buffer_i] = .{ .load_dso = so_path };
diff --git a/src/libs/glibc.zig b/src/libs/glibc.zig
index bec20ff3d4..e3d8ce1f7f 100644
--- a/src/libs/glibc.zig
+++ b/src/libs/glibc.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const mem = std.mem;
 const log = std.log;
-const fs = std.fs;
-const path = fs.path;
+const path = std.Io.Dir.path;
 const assert = std.debug.assert;
 const Version = std.SemanticVersion;
 const Path = std.Build.Cache.Path;
@@ -681,7 +681,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .io = io,
         .manifest_dir = try comp.dirs.global_cache.handle.makeOpenPath("h", .{}),
     };
-    cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
+    cache.addPrefix(.{ .path = null, .handle = Io.Dir.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
     defer cache.manifest_dir.close(io);
@@ -703,7 +703,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
             .lock = man.toOwnedLock(),
             .dir_path = .{
                 .root_dir = comp.dirs.global_cache,
-                .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+                .sub_path = try gpa.dupe(u8, "o" ++ path.sep_str ++ digest),
             },
         });
     }
@@ -775,7 +775,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         try stubs_asm.appendSlice(".text\n");
 
         var sym_i: usize = 0;
-        var sym_name_buf: std.Io.Writer.Allocating = .init(arena);
+        var sym_name_buf: Io.Writer.Allocating = .init(arena);
         var opt_symbol_name: ?[]const u8 = null;
         var versions_buffer: [32]u8 = undefined;
         var versions_len: usize = undefined;
@@ -796,7 +796,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         // twice, which causes a "duplicate symbol" assembler error.
         var versions_written = std.AutoArrayHashMap(Version, void).init(arena);
 
-        var inc_reader: std.Io.Reader = .fixed(metadata.inclusions);
+        var inc_reader: Io.Reader = .fixed(metadata.inclusions);
 
         const fn_inclusions_len = try inc_reader.takeInt(u16, .little);
 
@@ -1130,7 +1130,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .lock = man.toOwnedLock(),
         .dir_path = .{
             .root_dir = comp.dirs.global_cache,
-            .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+            .sub_path = try gpa.dupe(u8, "o" ++ path.sep_str ++ digest),
         },
     });
 }
@@ -1156,7 +1156,7 @@ fn queueSharedObjects(comp: *Compilation, so_files: BuiltSharedObjects) std.Io.C
             const so_path: Path = .{
                 .root_dir = so_files.dir_path.root_dir,
                 .sub_path = std.fmt.allocPrint(comp.arena, "{s}{c}lib{s}.so.{d}", .{
-                    so_files.dir_path.sub_path, fs.path.sep, lib.name, lib.sover,
+                    so_files.dir_path.sub_path, path.sep, lib.name, lib.sover,
                 }) catch return comp.setAllocFailure(),
             };
             task_buffer[task_buffer_i] = .{ .load_dso = so_path };
diff --git a/src/libs/mingw.zig b/src/libs/mingw.zig
index 005696e1fc..b3ca51e833 100644
--- a/src/libs/mingw.zig
+++ b/src/libs/mingw.zig
@@ -1,7 +1,8 @@
 const std = @import("std");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const mem = std.mem;
-const path = std.fs.path;
+const path = std.Io.Dir.path;
 const assert = std.debug.assert;
 const log = std.log.scoped(.mingw);
 
@@ -259,7 +260,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         .io = io,
         .manifest_dir = try comp.dirs.global_cache.handle.makeOpenPath("h", .{}),
     };
-    cache.addPrefix(.{ .path = null, .handle = std.fs.cwd() });
+    cache.addPrefix(.{ .path = null, .handle = Io.Dir.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
     defer cache.manifest_dir.close(io);
@@ -304,7 +305,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
         .output = .{ .to_list = .{ .arena = .init(gpa) } },
     };
     defer diagnostics.deinit();
-    var aro_comp = aro.Compilation.init(gpa, arena, io, &diagnostics, std.fs.cwd());
+    var aro_comp = aro.Compilation.init(gpa, arena, io, &diagnostics, Io.Dir.cwd());
     defer aro_comp.deinit();
 
     aro_comp.target = .fromZigTarget(target.*);
@@ -343,7 +344,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     }
 
     const members = members: {
-        var aw: std.Io.Writer.Allocating = .init(gpa);
+        var aw: Io.Writer.Allocating = .init(gpa);
         errdefer aw.deinit();
         try pp.prettyPrintTokens(&aw.writer, .result_only);
 
@@ -376,7 +377,7 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
     errdefer gpa.free(lib_final_path);
 
     {
-        const lib_final_file = try o_dir.createFile(final_lib_basename, .{ .truncate = true });
+        const lib_final_file = try o_dir.createFile(io, final_lib_basename, .{ .truncate = true });
         defer lib_final_file.close(io);
         var buffer: [1024]u8 = undefined;
         var file_writer = lib_final_file.writer(&buffer);
@@ -442,7 +443,7 @@ fn findDef(
         } else {
             try override_path.print(fmt_path, .{ lib_path, lib_name });
         }
-        if (std.fs.cwd().access(override_path.items, .{})) |_| {
+        if (Io.Dir.cwd().access(override_path.items, .{})) |_| {
             return override_path.toOwnedSlice();
         } else |err| switch (err) {
             error.FileNotFound => {},
@@ -459,7 +460,7 @@ fn findDef(
         } else {
             try override_path.print(fmt_path, .{lib_name});
         }
-        if (std.fs.cwd().access(override_path.items, .{})) |_| {
+        if (Io.Dir.cwd().access(override_path.items, .{})) |_| {
             return override_path.toOwnedSlice();
         } else |err| switch (err) {
             error.FileNotFound => {},
@@ -476,7 +477,7 @@ fn findDef(
         } else {
             try override_path.print(fmt_path, .{lib_name});
         }
-        if (std.fs.cwd().access(override_path.items, .{})) |_| {
+        if (Io.Dir.cwd().access(override_path.items, .{})) |_| {
             return override_path.toOwnedSlice();
         } else |err| switch (err) {
             error.FileNotFound => {},
diff --git a/src/libs/netbsd.zig b/src/libs/netbsd.zig
index 67e6a2f903..cb6a80d69d 100644
--- a/src/libs/netbsd.zig
+++ b/src/libs/netbsd.zig
@@ -1,9 +1,9 @@
 const std = @import("std");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const mem = std.mem;
 const log = std.log;
-const fs = std.fs;
-const path = fs.path;
+const path = std.Io.Dir.path;
 const assert = std.debug.assert;
 const Version = std.SemanticVersion;
 const Path = std.Build.Cache.Path;
@@ -387,7 +387,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .io = io,
         .manifest_dir = try comp.dirs.global_cache.handle.makeOpenPath("h", .{}),
     };
-    cache.addPrefix(.{ .path = null, .handle = fs.cwd() });
+    cache.addPrefix(.{ .path = null, .handle = Io.Dir.cwd() });
     cache.addPrefix(comp.dirs.zig_lib);
     cache.addPrefix(comp.dirs.global_cache);
     defer cache.manifest_dir.close(io);
@@ -409,7 +409,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
             .lock = man.toOwnedLock(),
             .dir_path = .{
                 .root_dir = comp.dirs.global_cache,
-                .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+                .sub_path = try gpa.dupe(u8, "o" ++ path.sep_str ++ digest),
             },
         });
     }
@@ -640,7 +640,7 @@ pub fn buildSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) anye
         .lock = man.toOwnedLock(),
         .dir_path = .{
             .root_dir = comp.dirs.global_cache,
-            .sub_path = try gpa.dupe(u8, "o" ++ fs.path.sep_str ++ digest),
+            .sub_path = try gpa.dupe(u8, "o" ++ path.sep_str ++ digest),
         },
     });
 }
@@ -661,7 +661,7 @@ fn queueSharedObjects(comp: *Compilation, so_files: BuiltSharedObjects) std.Io.C
             const so_path: Path = .{
                 .root_dir = so_files.dir_path.root_dir,
                 .sub_path = std.fmt.allocPrint(comp.arena, "{s}{c}lib{s}.so.{d}", .{
-                    so_files.dir_path.sub_path, fs.path.sep, lib.name, lib.sover,
+                    so_files.dir_path.sub_path, path.sep, lib.name, lib.sover,
                 }) catch return comp.setAllocFailure(),
             };
             task_buffer[task_buffer_i] = .{ .load_dso = so_path };
diff --git a/src/link/C.zig b/src/link/C.zig
index 04c92443e5..a001f8fdd9 100644
--- a/src/link/C.zig
+++ b/src/link/C.zig
@@ -136,7 +136,7 @@ pub fn createEmpty(
     assert(!use_lld);
     assert(!use_llvm);
 
-    const file = try emit.root_dir.handle.createFile(emit.sub_path, .{
+    const file = try emit.root_dir.handle.createFile(io, emit.sub_path, .{
         // Truncation is done on `flush`.
         .truncate = false,
     });
@@ -792,7 +792,7 @@ pub fn flushEmitH(zcu: *Zcu) !void {
     }
 
     const directory = emit_h.loc.directory orelse zcu.comp.local_cache_directory;
-    const file = try directory.handle.createFile(emit_h.loc.basename, .{
+    const file = try directory.handle.createFile(io, emit_h.loc.basename, .{
         // We set the end position explicitly below; by not truncating the file, we possibly
         // make it easier on the file system by doing 1 reallocation instead of two.
         .truncate = false,
diff --git a/src/link/Coff.zig b/src/link/Coff.zig
index e1d52fb7c4..009e59ed0d 100644
--- a/src/link/Coff.zig
+++ b/src/link/Coff.zig
@@ -631,12 +631,14 @@ fn create(
         else => return error.UnsupportedCOFFArchitecture,
     };
 
+    const io = comp.io;
+
     const coff = try arena.create(Coff);
-    const file = try path.root_dir.handle.createFile(comp.io, path.sub_path, .{
+    const file = try path.root_dir.handle.createFile(io, path.sub_path, .{
         .read = true,
         .mode = link.File.determineMode(comp.config.output_mode, comp.config.link_mode),
     });
-    errdefer file.close(comp.io);
+    errdefer file.close(io);
     coff.* = .{
         .base = .{
             .tag = .coff2,
diff --git a/src/link/Elf.zig b/src/link/Elf.zig
index 584a50c7f2..53812a37ec 100644
--- a/src/link/Elf.zig
+++ b/src/link/Elf.zig
@@ -313,9 +313,11 @@ pub fn createEmpty(
     const is_obj = output_mode == .Obj;
     const is_obj_or_ar = is_obj or (output_mode == .Lib and link_mode == .static);
 
+    const io = comp.io;
+
     // What path should this ELF linker code output to?
     const sub_path = emit.sub_path;
-    self.base.file = try emit.root_dir.handle.createFile(sub_path, .{
+    self.base.file = try emit.root_dir.handle.createFile(io, sub_path, .{
         .truncate = true,
         .read = true,
         .mode = link.File.determineMode(output_mode, link_mode),
diff --git a/src/link/Lld.zig b/src/link/Lld.zig
index 49f6d3f7c7..b25b9da9d9 100644
--- a/src/link/Lld.zig
+++ b/src/link/Lld.zig
@@ -1572,7 +1572,7 @@ fn wasmLink(lld: *Lld, arena: Allocator) !void {
             // report a nice error here with the file path if it fails instead of
             // just returning the error code.
             // chmod does not interact with umask, so we use a conservative -rwxr--r-- here.
-            std.posix.fchmodat(fs.cwd().fd, full_out_path, 0o744, 0) catch |err| switch (err) {
+            std.posix.fchmodat(Io.Dir.cwd().handle, full_out_path, 0o744, 0) catch |err| switch (err) {
                 error.OperationNotSupported => unreachable, // Not a symlink.
                 else => |e| return e,
             };
@@ -1624,7 +1624,7 @@ fn spawnLld(comp: *Compilation, arena: Allocator, argv: []const []const u8) !voi
                 const rand_int = std.crypto.random.int(u64);
                 const rsp_path = "tmp" ++ s ++ std.fmt.hex(rand_int) ++ ".rsp";
 
-                const rsp_file = try comp.dirs.local_cache.handle.createFile(rsp_path, .{});
+                const rsp_file = try comp.dirs.local_cache.handle.createFile(io, rsp_path, .{});
                 defer comp.dirs.local_cache.handle.deleteFileZ(rsp_path) catch |err|
                     log.warn("failed to delete response file {s}: {s}", .{ rsp_path, @errorName(err) });
                 {
diff --git a/src/link/MachO.zig b/src/link/MachO.zig
index e837cc853a..0f6127e10e 100644
--- a/src/link/MachO.zig
+++ b/src/link/MachO.zig
@@ -219,7 +219,9 @@ pub fn createEmpty(
     };
     errdefer self.base.destroy();
 
-    self.base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
+    const io = comp.io;
+
+    self.base.file = try emit.root_dir.handle.createFile(io, emit.sub_path, .{
         .truncate = true,
         .read = true,
         .mode = link.File.determineMode(output_mode, link_mode),
@@ -1082,7 +1084,7 @@ fn accessLibPath(
         test_path.clearRetainingCapacity();
         try test_path.print("{s}" ++ sep ++ "lib{s}{s}", .{ search_dir, name, ext });
         try checked_paths.append(try arena.dupe(u8, test_path.items));
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
+        Io.Dir.cwd().access(test_path.items, .{}) catch |err| switch (err) {
             error.FileNotFound => continue,
             else => |e| return e,
         };
@@ -1110,7 +1112,7 @@ fn accessFrameworkPath(
             ext,
         });
         try checked_paths.append(try arena.dupe(u8, test_path.items));
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
+        Io.Dir.cwd().access(test_path.items, .{}) catch |err| switch (err) {
             error.FileNotFound => continue,
             else => |e| return e,
         };
@@ -1191,7 +1193,7 @@ fn parseDependentDylibs(self: *MachO) !void {
                             try test_path.print("{s}{s}", .{ path, ext });
                         }
                         try checked_paths.append(try arena.dupe(u8, test_path.items));
-                        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
+                        Io.Dir.cwd().access(test_path.items, .{}) catch |err| switch (err) {
                             error.FileNotFound => continue,
                             else => |e| return e,
                         };
@@ -3289,7 +3291,7 @@ pub fn reopenDebugInfo(self: *MachO) !void {
     var d_sym_bundle = try self.base.emit.root_dir.handle.makeOpenPath(d_sym_path, .{});
     defer d_sym_bundle.close(io);
 
-    self.d_sym.?.file = try d_sym_bundle.createFile(fs.path.basename(self.base.emit.sub_path), .{
+    self.d_sym.?.file = try d_sym_bundle.createFile(io, fs.path.basename(self.base.emit.sub_path), .{
         .truncate = false,
         .read = true,
     });
@@ -4370,7 +4372,7 @@ fn inferSdkVersion(comp: *Compilation, sdk_layout: SdkLayout) ?std.SemanticVersi
 // The file/property is also available with vendored libc.
 fn readSdkVersionFromSettings(arena: Allocator, dir: []const u8) ![]const u8 {
     const sdk_path = try fs.path.join(arena, &.{ dir, "SDKSettings.json" });
-    const contents = try fs.cwd().readFileAlloc(sdk_path, arena, .limited(std.math.maxInt(u16)));
+    const contents = try Io.Dir.cwd().readFileAlloc(sdk_path, arena, .limited(std.math.maxInt(u16)));
     const parsed = try std.json.parseFromSlice(std.json.Value, arena, contents, .{});
     if (parsed.value.object.get("MinimalDisplayName")) |ver| return ver.string;
     return error.SdkVersionFailure;
diff --git a/src/link/MachO/CodeSignature.zig b/src/link/MachO/CodeSignature.zig
index 5f9a9ecac9..814faf234a 100644
--- a/src/link/MachO/CodeSignature.zig
+++ b/src/link/MachO/CodeSignature.zig
@@ -247,7 +247,7 @@ pub fn deinit(self: *CodeSignature, allocator: Allocator) void {
 }
 
 pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, path: []const u8) !void {
-    const inner = try fs.cwd().readFileAlloc(path, allocator, .limited(std.math.maxInt(u32)));
+    const inner = try Io.Dir.cwd().readFileAlloc(path, allocator, .limited(std.math.maxInt(u32)));
     self.entitlements = .{ .inner = inner };
 }
 
diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig
index 7e28dc0a8b..d13caaa315 100644
--- a/src/link/SpirV.zig
+++ b/src/link/SpirV.zig
@@ -33,6 +33,7 @@ pub fn createEmpty(
     options: link.File.OpenOptions,
 ) !*Linker {
     const gpa = comp.gpa;
+    const io = comp.io;
     const target = &comp.root_mod.resolved_target.result;
 
     assert(!comp.config.use_lld); // Caught by Compilation.Config.resolve
@@ -78,7 +79,7 @@ pub fn createEmpty(
     };
     errdefer linker.deinit();
 
-    linker.base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
+    linker.base.file = try emit.root_dir.handle.createFile(io, emit.sub_path, .{
         .truncate = true,
         .read = true,
     });
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 7ab1e0eb4b..5f89625d56 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -2997,7 +2997,9 @@ pub fn createEmpty(
         .named => |name| (try wasm.internString(name)).toOptional(),
     };
 
-    wasm.base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
+    const io = comp.io;
+
+    wasm.base.file = try emit.root_dir.handle.createFile(io, emit.sub_path, .{
         .truncate = true,
         .read = true,
         .mode = if (fs.has_executable_bit)
diff --git a/src/main.zig b/src/main.zig
index b040b6c8ef..67b7384b57 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -713,7 +713,7 @@ const Emit = union(enum) {
             } else e: {
                 // If there's a dirname, check that dir exists. This will give a more descriptive error than `Compilation` otherwise would.
                 if (fs.path.dirname(path)) |dir_path| {
-                    var dir = fs.cwd().openDir(dir_path, .{}) catch |err| {
+                    var dir = Io.Dir.cwd().openDir(dir_path, .{}) catch |err| {
                         fatal("unable to open output directory '{s}': {s}", .{ dir_path, @errorName(err) });
                     };
                     dir.close(io);
@@ -3304,7 +3304,7 @@ fn buildOutputType(
         } else emit: {
             // If there's a dirname, check that dir exists. This will give a more descriptive error than `Compilation` otherwise would.
             if (fs.path.dirname(path)) |dir_path| {
-                var dir = fs.cwd().openDir(dir_path, .{}) catch |err| {
+                var dir = Io.Dir.cwd().openDir(dir_path, .{}) catch |err| {
                     fatal("unable to open output directory '{s}': {s}", .{ dir_path, @errorName(err) });
                 };
                 dir.close(io);
@@ -3389,7 +3389,7 @@ fn buildOutputType(
         // file will not run and this temp file will be leaked. The filename
         // 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, .{});
+        var f = try dirs.local_cache.handle.createFile(io, dump_path, .{});
         defer f.close(io);
 
         // Re-using the hasher from Cache, since the functional requirements
@@ -4773,7 +4773,7 @@ fn cmdInit(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
             var ok_count: usize = 0;
 
             for (template_paths) |template_path| {
-                if (templates.write(arena, fs.cwd(), sanitized_root_name, template_path, fingerprint)) |_| {
+                if (templates.write(arena, Io.Dir.cwd(), sanitized_root_name, template_path, fingerprint)) |_| {
                     std.log.info("created {s}", .{template_path});
                     ok_count += 1;
                 } else |err| switch (err) {
@@ -5227,7 +5227,7 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8)
                 if (system_pkg_dir_path) |p| {
                     job_queue.global_cache = .{
                         .path = p,
-                        .handle = fs.cwd().openDir(p, .{}) catch |err| {
+                        .handle = Io.Dir.cwd().openDir(p, .{}) catch |err| {
                             fatal("unable to open system package directory '{s}': {s}", .{
                                 p, @errorName(err),
                             });
@@ -5823,7 +5823,7 @@ const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true,
 /// Initialize the arguments from a Response File. "*.rsp"
 fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
     const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
-    const cmd_line = try fs.cwd().readFileAlloc(resp_file_path, allocator, .limited(max_bytes));
+    const cmd_line = try Io.Dir.cwd().readFileAlloc(resp_file_path, allocator, .limited(max_bytes));
     errdefer allocator.free(cmd_line);
 
     return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
@@ -6187,7 +6187,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
     const display_path = zig_source_path orelse "<stdin>";
     const source: [:0]const u8 = s: {
         var f = if (zig_source_path) |p| file: {
-            break :file fs.cwd().openFile(io, p, .{}) catch |err| {
+            break :file Io.Dir.cwd().openFile(io, p, .{}) catch |err| {
                 fatal("unable to open file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });
             };
         } else Io.File.stdin();
@@ -6494,7 +6494,7 @@ fn cmdDumpZir(arena: Allocator, io: Io, args: []const []const u8) !void {
 
     const cache_file = args[0];
 
-    var f = fs.cwd().openFile(io, cache_file, .{}) catch |err| {
+    var f = Io.Dir.cwd().openFile(io, cache_file, .{}) catch |err| {
         fatal("unable to open zir cache file for dumping '{s}': {s}", .{ cache_file, @errorName(err) });
     };
     defer f.close(io);
@@ -6541,7 +6541,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
     const new_source_path = args[1];
 
     const old_source = source: {
-        var f = fs.cwd().openFile(io, old_source_path, .{}) catch |err|
+        var f = Io.Dir.cwd().openFile(io, old_source_path, .{}) catch |err|
             fatal("unable to open old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
         defer f.close(io);
         var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);
@@ -6549,7 +6549,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
             fatal("unable to read old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
     };
     const new_source = source: {
-        var f = fs.cwd().openFile(io, new_source_path, .{}) catch |err|
+        var f = Io.Dir.cwd().openFile(io, new_source_path, .{}) catch |err|
             fatal("unable to open new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
         defer f.close(io);
         var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);
@@ -6845,7 +6845,7 @@ fn accessFrameworkPath(
             framework_dir_path, framework_name, framework_name, ext,
         });
         try checked_paths.print("\n {s}", .{test_path.items});
-        fs.cwd().access(test_path.items, .{}) catch |err| switch (err) {
+        Io.Dir.cwd().access(test_path.items, .{}) catch |err| switch (err) {
             error.FileNotFound => continue,
             else => |e| fatal("unable to search for {s} framework '{s}': {s}", .{
                 ext, test_path.items, @errorName(e),
@@ -6957,7 +6957,7 @@ fn cmdFetch(
     var global_cache_directory: Directory = l: {
         const p = override_global_cache_dir orelse try introspect.resolveGlobalCacheDir(arena);
         break :l .{
-            .handle = try fs.cwd().makeOpenPath(p, .{}),
+            .handle = try Io.Dir.cwd().makeOpenPath(p, .{}),
             .path = p,
         };
     };
@@ -7260,7 +7260,7 @@ fn findBuildRoot(arena: Allocator, options: FindBuildRootOptions) !BuildRoot {
 
     if (options.build_file) |bf| {
         if (fs.path.dirname(bf)) |dirname| {
-            const dir = fs.cwd().openDir(dirname, .{}) catch |err| {
+            const dir = Io.Dir.cwd().openDir(dirname, .{}) catch |err| {
                 fatal("unable to open directory to build file from argument 'build-file', '{s}': {s}", .{ dirname, @errorName(err) });
             };
             return .{
@@ -7272,7 +7272,7 @@ fn findBuildRoot(arena: Allocator, options: FindBuildRootOptions) !BuildRoot {
 
         return .{
             .build_zig_basename = build_zig_basename,
-            .directory = .{ .path = null, .handle = fs.cwd() },
+            .directory = .{ .path = null, .handle = Io.Dir.cwd() },
             .cleanup_build_dir = null,
         };
     }
@@ -7280,8 +7280,8 @@ fn findBuildRoot(arena: Allocator, options: FindBuildRootOptions) !BuildRoot {
     var dirname: []const u8 = cwd_path;
     while (true) {
         const joined_path = try fs.path.join(arena, &[_][]const u8{ dirname, build_zig_basename });
-        if (fs.cwd().access(joined_path, .{})) |_| {
-            const dir = fs.cwd().openDir(dirname, .{}) catch |err| {
+        if (Io.Dir.cwd().access(joined_path, .{})) |_| {
+            const dir = Io.Dir.cwd().openDir(dirname, .{}) catch |err| {
                 fatal("unable to open directory while searching for build.zig file, '{s}': {s}", .{ dirname, @errorName(err) });
             };
             return .{
@@ -7443,7 +7443,7 @@ const Templates = struct {
     }
 };
 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 });
+    const f = try Io.Dir.cwd().createFile(io, file_name, .{ .exclusive = true });
     defer f.close(io);
     var buf: [4096]u8 = undefined;
     var fw = f.writer(&buf);
@@ -7591,7 +7591,7 @@ fn addLibDirectoryWarn2(
     ignore_not_found: bool,
 ) void {
     lib_directories.appendAssumeCapacity(.{
-        .handle = fs.cwd().openDir(path, .{}) catch |err| {
+        .handle = Io.Dir.cwd().openDir(path, .{}) catch |err| {
             if (err == error.FileNotFound and ignore_not_found) return;
             warn("unable to open library directory '{s}': {s}", .{ path, @errorName(err) });
             return;