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

14 files changed, 60 insertions, 57 deletions

diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig
index 09e4861d13..b3e4d5544d 100644
--- a/lib/compiler/aro/aro/Compilation.zig
+++ b/lib/compiler/aro/aro/Compilation.zig
@@ -2253,7 +2253,7 @@ test "addSourceFromBuffer" {
             var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
             defer arena.deinit();
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, &diagnostics, std.fs.cwd());
+            var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
             defer comp.deinit();
 
             const source = try comp.addSourceFromBuffer("path", str);
@@ -2267,7 +2267,7 @@ test "addSourceFromBuffer" {
             var arena: std.heap.ArenaAllocator = .init(allocator);
             defer arena.deinit();
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(allocator, arena.allocator(), std.testing.io, &diagnostics, std.fs.cwd());
+            var comp = Compilation.init(allocator, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
             defer comp.deinit();
 
             _ = try comp.addSourceFromBuffer("path", "spliced\\\nbuffer\n");
@@ -2313,7 +2313,7 @@ test "addSourceFromBuffer - exhaustive check for carriage return elimination" {
     var buf: [alphabet.len]u8 = @splat(alphabet[0]);
 
     var diagnostics: Diagnostics = .{ .output = .ignore };
-    var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, &diagnostics, std.fs.cwd());
+    var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
     defer comp.deinit();
 
     var source_count: u32 = 0;
@@ -2341,7 +2341,7 @@ test "ignore BOM at beginning of file" {
     const Test = struct {
         fn run(arena: Allocator, buf: []const u8) !void {
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, &diagnostics, std.fs.cwd());
+            var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, &diagnostics, Io.Dir.cwd());
             defer comp.deinit();
 
             const source = try comp.addSourceFromBuffer("file.c", buf);
diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig
index f933e3ce52..fec3cea0f8 100644
--- a/lib/compiler/aro/aro/Driver.zig
+++ b/lib/compiler/aro/aro/Driver.zig
@@ -1327,7 +1327,7 @@ fn processSource(
         const dep_file_name = try d.getDepFileName(source, writer_buf[0..std.fs.max_name_bytes]);
 
         const file = if (dep_file_name) |path|
-            d.comp.cwd.createFile(path, .{}) catch |er|
+            d.comp.cwd.createFile(io, path, .{}) catch |er|
                 return d.fatal("unable to create dependency file '{s}': {s}", .{ path, errorDescription(er) })
         else
             Io.File.stdout();
@@ -1352,7 +1352,7 @@ fn processSource(
         }
 
         const file = if (d.output_name) |some|
-            d.comp.cwd.createFile(some, .{}) catch |er|
+            d.comp.cwd.createFile(io, some, .{}) catch |er|
                 return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
         else
             Io.File.stdout();
@@ -1405,7 +1405,7 @@ fn processSource(
         defer assembly.deinit(gpa);
 
         if (d.only_preprocess_and_compile) {
-            const out_file = d.comp.cwd.createFile(out_file_name, .{}) catch |er|
+            const out_file = d.comp.cwd.createFile(io, out_file_name, .{}) catch |er|
                 return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
             defer out_file.close(io);
 
@@ -1419,7 +1419,7 @@ fn processSource(
         // then assemble to out_file_name
         var assembly_name_buf: [std.fs.max_name_bytes]u8 = undefined;
         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|
+        const out_file = d.comp.cwd.createFile(io, 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(io);
         assembly.writeToFile(out_file) catch |er|
@@ -1455,7 +1455,7 @@ fn processSource(
         };
         defer obj.deinit();
 
-        const out_file = d.comp.cwd.createFile(out_file_name, .{}) catch |er|
+        const out_file = d.comp.cwd.createFile(io, out_file_name, .{}) catch |er|
             return d.fatal("unable to create output file '{s}': {s}", .{ out_file_name, errorDescription(er) });
         defer out_file.close(io);
 
diff --git a/lib/compiler/aro/aro/Parser.zig b/lib/compiler/aro/aro/Parser.zig
index 4a89e0d460..fc21ee4d0b 100644
--- a/lib/compiler/aro/aro/Parser.zig
+++ b/lib/compiler/aro/aro/Parser.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 const assert = std.debug.assert;
@@ -211,7 +212,7 @@ fn checkIdentifierCodepointWarnings(p: *Parser, codepoint: u21, loc: Source.Loca
 
     const prev_total = p.diagnostics.total;
     var sf = std.heap.stackFallback(1024, p.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var allocating: Io.Writer.Allocating = .init(sf.get());
     defer allocating.deinit();
 
     if (!char_info.isC99IdChar(codepoint)) {
@@ -425,7 +426,7 @@ pub fn err(p: *Parser, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype)
     if (p.diagnostics.effectiveKind(diagnostic) == .off) return;
 
     var sf = std.heap.stackFallback(1024, p.comp.gpa);
-    var allocating: std.Io.Writer.Allocating = .init(sf.get());
+    var allocating: Io.Writer.Allocating = .init(sf.get());
     defer allocating.deinit();
 
     p.formatArgs(&allocating.writer, diagnostic.fmt, args) catch return error.OutOfMemory;
@@ -447,7 +448,7 @@ pub fn err(p: *Parser, tok_i: TokenIndex, diagnostic: Diagnostic, args: anytype)
     }, p.pp.expansionSlice(tok_i), true);
 }
 
-fn formatArgs(p: *Parser, w: *std.Io.Writer, fmt: []const u8, args: anytype) !void {
+fn formatArgs(p: *Parser, w: *Io.Writer, fmt: []const u8, args: anytype) !void {
     var i: usize = 0;
     inline for (std.meta.fields(@TypeOf(args))) |arg_info| {
         const arg = @field(args, arg_info.name);
@@ -476,13 +477,13 @@ fn formatArgs(p: *Parser, w: *std.Io.Writer, fmt: []const u8, args: anytype) !vo
     try w.writeAll(fmt[i..]);
 }
 
-fn formatTokenId(w: *std.Io.Writer, fmt: []const u8, tok_id: Tree.Token.Id) !usize {
+fn formatTokenId(w: *Io.Writer, fmt: []const u8, tok_id: Tree.Token.Id) !usize {
     const i = Diagnostics.templateIndex(w, fmt, "{tok_id}");
     try w.writeAll(tok_id.symbol());
     return i;
 }
 
-fn formatQualType(p: *Parser, w: *std.Io.Writer, fmt: []const u8, qt: QualType) !usize {
+fn formatQualType(p: *Parser, w: *Io.Writer, fmt: []const u8, qt: QualType) !usize {
     const i = Diagnostics.templateIndex(w, fmt, "{qt}");
     try w.writeByte('\'');
     try qt.print(p.comp, w);
@@ -501,7 +502,7 @@ fn formatQualType(p: *Parser, w: *std.Io.Writer, fmt: []const u8, qt: QualType)
     return i;
 }
 
-fn formatResult(p: *Parser, w: *std.Io.Writer, fmt: []const u8, res: Result) !usize {
+fn formatResult(p: *Parser, w: *Io.Writer, fmt: []const u8, res: Result) !usize {
     const i = Diagnostics.templateIndex(w, fmt, "{value}");
     switch (res.val.opt_ref) {
         .none => try w.writeAll("(none)"),
@@ -524,7 +525,7 @@ const Normalized = struct {
         return .{ .str = str };
     }
 
-    pub fn format(ctx: Normalized, w: *std.Io.Writer, fmt: []const u8) !usize {
+    pub fn format(ctx: Normalized, w: *Io.Writer, fmt: []const u8) !usize {
         const i = Diagnostics.templateIndex(w, fmt, "{normalized}");
         var it: std.unicode.Utf8Iterator = .{
             .bytes = ctx.str,
@@ -558,7 +559,7 @@ const Codepoint = struct {
         return .{ .codepoint = codepoint };
     }
 
-    pub fn format(ctx: Codepoint, w: *std.Io.Writer, fmt: []const u8) !usize {
+    pub fn format(ctx: Codepoint, w: *Io.Writer, fmt: []const u8) !usize {
         const i = Diagnostics.templateIndex(w, fmt, "{codepoint}");
         try w.print("{X:0>4}", .{ctx.codepoint});
         return i;
@@ -572,7 +573,7 @@ const Escaped = struct {
         return .{ .str = str };
     }
 
-    pub fn format(ctx: Escaped, w: *std.Io.Writer, fmt: []const u8) !usize {
+    pub fn format(ctx: Escaped, w: *Io.Writer, fmt: []const u8) !usize {
         const i = Diagnostics.templateIndex(w, fmt, "{s}");
         try std.zig.stringEscape(ctx.str, w);
         return i;
@@ -1453,7 +1454,7 @@ fn decl(p: *Parser) Error!bool {
     return true;
 }
 
-fn staticAssertMessage(p: *Parser, cond_node: Node.Index, maybe_message: ?Result, allocating: *std.Io.Writer.Allocating) !?[]const u8 {
+fn staticAssertMessage(p: *Parser, cond_node: Node.Index, maybe_message: ?Result, allocating: *Io.Writer.Allocating) !?[]const u8 {
     const w = &allocating.writer;
 
     const cond = cond_node.get(&p.tree);
@@ -1526,7 +1527,7 @@ fn staticAssert(p: *Parser) Error!bool {
     } else {
         if (!res.val.toBool(p.comp)) {
             var sf = std.heap.stackFallback(1024, gpa);
-            var allocating: std.Io.Writer.Allocating = .init(sf.get());
+            var allocating: Io.Writer.Allocating = .init(sf.get());
             defer allocating.deinit();
 
             if (p.staticAssertMessage(res_node, str, &allocating) catch return error.OutOfMemory) |message| {
@@ -9719,7 +9720,7 @@ fn primaryExpr(p: *Parser) Error!?Result {
                 qt = some.qt;
             } else if (p.func.qt) |func_qt| {
                 var sf = std.heap.stackFallback(1024, gpa);
-                var allocating: std.Io.Writer.Allocating = .init(sf.get());
+                var allocating: Io.Writer.Allocating = .init(sf.get());
                 defer allocating.deinit();
 
                 func_qt.printNamed(p.tokSlice(p.func.name), p.comp, &allocating.writer) catch return error.OutOfMemory;
@@ -10608,7 +10609,7 @@ test "Node locations" {
     const arena = arena_state.allocator();
 
     var diagnostics: Diagnostics = .{ .output = .ignore };
-    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, &diagnostics, std.fs.cwd());
+    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, &diagnostics, Io.Dir.cwd());
     defer comp.deinit();
 
     const file = try comp.addSourceFromBuffer("file.c",
diff --git a/lib/compiler/aro/aro/Preprocessor.zig b/lib/compiler/aro/aro/Preprocessor.zig
index d47727cbf0..e8343dc83a 100644
--- a/lib/compiler/aro/aro/Preprocessor.zig
+++ b/lib/compiler/aro/aro/Preprocessor.zig
@@ -3900,7 +3900,7 @@ test "Preserve pragma tokens sometimes" {
             defer arena.deinit();
 
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, std.fs.cwd());
+            var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
             defer comp.deinit();
 
             try comp.addDefaultPragmaHandlers();
@@ -3967,7 +3967,7 @@ test "destringify" {
     var arena: std.heap.ArenaAllocator = .init(gpa);
     defer arena.deinit();
     var diagnostics: Diagnostics = .{ .output = .ignore };
-    var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, std.fs.cwd());
+    var comp = Compilation.init(gpa, arena.allocator(), std.testing.io, &diagnostics, Io.Dir.cwd());
     defer comp.deinit();
     var pp = Preprocessor.init(&comp, .default);
     defer pp.deinit();
@@ -4030,7 +4030,7 @@ test "Include guards" {
             const arena = arena_state.allocator();
 
             var diagnostics: Diagnostics = .{ .output = .ignore };
-            var comp = Compilation.init(gpa, arena, std.testing.io, &diagnostics, std.fs.cwd());
+            var comp = Compilation.init(gpa, arena, std.testing.io, &diagnostics, Io.Dir.cwd());
             defer comp.deinit();
             var pp = Preprocessor.init(&comp, .default);
             defer pp.deinit();
diff --git a/lib/compiler/aro/aro/Tokenizer.zig b/lib/compiler/aro/aro/Tokenizer.zig
index c497c5ce82..198d49364a 100644
--- a/lib/compiler/aro/aro/Tokenizer.zig
+++ b/lib/compiler/aro/aro/Tokenizer.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const assert = std.debug.assert;
 
 const Compilation = @import("Compilation.zig");
@@ -2326,7 +2327,7 @@ test "Tokenizer fuzz test" {
         fn testOne(_: @This(), input_bytes: []const u8) anyerror!void {
             var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
             defer arena.deinit();
-            var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, std.fs.cwd());
+            var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, Io.Dir.cwd());
             defer comp.deinit();
 
             const source = try comp.addSourceFromBuffer("fuzz.c", input_bytes);
@@ -2351,7 +2352,7 @@ test "Tokenizer fuzz test" {
 fn expectTokensExtra(contents: []const u8, expected_tokens: []const Token.Id, langopts: ?LangOpts) !void {
     var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
     defer arena.deinit();
-    var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, std.fs.cwd());
+    var comp = Compilation.init(std.testing.allocator, arena.allocator(), std.testing.io, undefined, Io.Dir.cwd());
     defer comp.deinit();
     if (langopts) |provided| {
         comp.langopts = provided;
diff --git a/lib/compiler/aro/aro/Value.zig b/lib/compiler/aro/aro/Value.zig
index 25a2d1824f..14949ce03b 100644
--- a/lib/compiler/aro/aro/Value.zig
+++ b/lib/compiler/aro/aro/Value.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const assert = std.debug.assert;
 const BigIntConst = std.math.big.int.Const;
 const BigIntMutable = std.math.big.int.Mutable;
@@ -80,7 +81,7 @@ test "minUnsignedBits" {
     defer arena_state.deinit();
     const arena = arena_state.allocator();
 
-    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, std.fs.cwd());
+    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, Io.Dir.cwd());
     defer comp.deinit();
     const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
     comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));
@@ -119,7 +120,7 @@ test "minSignedBits" {
     defer arena_state.deinit();
     const arena = arena_state.allocator();
 
-    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, std.fs.cwd());
+    var comp = Compilation.init(std.testing.allocator, arena, std.testing.io, undefined, Io.Dir.cwd());
     defer comp.deinit();
     const target_query = try std.Target.Query.parse(.{ .arch_os_abi = "x86_64-linux-gnu" });
     comp.target = .fromZigTarget(try std.zig.system.resolveTargetQuery(std.testing.io, target_query));
@@ -1080,7 +1081,7 @@ const NestedPrint = union(enum) {
     },
 };
 
-pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!void {
+pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w: *Io.Writer) Io.Writer.Error!void {
     try w.writeByte('&');
     try w.writeAll(base);
     if (!offset.isZero(comp)) {
@@ -1089,7 +1090,7 @@ pub fn printPointer(offset: Value, base: []const u8, comp: *const Compilation, w
     }
 }
 
-pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!?NestedPrint {
+pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *Io.Writer) Io.Writer.Error!?NestedPrint {
     if (qt.is(comp, .bool)) {
         try w.writeAll(if (v.isZero(comp)) "false" else "true");
         return null;
@@ -1116,7 +1117,7 @@ pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *std.Io.Writer
     return null;
 }
 
-pub fn printString(bytes: []const u8, qt: QualType, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!void {
+pub fn printString(bytes: []const u8, qt: QualType, comp: *const Compilation, w: *Io.Writer) Io.Writer.Error!void {
     const size: Compilation.CharUnitSize = @enumFromInt(qt.childType(comp).sizeof(comp));
     const without_null = bytes[0 .. bytes.len - @intFromEnum(size)];
     try w.writeByte('"');
diff --git a/lib/compiler/aro/main.zig b/lib/compiler/aro/main.zig
index 66c8add4a3..d1be1dbb21 100644
--- a/lib/compiler/aro/main.zig
+++ b/lib/compiler/aro/main.zig
@@ -59,7 +59,7 @@ pub fn main() u8 {
         } },
     };
 
-    var comp = Compilation.initDefault(gpa, arena, io, &diagnostics, std.fs.cwd()) catch |er| switch (er) {
+    var comp = Compilation.initDefault(gpa, arena, io, &diagnostics, Io.Dir.cwd()) catch |er| switch (er) {
         error.OutOfMemory => {
             std.debug.print("out of memory\n", .{});
             if (fast_exit) process.exit(1);
diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig
index 485e644daa..e48f76a6a6 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
     defer threaded.deinit();
     const io = threaded.io();
 
-    const input_file = fs.cwd().openFile(input, .{}) catch |err| fatal("failed to open {s}: {t}", .{ input, err });
+    const input_file = Io.Dir.cwd().openFile(input, .{}) catch |err| fatal("failed to open {s}: {t}", .{ input, err });
     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) Io.File.default_mode else stat.mode;
 
-    var output_file = try fs.cwd().createFile(output, .{ .mode = mode });
+    var output_file = try Io.Dir.cwd().createFile(io, output, .{ .mode = mode });
     defer output_file.close(io);
 
     var out = output_file.writer(&output_buffer);
diff --git a/lib/compiler/reduce.zig b/lib/compiler/reduce.zig
index bbd3d172b4..d3f33ad81a 100644
--- a/lib/compiler/reduce.zig
+++ b/lib/compiler/reduce.zig
@@ -233,7 +233,7 @@ pub fn main() !void {
                 }
             }
 
-            try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() });
+            try Io.Dir.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() });
             // std.debug.print("trying this code:\n{s}\n", .{rendered.items});
 
             const interestingness = try runCheck(arena, interestingness_argv.items);
@@ -274,7 +274,7 @@ pub fn main() !void {
         fixups.clearRetainingCapacity();
         rendered.clearRetainingCapacity();
         try tree.render(gpa, &rendered.writer, fixups);
-        try std.fs.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() });
+        try Io.Dir.cwd().writeFile(.{ .sub_path = root_source_file_path, .data = rendered.written() });
 
         return std.process.cleanExit();
     }
@@ -398,7 +398,7 @@ fn transformationsToFixups(
 }
 
 fn parse(gpa: Allocator, file_path: []const u8) !Ast {
-    const source_code = std.fs.cwd().readFileAllocOptions(
+    const source_code = Io.Dir.cwd().readFileAllocOptions(
         file_path,
         gpa,
         .limited(std.math.maxInt(u32)),
diff --git a/lib/compiler/resinator/cli.zig b/lib/compiler/resinator/cli.zig
index bb54289e3e..ae4ece2968 100644
--- a/lib/compiler/resinator/cli.zig
+++ b/lib/compiler/resinator/cli.zig
@@ -2003,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", .{});
+    var file = try tmp.dir.createFile(io, "foo", .{});
     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 7dc77e5ee1..3e046a10c1 100644
--- a/lib/compiler/resinator/compile.zig
+++ b/lib/compiler/resinator/compile.zig
@@ -111,7 +111,7 @@ pub fn compile(allocator: Allocator, io: Io, source: []const u8, writer: *std.Io
             try search_dirs.append(allocator, .{ .dir = root_dir, .path = try allocator.dupe(u8, root_dir_path) });
         }
     }
-    // Re-open the passed in cwd since we want to be able to close it (std.fs.cwd() shouldn't be closed)
+    // Re-open the passed in cwd since we want to be able to close it (Io.Dir.cwd() shouldn't be closed)
     const cwd_dir = options.cwd.openDir(".", .{}) catch |err| {
         try options.diagnostics.append(.{
             .err = .failed_to_open_cwd,
@@ -406,7 +406,7 @@ pub const Compiler = struct {
         // `/test.bin` relative to include paths and instead only treats it as
         // an absolute path.
         if (std.fs.path.isAbsolute(path)) {
-            const file = try utils.openFileNotDir(std.fs.cwd(), path, .{});
+            const file = try utils.openFileNotDir(Io.Dir.cwd(), path, .{});
             errdefer file.close(io);
 
             if (self.dependencies) |dependencies| {
diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig
index c726a06cf4..416abc2ab7 100644
--- a/lib/compiler/resinator/main.zig
+++ b/lib/compiler/resinator/main.zig
@@ -67,7 +67,7 @@ pub fn main() !void {
             },
             else => |e| return e,
         };
-        try options.maybeAppendRC(std.fs.cwd());
+        try options.maybeAppendRC(Io.Dir.cwd());
 
         if (!zig_integration) {
             // print any warnings/notes
@@ -141,7 +141,7 @@ pub fn main() !void {
                 if (!zig_integration) std.debug.unlockStderrWriter();
             }
 
-            var comp = aro.Compilation.init(aro_arena, aro_arena, io, &diagnostics, std.fs.cwd());
+            var comp = aro.Compilation.init(aro_arena, aro_arena, io, &diagnostics, Io.Dir.cwd());
             defer comp.deinit();
 
             var argv: std.ArrayList([]const u8) = .empty;
@@ -196,7 +196,7 @@ pub fn main() !void {
                     };
                 },
                 .filename => |input_filename| {
-                    break :full_input std.fs.cwd().readFileAlloc(input_filename, gpa, .unlimited) catch |err| {
+                    break :full_input Io.Dir.cwd().readFileAlloc(input_filename, gpa, .unlimited) catch |err| {
                         try error_handler.emitMessage(gpa, .err, "unable to read input file path '{s}': {s}", .{ input_filename, @errorName(err) });
                         std.process.exit(1);
                     };
@@ -212,7 +212,7 @@ pub fn main() !void {
                 try output_file.writeAll(full_input);
             },
             .filename => |output_filename| {
-                try std.fs.cwd().writeFile(.{ .sub_path = output_filename, .data = full_input });
+                try Io.Dir.cwd().writeFile(.{ .sub_path = output_filename, .data = full_input });
             },
         }
         return;
@@ -277,7 +277,7 @@ pub fn main() !void {
                 const output_buffered_stream = res_stream_writer.interface();
 
                 compile(gpa, io, final_input, output_buffered_stream, .{
-                    .cwd = std.fs.cwd(),
+                    .cwd = Io.Dir.cwd(),
                     .diagnostics = &diagnostics,
                     .source_mappings = &mapping_results.mappings,
                     .dependencies = maybe_dependencies,
@@ -294,7 +294,7 @@ pub fn main() !void {
                     .warn_instead_of_error_on_invalid_code_page = options.warn_instead_of_error_on_invalid_code_page,
                 }) catch |err| switch (err) {
                     error.ParseError, error.CompileError => {
-                        try error_handler.emitDiagnostics(gpa, std.fs.cwd(), final_input, &diagnostics, mapping_results.mappings);
+                        try error_handler.emitDiagnostics(gpa, Io.Dir.cwd(), final_input, &diagnostics, mapping_results.mappings);
                         // Delete the output file on error
                         res_stream.cleanupAfterError(io);
                         std.process.exit(1);
@@ -306,12 +306,12 @@ pub fn main() !void {
 
                 // print any warnings/notes
                 if (!zig_integration) {
-                    diagnostics.renderToStdErr(std.fs.cwd(), final_input, mapping_results.mappings);
+                    diagnostics.renderToStdErr(Io.Dir.cwd(), final_input, mapping_results.mappings);
                 }
 
                 // write the depfile
                 if (options.depfile_path) |depfile_path| {
-                    var depfile = std.fs.cwd().createFile(depfile_path, .{}) catch |err| {
+                    var depfile = Io.Dir.cwd().createFile(io, depfile_path, .{}) catch |err| {
                         try error_handler.emitMessage(gpa, .err, "unable to create depfile '{s}': {s}", .{ depfile_path, @errorName(err) });
                         std.process.exit(1);
                     };
@@ -440,7 +440,7 @@ const IoStream = struct {
                 // Delete the output file on error
                 file.close(io);
                 // Failing to delete is not really a big deal, so swallow any errors
-                std.fs.cwd().deleteFile(self.name) catch {};
+                Io.Dir.cwd().deleteFile(self.name) catch {};
             },
             .stdio, .memory, .closed => return,
         }
@@ -457,8 +457,8 @@ const IoStream = struct {
             switch (source) {
                 .filename => |filename| return .{
                     .file = switch (io) {
-                        .input => try openFileNotDir(std.fs.cwd(), filename, .{}),
-                        .output => try std.fs.cwd().createFile(filename, .{}),
+                        .input => try openFileNotDir(Io.Dir.cwd(), filename, .{}),
+                        .output => try Io.Dir.cwd().createFile(io, filename, .{}),
                     },
                 },
                 .stdio => |file| return .{ .stdio = file },
diff --git a/lib/compiler/std-docs.zig b/lib/compiler/std-docs.zig
index e4efac28cd..87c4da9faa 100644
--- a/lib/compiler/std-docs.zig
+++ b/lib/compiler/std-docs.zig
@@ -40,7 +40,7 @@ pub fn main() !void {
     const zig_exe_path = argv.next().?;
     const global_cache_path = argv.next().?;
 
-    var lib_dir = try std.fs.cwd().openDir(zig_lib_directory, .{});
+    var lib_dir = try Io.Dir.cwd().openDir(zig_lib_directory, .{});
     defer lib_dir.close(io);
 
     var listen_port: u16 = 0;
diff --git a/lib/compiler/translate-c/main.zig b/lib/compiler/translate-c/main.zig
index 830c70e424..d0a873fd78 100644
--- a/lib/compiler/translate-c/main.zig
+++ b/lib/compiler/translate-c/main.zig
@@ -47,7 +47,7 @@ pub fn main() u8 {
     };
     defer diagnostics.deinit();
 
-    var comp = aro.Compilation.initDefault(gpa, arena, io, &diagnostics, std.fs.cwd()) catch |err| switch (err) {
+    var comp = aro.Compilation.initDefault(gpa, arena, io, &diagnostics, Io.Dir.cwd()) catch |err| switch (err) {
         error.OutOfMemory => {
             std.debug.print("ran out of memory initializing C compilation\n", .{});
             if (fast_exit) process.exit(1);
@@ -226,7 +226,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration
         const dep_file_name = try d.getDepFileName(source, out_buf[0..std.fs.max_name_bytes]);
 
         const file = if (dep_file_name) |path|
-            d.comp.cwd.createFile(path, .{}) catch |er|
+            d.comp.cwd.createFile(io, path, .{}) catch |er|
                 return d.fatal("unable to create dependency file '{s}': {s}", .{ path, aro.Driver.errorDescription(er) })
         else
             Io.File.stdout();
@@ -253,10 +253,10 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration
     if (d.output_name) |path| blk: {
         if (std.mem.eql(u8, path, "-")) break :blk;
         if (std.fs.path.dirname(path)) |dirname| {
-            std.fs.cwd().makePath(dirname) catch |err|
+            Io.Dir.cwd().makePath(dirname) catch |err|
                 return d.fatal("failed to create path to '{s}': {s}", .{ path, aro.Driver.errorDescription(err) });
         }
-        out_file = std.fs.cwd().createFile(path, .{}) catch |err| {
+        out_file = Io.Dir.cwd().createFile(io, path, .{}) catch |err| {
             return d.fatal("failed to create output file '{s}': {s}", .{ path, aro.Driver.errorDescription(err) });
         };
         close_out_file = true;