update all occurrences of std.fs.File to std.Io.File

48 files changed, 160 insertions, 138 deletions

diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig
index 9fb8123146..06b27c33bb 100644
--- a/lib/compiler/aro/aro/Compilation.zig
+++ b/lib/compiler/aro/aro/Compilation.zig
@@ -1646,7 +1646,7 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin
     return comp.addSourceFromFile(file, path, kind);
 }
 
-pub fn addSourceFromFile(comp: *Compilation, file: std.fs.File, path: []const u8, kind: Source.Kind) !Source {
+pub fn addSourceFromFile(comp: *Compilation, file: Io.File, path: []const u8, kind: Source.Kind) !Source {
     const contents = try comp.getFileContents(file, .unlimited);
     errdefer comp.gpa.free(contents);
     return comp.addSourceFromOwnedBuffer(path, contents, kind);
@@ -1980,7 +1980,7 @@ fn getPathContents(comp: *Compilation, path: []const u8, limit: Io.Limit) ![]u8
     return comp.getFileContents(file, limit);
 }
 
-fn getFileContents(comp: *Compilation, file: std.fs.File, limit: Io.Limit) ![]u8 {
+fn getFileContents(comp: *Compilation, file: Io.File, limit: Io.Limit) ![]u8 {
     var file_buf: [4096]u8 = undefined;
     var file_reader = file.reader(comp.io, &file_buf);
 
diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig
index 888ade2be4..f933e3ce52 100644
--- a/lib/compiler/aro/aro/Driver.zig
+++ b/lib/compiler/aro/aro/Driver.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const Allocator = mem.Allocator;
 const process = std.process;
@@ -1061,7 +1062,7 @@ pub fn printDiagnosticsStats(d: *Driver) void {
     }
 }
 
-pub fn detectConfig(d: *Driver, file: std.fs.File) std.Io.tty.Config {
+pub fn detectConfig(d: *Driver, file: Io.File) std.Io.tty.Config {
     if (d.diagnostics.color == false) return .no_color;
     const force_color = d.diagnostics.color == true;
 
@@ -1109,7 +1110,7 @@ pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_
         defer macro_buf.deinit(d.comp.gpa);
 
         var stdout_buf: [256]u8 = undefined;
-        var stdout = std.fs.File.stdout().writer(&stdout_buf);
+        var stdout = Io.File.stdout().writer(&stdout_buf);
         if (parseArgs(d, &stdout.interface, &macro_buf, args) catch |er| switch (er) {
             error.WriteFailed => return d.fatal("failed to write to stdout: {s}", .{errorDescription(er)}),
             error.OutOfMemory => return error.OutOfMemory,
@@ -1329,7 +1330,7 @@ fn processSource(
             d.comp.cwd.createFile(path, .{}) catch |er|
                 return d.fatal("unable to create dependency file '{s}': {s}", .{ path, errorDescription(er) })
         else
-            std.fs.File.stdout();
+            Io.File.stdout();
         defer if (dep_file_name != null) file.close(io);
 
         var file_writer = file.writer(&writer_buf);
@@ -1354,7 +1355,7 @@ fn processSource(
             d.comp.cwd.createFile(some, .{}) catch |er|
                 return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
         else
-            std.fs.File.stdout();
+            Io.File.stdout();
         defer if (d.output_name != null) file.close(io);
 
         var file_writer = file.writer(&writer_buf);
@@ -1369,7 +1370,7 @@ fn processSource(
     defer tree.deinit();
 
     if (d.verbose_ast) {
-        var stdout = std.fs.File.stdout().writer(&writer_buf);
+        var stdout = Io.File.stdout().writer(&writer_buf);
         tree.dump(d.detectConfig(stdout.file), &stdout.interface) catch {};
     }
 
@@ -1433,7 +1434,7 @@ fn processSource(
         defer ir.deinit(gpa);
 
         if (d.verbose_ir) {
-            var stdout = std.fs.File.stdout().writer(&writer_buf);
+            var stdout = Io.File.stdout().writer(&writer_buf);
             ir.dump(gpa, d.detectConfig(stdout.file), &stdout.interface) catch {};
         }
 
@@ -1499,7 +1500,7 @@ pub fn invokeLinker(d: *Driver, tc: *Toolchain, comptime fast_exit: bool) Compil
 
     if (d.verbose_linker_args) {
         var stdout_buf: [4096]u8 = undefined;
-        var stdout = std.fs.File.stdout().writer(&stdout_buf);
+        var stdout = Io.File.stdout().writer(&stdout_buf);
         dumpLinkerArgs(&stdout.interface, argv.items) catch {
             return d.fatal("unable to dump linker args: {s}", .{errorDescription(stdout.err.?)});
         };
diff --git a/lib/compiler/aro/aro/Preprocessor.zig b/lib/compiler/aro/aro/Preprocessor.zig
index 6bd1206aff..d47727cbf0 100644
--- a/lib/compiler/aro/aro/Preprocessor.zig
+++ b/lib/compiler/aro/aro/Preprocessor.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;
@@ -1068,7 +1069,7 @@ fn verboseLog(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args:
     const line_col = source.lineCol(.{ .id = raw.source, .line = raw.line, .byte_offset = raw.start });
 
     var stderr_buf: [4096]u8 = undefined;
-    var stderr = std.fs.File.stderr().writer(&stderr_buf);
+    var stderr = Io.File.stderr().writer(&stderr_buf);
     const w = &stderr.interface;
 
     w.print("{s}:{d}:{d}: ", .{ source.path, line_col.line_no, line_col.col }) catch return;
diff --git a/lib/compiler/aro/backend/Assembly.zig b/lib/compiler/aro/backend/Assembly.zig
index d0d14bdd77..80143bf97f 100644
--- a/lib/compiler/aro/backend/Assembly.zig
+++ b/lib/compiler/aro/backend/Assembly.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 
 data: []const u8,
@@ -11,7 +12,7 @@ pub fn deinit(self: *const Assembly, gpa: Allocator) void {
     gpa.free(self.text);
 }
 
-pub fn writeToFile(self: Assembly, file: std.fs.File) !void {
+pub fn writeToFile(self: Assembly, file: Io.File) !void {
     var file_writer = file.writer(&.{});
 
     var buffers = [_][]const u8{ self.data, self.text };
diff --git a/lib/compiler/aro/main.zig b/lib/compiler/aro/main.zig
index d3655e43da..66c8add4a3 100644
--- a/lib/compiler/aro/main.zig
+++ b/lib/compiler/aro/main.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const Allocator = mem.Allocator;
 const mem = std.mem;
 const process = std.process;
@@ -50,7 +51,7 @@ pub fn main() u8 {
     defer gpa.free(aro_name);
 
     var stderr_buf: [1024]u8 = undefined;
-    var stderr = std.fs.File.stderr().writer(&stderr_buf);
+    var stderr = Io.File.stderr().writer(&stderr_buf);
     var diagnostics: Diagnostics = .{
         .output = .{ .to_writer = .{
             .color = .detect(stderr.file),
diff --git a/lib/compiler/build_runner.zig b/lib/compiler/build_runner.zig
index 2c8d71e3e2..6e0e2d8eca 100644
--- a/lib/compiler/build_runner.zig
+++ b/lib/compiler/build_runner.zig
@@ -7,7 +7,7 @@ const assert = std.debug.assert;
 const fmt = std.fmt;
 const mem = std.mem;
 const process = std.process;
-const File = std.fs.File;
+const File = std.Io.File;
 const Step = std.Build.Step;
 const Watch = std.Build.Watch;
 const WebServer = std.Build.WebServer;
@@ -1845,9 +1845,9 @@ fn createModuleDependenciesForStep(step: *Step) Allocator.Error!void {
 }
 
 var stdio_buffer_allocation: [256]u8 = undefined;
-var stdout_writer_allocation: std.fs.File.Writer = undefined;
+var stdout_writer_allocation: Io.File.Writer = undefined;
 
 fn initStdoutWriter() *Writer {
-    stdout_writer_allocation = std.fs.File.stdout().writerStreaming(&stdio_buffer_allocation);
+    stdout_writer_allocation = Io.File.stdout().writerStreaming(&stdio_buffer_allocation);
     return &stdout_writer_allocation.interface;
 }
diff --git a/lib/compiler/libc.zig b/lib/compiler/libc.zig
index a18a7a0e06..142b87062e 100644
--- a/lib/compiler/libc.zig
+++ b/lib/compiler/libc.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const LibCInstallation = std.zig.LibCInstallation;
 
@@ -39,7 +40,7 @@ pub fn main() !void {
     var input_file: ?[]const u8 = null;
     var target_arch_os_abi: []const u8 = "native";
     var print_includes: bool = false;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
     {
         var i: usize = 2;
diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig
index 1608c121b1..c360ea8df0 100644
--- a/lib/compiler/objcopy.zig
+++ b/lib/compiler/objcopy.zig
@@ -1,12 +1,13 @@
 const builtin = @import("builtin");
+
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const fs = std.fs;
 const elf = std.elf;
 const Allocator = std.mem.Allocator;
-const File = std.fs.File;
+const File = std.Io.File;
 const assert = std.debug.assert;
-
 const fatal = std.process.fatal;
 const Server = std.zig.Server;
 
@@ -56,7 +57,7 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
                 fatal("unexpected positional argument: '{s}'", .{arg});
             }
         } else if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-            return std.fs.File.stdout().writeAll(usage);
+            return Io.File.stdout().writeAll(usage);
         } else if (mem.eql(u8, arg, "-O") or mem.eql(u8, arg, "--output-target")) {
             i += 1;
             if (i >= args.len) fatal("expected another argument after '{s}'", .{arg});
@@ -177,7 +178,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;
+    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 });
     defer output_file.close(io);
@@ -221,8 +222,8 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
     try out.end();
 
     if (listen) {
-        var stdin_reader = fs.File.stdin().reader(io, &stdin_buffer);
-        var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
+        var stdin_reader = Io.File.stdin().reader(io, &stdin_buffer);
+        var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
         var server = try Server.init(.{
             .in = &stdin_reader.interface,
             .out = &stdout_writer.interface,
diff --git a/lib/compiler/reduce.zig b/lib/compiler/reduce.zig
index 28305e801b..bbd3d172b4 100644
--- a/lib/compiler/reduce.zig
+++ b/lib/compiler/reduce.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
@@ -68,7 +69,7 @@ pub fn main() !void {
             const arg = args[i];
             if (mem.startsWith(u8, arg, "-")) {
                 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
-                    const stdout = std.fs.File.stdout();
+                    const stdout = Io.File.stdout();
                     try stdout.writeAll(usage);
                     return std.process.cleanExit();
                 } else if (mem.eql(u8, arg, "--")) {
diff --git a/lib/compiler/resinator/cli.zig b/lib/compiler/resinator/cli.zig
index ffaa62e7ca..17da5c7b75 100644
--- a/lib/compiler/resinator/cli.zig
+++ b/lib/compiler/resinator/cli.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const code_pages = @import("code_pages.zig");
 const SupportedCodePage = code_pages.SupportedCodePage;
 const lang = @import("lang.zig");
@@ -169,7 +170,7 @@ pub const Options = struct {
     coff_options: cvtres.CoffOptions = .{},
 
     pub const IoSource = union(enum) {
-        stdio: std.fs.File,
+        stdio: Io.File,
         filename: []const u8,
     };
     pub const AutoIncludes = enum { any, msvc, gnu, none };
diff --git a/lib/compiler/resinator/errors.zig b/lib/compiler/resinator/errors.zig
index 8509aa610f..61fd00e683 100644
--- a/lib/compiler/resinator/errors.zig
+++ b/lib/compiler/resinator/errors.zig
@@ -169,9 +169,9 @@ pub const ErrorDetails = struct {
         filename_string_index: FilenameStringIndex,
 
         pub const FilenameStringIndex = std.meta.Int(.unsigned, 32 - @bitSizeOf(FileOpenErrorEnum));
-        pub const FileOpenErrorEnum = std.meta.FieldEnum(std.fs.File.OpenError || std.fs.File.StatError);
+        pub const FileOpenErrorEnum = std.meta.FieldEnum(Io.File.OpenError || Io.File.StatError);
 
-        pub fn enumFromError(err: (std.fs.File.OpenError || std.fs.File.StatError)) FileOpenErrorEnum {
+        pub fn enumFromError(err: (Io.File.OpenError || Io.File.StatError)) FileOpenErrorEnum {
             return switch (err) {
                 inline else => |e| @field(ErrorDetails.FileOpenError.FileOpenErrorEnum, @errorName(e)),
             };
@@ -1094,8 +1094,8 @@ const CorrespondingLines = struct {
     last_byte: u8 = 0,
     at_eof: bool = false,
     span: SourceMappings.CorrespondingSpan,
-    file: std.fs.File,
-    file_reader: std.fs.File.Reader,
+    file: Io.File,
+    file_reader: Io.File.Reader,
     code_page: SupportedCodePage,
 
     pub fn init(
diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig
index 42308a8987..e171d8199c 100644
--- a/lib/compiler/resinator/main.zig
+++ b/lib/compiler/resinator/main.zig
@@ -45,7 +45,7 @@ pub fn main() !void {
     }
 
     var stdout_buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
     var error_handler: ErrorHandler = switch (zig_integration) {
         true => .{
@@ -447,8 +447,8 @@ const IoStream = struct {
     }
 
     pub const Source = union(enum) {
-        file: std.fs.File,
-        stdio: std.fs.File,
+        file: Io.File,
+        stdio: Io.File,
         memory: std.ArrayList(u8),
         /// The source has been closed and any usage of the Source in this state is illegal (except deinit).
         closed: void,
@@ -500,10 +500,10 @@ const IoStream = struct {
         }
 
         pub const Writer = union(enum) {
-            file: std.fs.File.Writer,
+            file: Io.File.Writer,
             allocating: std.Io.Writer.Allocating,
 
-            pub const Error = Allocator.Error || std.fs.File.WriteError;
+            pub const Error = Allocator.Error || Io.File.WriteError;
 
             pub fn interface(this: *@This()) *std.Io.Writer {
                 return switch (this.*) {
diff --git a/lib/compiler/resinator/utils.zig b/lib/compiler/resinator/utils.zig
index f8080539cb..e8565f3af9 100644
--- a/lib/compiler/resinator/utils.zig
+++ b/lib/compiler/resinator/utils.zig
@@ -32,8 +32,8 @@ 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 {
+    flags: Io.File.OpenFlags,
+) (Io.File.OpenError || Io.File.StatError)!Io.File {
     const file = try cwd.openFile(io, path, flags);
     errdefer file.close(io);
     // https://github.com/ziglang/zig/issues/5732
diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig
index 72ed3e7677..07a6724ec0 100644
--- a/lib/compiler/test_runner.zig
+++ b/lib/compiler/test_runner.zig
@@ -74,8 +74,8 @@ pub fn main() void {
 
 fn mainServer() !void {
     @disableInstrumentation();
-    var stdin_reader = std.fs.File.stdin().readerStreaming(runner_threaded_io.io(), &stdin_buffer);
-    var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
+    var stdin_reader = Io.File.stdin().readerStreaming(runner_threaded_io.io(), &stdin_buffer);
+    var stdout_writer = Io.File.stdout().writerStreaming(&stdout_buffer);
     var server = try std.zig.Server.init(.{
         .in = &stdin_reader.interface,
         .out = &stdout_writer.interface,
@@ -228,7 +228,7 @@ fn mainTerminal() void {
         .root_name = "Test",
         .estimated_total_items = test_fn_list.len,
     });
-    const have_tty = std.fs.File.stderr().isTty();
+    const have_tty = Io.File.stderr().isTty();
 
     var leaks: usize = 0;
     for (test_fn_list, 0..) |test_fn, i| {
@@ -318,7 +318,7 @@ pub fn log(
 /// work-in-progress backends can handle it.
 pub fn mainSimple() anyerror!void {
     @disableInstrumentation();
-    // is the backend capable of calling `std.fs.File.writeAll`?
+    // is the backend capable of calling `Io.File.writeAll`?
     const enable_write = switch (builtin.zig_backend) {
         .stage2_aarch64, .stage2_riscv64 => true,
         else => false,
@@ -334,7 +334,7 @@ pub fn mainSimple() anyerror!void {
     var failed: u64 = 0;
 
     // we don't want to bring in File and Writer if the backend doesn't support it
-    const stdout = if (enable_write) std.fs.File.stdout() else {};
+    const stdout = if (enable_write) Io.File.stdout() else {};
 
     for (builtin.test_functions) |test_fn| {
         if (enable_write) {
diff --git a/lib/compiler/translate-c/main.zig b/lib/compiler/translate-c/main.zig
index 0c72298b30..830c70e424 100644
--- a/lib/compiler/translate-c/main.zig
+++ b/lib/compiler/translate-c/main.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const assert = std.debug.assert;
 const mem = std.mem;
 const process = std.process;
@@ -34,7 +35,7 @@ pub fn main() u8 {
     }
 
     var stderr_buf: [1024]u8 = undefined;
-    var stderr = std.fs.File.stderr().writer(&stderr_buf);
+    var stderr = Io.File.stderr().writer(&stderr_buf);
     var diagnostics: aro.Diagnostics = switch (zig_integration) {
         false => .{ .output = .{ .to_writer = .{
             .color = .detect(stderr.file),
@@ -99,7 +100,7 @@ fn serveErrorBundle(arena: std.mem.Allocator, diagnostics: *const aro.Diagnostic
         "translation failure",
     );
     var stdout_buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     var server: std.zig.Server = .{
         .out = &stdout_writer.interface,
         .in = undefined,
@@ -129,13 +130,13 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration
             args[i] = arg;
             if (mem.eql(u8, arg, "--help")) {
                 var stdout_buf: [512]u8 = undefined;
-                var stdout = std.fs.File.stdout().writer(&stdout_buf);
+                var stdout = Io.File.stdout().writer(&stdout_buf);
                 try stdout.interface.print(usage, .{args[0]});
                 try stdout.interface.flush();
                 return;
             } else if (mem.eql(u8, arg, "--version")) {
                 var stdout_buf: [512]u8 = undefined;
-                var stdout = std.fs.File.stdout().writer(&stdout_buf);
+                var stdout = Io.File.stdout().writer(&stdout_buf);
                 // TODO add version
                 try stdout.interface.writeAll("0.0.0-dev\n");
                 try stdout.interface.flush();
@@ -228,7 +229,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8, zig_integration
             d.comp.cwd.createFile(path, .{}) catch |er|
                 return d.fatal("unable to create dependency file '{s}': {s}", .{ path, aro.Driver.errorDescription(er) })
         else
-            std.fs.File.stdout();
+            Io.File.stdout();
         defer if (dep_file_name != null) file.close(io);
 
         var file_writer = file.writer(&out_buf);
@@ -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();
+    var out_file: Io.File = .stdout();
     defer if (close_out_file) out_file.close(io);
 
     if (d.output_name) |path| blk: {
diff --git a/lib/std/Build.zig b/lib/std/Build.zig
index fcd94ce134..2755b895c2 100644
--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -1,3 +1,4 @@
+const Build = @This();
 const builtin = @import("builtin");
 
 const std = @import("std.zig");
@@ -9,13 +10,12 @@ const panic = std.debug.panic;
 const assert = debug.assert;
 const log = std.log;
 const StringHashMap = std.StringHashMap;
-const Allocator = mem.Allocator;
+const Allocator = std.mem.Allocator;
 const Target = std.Target;
 const process = std.process;
 const EnvMap = std.process.EnvMap;
-const File = fs.File;
+const File = std.Io.File;
 const Sha256 = std.crypto.hash.sha2.Sha256;
-const Build = @This();
 const ArrayList = std.ArrayList;
 
 pub const Cache = @import("Build/Cache.zig");
diff --git a/lib/std/Build/Step.zig b/lib/std/Build/Step.zig
index acde47071d..2b1e6d8ace 100644
--- a/lib/std/Build/Step.zig
+++ b/lib/std/Build/Step.zig
@@ -667,7 +667,7 @@ fn clearZigProcess(s: *Step, gpa: Allocator) void {
     }
 }
 
-fn sendMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag) !void {
+fn sendMessage(file: 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/std/Build/Step/ObjCopy.zig b/lib/std/Build/Step/ObjCopy.zig
index b5f058ddfc..4aa1c0a9dc 100644
--- a/lib/std/Build/Step/ObjCopy.zig
+++ b/lib/std/Build/Step/ObjCopy.zig
@@ -3,7 +3,7 @@ const ObjCopy = @This();
 
 const Allocator = std.mem.Allocator;
 const ArenaAllocator = std.heap.ArenaAllocator;
-const File = std.fs.File;
+const File = std.Io.File;
 const InstallDir = std.Build.InstallDir;
 const Step = std.Build.Step;
 const elf = std.elf;
diff --git a/lib/std/Build/Step/Run.zig b/lib/std/Build/Step/Run.zig
index e66e30cc79..1df6f42a35 100644
--- a/lib/std/Build/Step/Run.zig
+++ b/lib/std/Build/Step/Run.zig
@@ -1,15 +1,16 @@
-const std = @import("std");
+const Run = @This();
 const builtin = @import("builtin");
+
+const std = @import("std");
+const Io = std.Io;
 const Build = std.Build;
-const Step = Build.Step;
+const Step = std.Build.Step;
 const fs = std.fs;
 const mem = std.mem;
 const process = std.process;
-const EnvMap = process.EnvMap;
+const EnvMap = std.process.EnvMap;
 const assert = std.debug.assert;
-const Path = Build.Cache.Path;
-
-const Run = @This();
+const Path = std.Build.Cache.Path;
 
 pub const base_id: Step.Id = .run;
 
@@ -2095,7 +2096,7 @@ pub const CachedTestMetadata = struct {
     }
 };
 
-fn requestNextTest(in: fs.File, metadata: *TestMetadata, sub_prog_node: *?std.Progress.Node) !void {
+fn requestNextTest(in: Io.File, metadata: *TestMetadata, sub_prog_node: *?std.Progress.Node) !void {
     while (metadata.next_index < metadata.names.len) {
         const i = metadata.next_index;
         metadata.next_index += 1;
@@ -2114,7 +2115,7 @@ fn requestNextTest(in: fs.File, metadata: *TestMetadata, sub_prog_node: *?std.Pr
     }
 }
 
-fn sendMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag) !void {
+fn sendMessage(file: Io.File, tag: std.zig.Client.Message.Tag) !void {
     const header: std.zig.Client.Message.Header = .{
         .tag = tag,
         .bytes_len = 0,
@@ -2125,7 +2126,7 @@ fn sendMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag) !void {
     };
 }
 
-fn sendRunTestMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag, index: u32) !void {
+fn sendRunTestMessage(file: Io.File, tag: std.zig.Client.Message.Tag, index: u32) !void {
     const header: std.zig.Client.Message.Header = .{
         .tag = tag,
         .bytes_len = 4,
@@ -2140,7 +2141,7 @@ fn sendRunTestMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag, index:
 }
 
 fn sendRunFuzzTestMessage(
-    file: std.fs.File,
+    file: Io.File,
     index: u32,
     kind: std.Build.abi.fuzz.LimitKind,
     amount_or_instance: u64,
diff --git a/lib/std/Io.zig b/lib/std/Io.zig
index 0727e3efd3..f783718cef 100644
--- a/lib/std/Io.zig
+++ b/lib/std/Io.zig
@@ -528,7 +528,7 @@ pub fn Poller(comptime StreamEnum: type) type {
 /// Given an enum, returns a struct with fields of that enum, each field
 /// representing an I/O stream for polling.
 pub fn PollFiles(comptime StreamEnum: type) type {
-    return @Struct(.auto, null, std.meta.fieldNames(StreamEnum), &@splat(std.fs.File), &@splat(.{}));
+    return @Struct(.auto, null, std.meta.fieldNames(StreamEnum), &@splat(Io.File), &@splat(.{}));
 }
 
 test {
diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig
index 5601293cfb..3f25bc6a26 100644
--- a/lib/std/Io/Writer.zig
+++ b/lib/std/Io/Writer.zig
@@ -1,7 +1,8 @@
+const Writer = @This();
+
 const builtin = @import("builtin");
 const native_endian = builtin.target.cpu.arch.endian();
 
-const Writer = @This();
 const std = @import("../std.zig");
 const assert = std.debug.assert;
 const Limit = std.Io.Limit;
@@ -2837,7 +2838,7 @@ test "discarding sendFile" {
     const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
     defer file.close(io);
     var r_buffer: [256]u8 = undefined;
-    var file_writer: std.fs.File.Writer = .init(file, &r_buffer);
+    var file_writer: File.Writer = .init(file, &r_buffer);
     try file_writer.interface.writeByte('h');
     try file_writer.interface.flush();
 
@@ -2859,7 +2860,7 @@ test "allocating sendFile" {
     const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
     defer file.close(io);
     var r_buffer: [2]u8 = undefined;
-    var file_writer: std.fs.File.Writer = .init(file, &r_buffer);
+    var file_writer: File.Writer = .init(file, &r_buffer);
     try file_writer.interface.writeAll("abcd");
     try file_writer.interface.flush();
 
@@ -2883,7 +2884,7 @@ test sendFileReading {
     const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
     defer file.close(io);
     var r_buffer: [2]u8 = undefined;
-    var file_writer: std.fs.File.Writer = .init(file, &r_buffer);
+    var file_writer: File.Writer = .init(file, &r_buffer);
     try file_writer.interface.writeAll("abcd");
     try file_writer.interface.flush();
 
diff --git a/lib/std/Io/test.zig b/lib/std/Io/test.zig
index 9ea2d48ee5..b922acc333 100644
--- a/lib/std/Io/test.zig
+++ b/lib/std/Io/test.zig
@@ -10,7 +10,7 @@ const expectError = std.testing.expectError;
 const DefaultPrng = std.Random.DefaultPrng;
 const mem = std.mem;
 const fs = std.fs;
-const File = std.fs.File;
+const File = std.Io.File;
 const assert = std.debug.assert;
 
 const tmpDir = std.testing.tmpDir;
diff --git a/lib/std/Io/tty.zig b/lib/std/Io/tty.zig
index 08e0bd71f0..d1f8b576c2 100644
--- a/lib/std/Io/tty.zig
+++ b/lib/std/Io/tty.zig
@@ -1,9 +1,10 @@
-const std = @import("std");
 const builtin = @import("builtin");
-const File = std.fs.File;
+const native_os = builtin.os.tag;
+
+const std = @import("std");
+const File = std.Io.File;
 const process = std.process;
 const windows = std.os.windows;
-const native_os = builtin.os.tag;
 
 pub const Color = enum {
     black,
diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig
index 467d4754ff..d8b22c2db0 100644
--- a/lib/std/Progress.zig
+++ b/lib/std/Progress.zig
@@ -1,19 +1,21 @@
 //! This API is non-allocating, non-fallible, thread-safe, and lock-free.
+const Progress = @This();
 
-const std = @import("std");
 const builtin = @import("builtin");
+const is_big_endian = builtin.cpu.arch.endian() == .big;
+const is_windows = builtin.os.tag == .windows;
+
+const std = @import("std");
+const Io = std.Io;
 const windows = std.os.windows;
 const testing = std.testing;
 const assert = std.debug.assert;
-const Progress = @This();
 const posix = std.posix;
-const is_big_endian = builtin.cpu.arch.endian() == .big;
-const is_windows = builtin.os.tag == .windows;
 const Writer = std.Io.Writer;
 
 /// `null` if the current node (and its children) should
 /// not print on update()
-terminal: std.fs.File,
+terminal: Io.File,
 
 terminal_mode: TerminalMode,
 
@@ -472,7 +474,7 @@ pub fn start(options: Options) Node {
             if (options.disable_printing) {
                 return Node.none;
             }
-            const stderr: std.fs.File = .stderr();
+            const stderr: Io.File = .stderr();
             global_progress.terminal = stderr;
             if (stderr.enableAnsiEscapeCodes()) |_| {
                 global_progress.terminal_mode = .ansi_escape_codes;
@@ -633,8 +635,8 @@ pub fn unlockStdErr() void {
 /// Protected by `stderr_mutex`.
 const stderr_writer: *Writer = &stderr_file_writer.interface;
 /// Protected by `stderr_mutex`.
-var stderr_file_writer: std.fs.File.Writer = .{
-    .interface = std.fs.File.Writer.initInterface(&.{}),
+var stderr_file_writer: Io.File.Writer = .{
+    .interface = Io.File.Writer.initInterface(&.{}),
     .file = if (is_windows) undefined else .stderr(),
     .mode = .streaming,
 };
diff --git a/lib/std/Random/benchmark.zig b/lib/std/Random/benchmark.zig
index 57dc69051e..97afe23b95 100644
--- a/lib/std/Random/benchmark.zig
+++ b/lib/std/Random/benchmark.zig
@@ -1,7 +1,9 @@
 // zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig
 
-const std = @import("std");
 const builtin = @import("builtin");
+
+const std = @import("std");
+const Io = std.Io;
 const time = std.time;
 const Timer = time.Timer;
 const Random = std.Random;
@@ -123,7 +125,7 @@ fn mode(comptime x: comptime_int) comptime_int {
 
 pub fn main() !void {
     var stdout_buffer: [0x100]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
 
     var buffer: [1024]u8 = undefined;
diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig
index 9f532c3bec..8d8e5979df 100644
--- a/lib/std/Thread.zig
+++ b/lib/std/Thread.zig
@@ -175,7 +175,7 @@ pub const SetNameError = error{
     Unsupported,
     Unexpected,
     InvalidWtf8,
-} || posix.PrctlError || posix.WriteError || std.fs.File.OpenError || std.fmt.BufPrintError;
+} || posix.PrctlError || posix.WriteError || Io.File.OpenError || std.fmt.BufPrintError;
 
 pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void {
     if (name.len > max_name_len) return error.NameTooLong;
@@ -293,7 +293,7 @@ pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void {
 pub const GetNameError = error{
     Unsupported,
     Unexpected,
-} || posix.PrctlError || posix.ReadError || std.fs.File.OpenError || std.fmt.BufPrintError;
+} || posix.PrctlError || posix.ReadError || Io.File.OpenError || std.fmt.BufPrintError;
 
 /// On Windows, the result is encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// On other platforms, the result is an opaque sequence of bytes with no particular encoding.
diff --git a/lib/std/crypto/Certificate/Bundle.zig b/lib/std/crypto/Certificate/Bundle.zig
index 9541e01db5..1d21918b5c 100644
--- a/lib/std/crypto/Certificate/Bundle.zig
+++ b/lib/std/crypto/Certificate/Bundle.zig
@@ -171,7 +171,7 @@ fn rescanWindows(cb: *Bundle, gpa: Allocator, io: Io, now: Io.Timestamp) RescanW
     cb.bytes.shrinkAndFree(gpa, cb.bytes.items.len);
 }
 
-pub const AddCertsFromDirPathError = fs.File.OpenError || AddCertsFromDirError;
+pub const AddCertsFromDirPathError = Io.File.OpenError || AddCertsFromDirError;
 
 pub fn addCertsFromDirPath(
     cb: *Bundle,
@@ -212,7 +212,7 @@ pub fn addCertsFromDir(cb: *Bundle, gpa: Allocator, io: Io, now: Io.Timestamp, i
     }
 }
 
-pub const AddCertsFromFilePathError = fs.File.OpenError || AddCertsFromFileError || Io.Clock.Error;
+pub const AddCertsFromFilePathError = Io.File.OpenError || AddCertsFromFileError || Io.Clock.Error;
 
 pub fn addCertsFromFilePathAbsolute(
     cb: *Bundle,
@@ -242,8 +242,8 @@ pub fn addCertsFromFilePath(
 }
 
 pub const AddCertsFromFileError = Allocator.Error ||
-    fs.File.GetSeekPosError ||
-    fs.File.ReadError ||
+    Io.File.GetSeekPosError ||
+    Io.File.ReadError ||
     ParseCertError ||
     std.base64.Error ||
     error{ CertificateAuthorityBundleTooBig, MissingEndCertificateMarker, Streaming };
diff --git a/lib/std/crypto/Certificate/Bundle/macos.zig b/lib/std/crypto/Certificate/Bundle/macos.zig
index d32f1be8e0..473505ac51 100644
--- a/lib/std/crypto/Certificate/Bundle/macos.zig
+++ b/lib/std/crypto/Certificate/Bundle/macos.zig
@@ -6,7 +6,7 @@ const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const Bundle = @import("../Bundle.zig");
 
-pub const RescanMacError = Allocator.Error || fs.File.OpenError || fs.File.ReadError || fs.File.SeekError || Bundle.ParseCertError || error{EndOfStream};
+pub const RescanMacError = Allocator.Error || Io.File.OpenError || Io.File.ReadError || Io.File.SeekError || Bundle.ParseCertError || error{EndOfStream};
 
 pub fn rescanMac(cb: *Bundle, gpa: Allocator, io: Io, now: Io.Timestamp) RescanMacError!void {
     cb.bytes.clearRetainingCapacity();
diff --git a/lib/std/crypto/benchmark.zig b/lib/std/crypto/benchmark.zig
index 54024f070e..1b71110be5 100644
--- a/lib/std/crypto/benchmark.zig
+++ b/lib/std/crypto/benchmark.zig
@@ -1,10 +1,12 @@
 // zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig
 
-const std = @import("std");
 const builtin = @import("builtin");
+
+const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const time = std.time;
-const Timer = time.Timer;
+const Timer = std.time.Timer;
 const crypto = std.crypto;
 
 const KiB = 1024;
@@ -504,7 +506,7 @@ fn mode(comptime x: comptime_int) comptime_int {
 pub fn main() !void {
     // Size of buffer is about size of printed message.
     var stdout_buffer: [0x100]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
 
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 0cb96ed593..97741ecb40 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -8,7 +8,7 @@ const posix = std.posix;
 const fs = std.fs;
 const testing = std.testing;
 const Allocator = mem.Allocator;
-const File = std.fs.File;
+const File = std.Io.File;
 const windows = std.os.windows;
 
 const builtin = @import("builtin");
@@ -575,7 +575,7 @@ pub fn defaultPanic(
             // A panic happened while trying to print a previous panic message.
             // We're still holding the mutex but that's fine as we're going to
             // call abort().
-            fs.File.stderr().writeAll("aborting due to recursive panic\n") catch {};
+            File.stderr().writeAll("aborting due to recursive panic\n") catch {};
         },
         else => {}, // Panicked while printing the recursive panic message.
     }
@@ -1596,7 +1596,7 @@ pub fn defaultHandleSegfault(addr: ?usize, name: []const u8, opt_ctx: ?CpuContex
             // A segfault happened while trying to print a previous panic message.
             // We're still holding the mutex but that's fine as we're going to
             // call abort().
-            fs.File.stderr().writeAll("aborting due to recursive panic\n") catch {};
+            File.stderr().writeAll("aborting due to recursive panic\n") catch {};
         },
         else => {}, // Panicked while printing the recursive panic message.
     }
diff --git a/lib/std/debug/ElfFile.zig b/lib/std/debug/ElfFile.zig
index 92bcca1bcf..5dbae18130 100644
--- a/lib/std/debug/ElfFile.zig
+++ b/lib/std/debug/ElfFile.zig
@@ -123,7 +123,7 @@ pub const LoadError = error{
 
 pub fn load(
     gpa: Allocator,
-    elf_file: std.fs.File,
+    elf_file: Io.File,
     opt_build_id: ?[]const u8,
     di_search_paths: *const DebugInfoSearchPaths,
 ) LoadError!ElfFile {
@@ -423,7 +423,7 @@ const LoadInnerResult = struct {
 };
 fn loadInner(
     arena: Allocator,
-    elf_file: std.fs.File,
+    elf_file: Io.File,
     opt_crc: ?u32,
 ) (LoadError || error{ CrcMismatch, Streaming, Canceled })!LoadInnerResult {
     const mapped_mem: []align(std.heap.page_size_min) const u8 = mapped: {
diff --git a/lib/std/debug/Info.zig b/lib/std/debug/Info.zig
index 9268ca0247..da7656e626 100644
--- a/lib/std/debug/Info.zig
+++ b/lib/std/debug/Info.zig
@@ -27,7 +27,7 @@ coverage: *Coverage,
 pub const LoadError = error{
     MissingDebugInfo,
     UnsupportedDebugInfo,
-} || std.fs.File.OpenError || ElfFile.LoadError || MachOFile.Error || std.debug.Dwarf.ScanError;
+} || Io.File.OpenError || ElfFile.LoadError || MachOFile.Error || std.debug.Dwarf.ScanError;
 
 pub fn load(
     gpa: Allocator,
diff --git a/lib/std/debug/Pdb.zig b/lib/std/debug/Pdb.zig
index c10b361f72..3ecfd1b363 100644
--- a/lib/std/debug/Pdb.zig
+++ b/lib/std/debug/Pdb.zig
@@ -1,5 +1,5 @@
 const std = @import("../std.zig");
-const File = std.fs.File;
+const File = std.Io.File;
 const Allocator = std.mem.Allocator;
 const pdb = std.pdb;
 const assert = std.debug.assert;
diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig
index 557f3901eb..3af7223293 100644
--- a/lib/std/debug/SelfInfo/Windows.zig
+++ b/lib/std/debug/SelfInfo/Windows.zig
@@ -204,7 +204,7 @@ const Module = struct {
         coff_section_headers: []coff.SectionHeader,
 
         const MappedFile = struct {
-            file: fs.File,
+            file: Io.File,
             section_handle: windows.HANDLE,
             section_view: []const u8,
             fn deinit(mf: *const MappedFile, io: Io) void {
diff --git a/lib/std/debug/simple_panic.zig b/lib/std/debug/simple_panic.zig
index 45e97777c4..f6ff77e04f 100644
--- a/lib/std/debug/simple_panic.zig
+++ b/lib/std/debug/simple_panic.zig
@@ -15,7 +15,7 @@ pub fn call(msg: []const u8, ra: ?usize) noreturn {
     @branchHint(.cold);
     _ = ra;
     std.debug.lockStdErr();
-    const stderr: std.fs.File = .stderr();
+    const stderr: std.Io.File = .stderr();
     stderr.writeAll(msg) catch {};
     @trap();
 }
diff --git a/lib/std/dynamic_library.zig b/lib/std/dynamic_library.zig
index c91056b0ab..ca36d5cbb9 100644
--- a/lib/std/dynamic_library.zig
+++ b/lib/std/dynamic_library.zig
@@ -225,7 +225,7 @@ pub const ElfDynLib = struct {
         const fd = try resolveFromName(io, path);
         defer posix.close(fd);
 
-        const file: std.fs.File = .{ .handle = fd };
+        const file: Io.File = .{ .handle = fd };
         const stat = try file.stat();
         const size = std.math.cast(usize, stat.size) orelse return error.FileTooBig;
 
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index 15b8e9b558..f770ddd30e 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -12,7 +12,7 @@ const posix = std.posix;
 
 const ArenaAllocator = std.heap.ArenaAllocator;
 const Dir = std.fs.Dir;
-const File = std.fs.File;
+const File = std.Io.File;
 const tmpDir = testing.tmpDir;
 const SymLinkFlags = std.fs.Dir.SymLinkFlags;
 
@@ -2231,7 +2231,7 @@ test "read file non vectored" {
     const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
     defer file.close(io);
     {
-        var file_writer: std.fs.File.Writer = .init(file, &.{});
+        var file_writer: File.Writer = .init(file, &.{});
         try file_writer.interface.writeAll(contents);
         try file_writer.interface.flush();
     }
@@ -2263,7 +2263,7 @@ test "seek keeping partial buffer" {
     const file = try tmp_dir.dir.createFile("input.txt", .{ .read = true });
     defer file.close(io);
     {
-        var file_writer: std.fs.File.Writer = .init(file, &.{});
+        var file_writer: File.Writer = .init(file, &.{});
         try file_writer.interface.writeAll(contents);
         try file_writer.interface.flush();
     }
@@ -2325,7 +2325,7 @@ test "seekTo flushes buffered data" {
     defer file.close(io);
     {
         var buf: [16]u8 = undefined;
-        var file_writer = std.fs.File.writer(file, &buf);
+        var file_writer = File.writer(file, &buf);
 
         try file_writer.interface.writeAll(contents);
         try file_writer.seekTo(8);
diff --git a/lib/std/hash/benchmark.zig b/lib/std/hash/benchmark.zig
index a21d6e9ada..6744b87fac 100644
--- a/lib/std/hash/benchmark.zig
+++ b/lib/std/hash/benchmark.zig
@@ -1,7 +1,8 @@
 // zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig
+const builtin = @import("builtin");
 
 const std = @import("std");
-const builtin = @import("builtin");
+const Io = std.Io;
 const time = std.time;
 const Timer = time.Timer;
 const hash = std.hash;
@@ -354,7 +355,7 @@ fn mode(comptime x: comptime_int) comptime_int {
 
 pub fn main() !void {
     var stdout_buffer: [0x100]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
 
     var buffer: [1024]u8 = undefined;
diff --git a/lib/std/http.zig b/lib/std/http.zig
index a768372ecc..291e22539b 100644
--- a/lib/std/http.zig
+++ b/lib/std/http.zig
@@ -2,7 +2,7 @@ const builtin = @import("builtin");
 const std = @import("std.zig");
 const assert = std.debug.assert;
 const Writer = std.Io.Writer;
-const File = std.fs.File;
+const File = std.Io.File;
 
 pub const Client = @import("http/Client.zig");
 pub const Server = @import("http/Server.zig");
diff --git a/lib/std/pdb.zig b/lib/std/pdb.zig
index 36b0e04e5c..7e479de8d4 100644
--- a/lib/std/pdb.zig
+++ b/lib/std/pdb.zig
@@ -12,7 +12,7 @@ const math = std.math;
 const mem = std.mem;
 const coff = std.coff;
 const fs = std.fs;
-const File = std.fs.File;
+const File = std.Io.File;
 const debug = std.debug;
 
 const ArrayList = std.ArrayList;
diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig
index 8889e50ea3..82fa2c41d1 100644
--- a/lib/std/posix/test.zig
+++ b/lib/std/posix/test.zig
@@ -1,20 +1,20 @@
+const builtin = @import("builtin");
+const native_os = builtin.target.os.tag;
+
 const std = @import("../std.zig");
+const Io = std.Io;
 const posix = std.posix;
 const testing = std.testing;
-const expect = testing.expect;
-const expectEqual = testing.expectEqual;
-const expectError = testing.expectError;
+const expect = std.testing.expect;
+const expectEqual = std.testing.expectEqual;
+const expectError = std.testing.expectError;
 const fs = std.fs;
 const mem = std.mem;
 const elf = std.elf;
 const linux = std.os.linux;
-
 const a = std.testing.allocator;
-
-const builtin = @import("builtin");
 const AtomicRmwOp = std.builtin.AtomicRmwOp;
 const AtomicOrder = std.builtin.AtomicOrder;
-const native_os = builtin.target.os.tag;
 const tmpDir = std.testing.tmpDir;
 const AT = posix.AT;
 
@@ -663,14 +663,14 @@ test "dup & dup2" {
         var file = try tmp.dir.createFile("os_dup_test", .{});
         defer file.close(io);
 
-        var duped = std.fs.File{ .handle = try posix.dup(file.handle) };
+        var duped = Io.File{ .handle = try posix.dup(file.handle) };
         defer duped.close(io);
         try duped.writeAll("dup");
 
         // Tests aren't run in parallel so using the next fd shouldn't be an issue.
         const new_fd = duped.handle + 1;
         try posix.dup2(file.handle, new_fd);
-        var dup2ed = std.fs.File{ .handle = new_fd };
+        var dup2ed = Io.File{ .handle = new_fd };
         defer dup2ed.close(io);
         try dup2ed.writeAll("dup2");
     }
diff --git a/lib/std/process/Child.zig b/lib/std/process/Child.zig
index be3026ff10..87d2fe3ba9 100644
--- a/lib/std/process/Child.zig
+++ b/lib/std/process/Child.zig
@@ -8,7 +8,7 @@ const Io = std.Io;
 const unicode = std.unicode;
 const fs = std.fs;
 const process = std.process;
-const File = std.fs.File;
+const File = std.Io.File;
 const windows = std.os.windows;
 const linux = std.os.linux;
 const posix = std.posix;
@@ -1055,7 +1055,7 @@ fn forkChildErrReport(fd: i32, err: ChildProcess.SpawnError) noreturn {
 
 fn writeIntFd(fd: i32, value: ErrInt) !void {
     var buffer: [8]u8 = undefined;
-    var fw: std.fs.File.Writer = .initStreaming(.{ .handle = fd }, &buffer);
+    var fw: File.Writer = .initStreaming(.{ .handle = fd }, &buffer);
     fw.interface.writeInt(u64, value, .little) catch unreachable;
     fw.interface.flush() catch return error.SystemResources;
 }
diff --git a/lib/std/unicode/throughput_test.zig b/lib/std/unicode/throughput_test.zig
index fd3f46ec58..c02f550a4a 100644
--- a/lib/std/unicode/throughput_test.zig
+++ b/lib/std/unicode/throughput_test.zig
@@ -1,8 +1,8 @@
 const std = @import("std");
+const Io = std.Io;
 const time = std.time;
 const unicode = std.unicode;
-
-const Timer = time.Timer;
+const Timer = std.time.Timer;
 
 const N = 1_000_000;
 
@@ -41,7 +41,7 @@ fn benchmarkCodepointCount(buf: []const u8) !ResultCount {
 pub fn main() !void {
     // Size of buffer is about size of printed message.
     var stdout_buffer: [0x100]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
 
     try stdout.print("short ASCII strings\n", .{});
diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig
index 09c785613f..37ce7b4cfa 100644
--- a/lib/std/zig/Zir.zig
+++ b/lib/std/zig/Zir.zig
@@ -11,9 +11,11 @@
 //!  * In the future, possibly inline assembly, which needs to get parsed and
 //!    handled by the codegen backend, and errors reported there. However for now,
 //!    inline assembly is not an exception.
+const Zir = @This();
+const builtin = @import("builtin");
 
 const std = @import("std");
-const builtin = @import("builtin");
+const Io = std.Io;
 const mem = std.mem;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
@@ -21,8 +23,6 @@ const BigIntConst = std.math.big.int.Const;
 const BigIntMutable = std.math.big.int.Mutable;
 const Ast = std.zig.Ast;
 
-const Zir = @This();
-
 instructions: std.MultiArrayList(Inst).Slice,
 /// In order to store references to strings in fewer bytes, we copy all
 /// string bytes into here. String bytes can be null. It is up to whomever
@@ -45,7 +45,7 @@ pub const Header = extern struct {
     /// it's essentially free to have a zero field here and makes the warning go away,
     /// making it more likely that following Valgrind warnings will be taken seriously.
     unused: u32 = 0,
-    stat_inode: std.fs.File.INode,
+    stat_inode: Io.File.INode,
     stat_size: u64,
     stat_mtime: i128,
 };
diff --git a/lib/std/zig/Zoir.zig b/lib/std/zig/Zoir.zig
index 08a7fc9639..d82b8f1861 100644
--- a/lib/std/zig/Zoir.zig
+++ b/lib/std/zig/Zoir.zig
@@ -1,6 +1,13 @@
 //! Zig Object Intermediate Representation.
 //! Simplified AST for the ZON (Zig Object Notation) format.
 //! `ZonGen` converts `Ast` to `Zoir`.
+const Zoir = @This();
+
+const std = @import("std");
+const Io = std.Io;
+const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;
+const Ast = std.zig.Ast;
 
 nodes: std.MultiArrayList(Node.Repr).Slice,
 extra: []u32,
@@ -25,7 +32,7 @@ pub const Header = extern struct {
     /// making it more likely that following Valgrind warnings will be taken seriously.
     unused: u64 = 0,
 
-    stat_inode: std.fs.File.INode,
+    stat_inode: Io.File.INode,
     stat_size: u64,
     stat_mtime: i128,
 
@@ -254,9 +261,3 @@ pub const CompileError = extern struct {
         assert(std.meta.hasUniqueRepresentation(Note));
     }
 };
-
-const std = @import("std");
-const assert = std.debug.assert;
-const Allocator = std.mem.Allocator;
-const Ast = std.zig.Ast;
-const Zoir = @This();
diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig
index 9a52ae2c81..9ca0124f4f 100644
--- a/lib/std/zig/llvm/Builder.zig
+++ b/lib/std/zig/llvm/Builder.zig
@@ -9578,7 +9578,7 @@ pub fn asmValue(
 
 pub fn dump(b: *Builder) void {
     var buffer: [4000]u8 = undefined;
-    const stderr: std.fs.File = .stderr();
+    const stderr: Io.File = .stderr();
     b.printToFile(stderr, &buffer) catch {};
 }
 
@@ -9589,7 +9589,7 @@ pub fn printToFilePath(b: *Builder, io: Io, dir: std.fs.Dir, path: []const u8) !
     try b.printToFile(io, file, &buffer);
 }
 
-pub fn printToFile(b: *Builder, file: std.fs.File, buffer: []u8) !void {
+pub fn printToFile(b: *Builder, file: Io.File, buffer: []u8) !void {
     var fw = file.writer(buffer);
     try print(b, &fw.interface);
     try fw.interface.flush();
diff --git a/lib/std/zig/perf_test.zig b/lib/std/zig/perf_test.zig
index 1566a15d2d..da3dd42f15 100644
--- a/lib/std/zig/perf_test.zig
+++ b/lib/std/zig/perf_test.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const mem = std.mem;
 const Tokenizer = std.zig.Tokenizer;
 const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
@@ -22,7 +23,7 @@ pub fn main() !void {
     const bytes_per_sec = @as(u64, @intFromFloat(@floor(bytes_per_sec_float)));
 
     var stdout_buffer: [1024]u8 = undefined;
-    var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+    var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
     const stdout = &stdout_writer.interface;
     try stdout.print("parsing speed: {Bi:.2}/s, {Bi:.2} used \n", .{ bytes_per_sec, memory_used });
     try stdout.flush();
diff --git a/lib/std/zip.zig b/lib/std/zip.zig
index c2dbaf5b81..9588651e7f 100644
--- a/lib/std/zip.zig
+++ b/lib/std/zip.zig
@@ -4,9 +4,10 @@
 //! Note that this file uses the abbreviation "cd" for "central directory"
 
 const builtin = @import("builtin");
-const std = @import("std");
-const File = std.fs.File;
 const is_le = builtin.target.cpu.arch.endian() == .little;
+
+const std = @import("std");
+const File = std.Io.File;
 const Writer = std.Io.Writer;
 const Reader = std.Io.Reader;
 const flate = std.compress.flate;