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

6 files changed, 51 insertions, 34 deletions

diff --git a/lib/std/debug/ElfFile.zig b/lib/std/debug/ElfFile.zig
index e81943ab49..92bcca1bcf 100644
--- a/lib/std/debug/ElfFile.zig
+++ b/lib/std/debug/ElfFile.zig
@@ -1,5 +1,13 @@
 //! A helper type for loading an ELF file and collecting its DWARF debug information, unwind
 //! information, and symbol table.
+const ElfFile = @This();
+
+const std = @import("std");
+const Io = std.Io;
+const Endian = std.builtin.Endian;
+const Dwarf = std.debug.Dwarf;
+const Allocator = std.mem.Allocator;
+const elf = std.elf;
 
 is_64: bool,
 endian: Endian,
@@ -358,10 +366,17 @@ const Section = struct {
     const Array = std.enums.EnumArray(Section.Id, ?Section);
 };
 
-fn loadSeparateDebugFile(arena: Allocator, main_loaded: *LoadInnerResult, opt_crc: ?u32, comptime fmt: []const u8, args: anytype) Allocator.Error!?[]align(std.heap.page_size_min) const u8 {
+fn loadSeparateDebugFile(
+    arena: Allocator,
+    io: Io,
+    main_loaded: *LoadInnerResult,
+    opt_crc: ?u32,
+    comptime fmt: []const u8,
+    args: anytype,
+) Allocator.Error!?[]align(std.heap.page_size_min) const u8 {
     const path = try std.fmt.allocPrint(arena, fmt, args);
     const elf_file = std.fs.cwd().openFile(path, .{}) catch return null;
-    defer elf_file.close();
+    defer elf_file.close(io);
 
     const result = loadInner(arena, elf_file, opt_crc) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
@@ -529,10 +544,3 @@ fn loadInner(
         .mapped_mem = mapped_mem,
     };
 }
-
-const std = @import("std");
-const Endian = std.builtin.Endian;
-const Dwarf = std.debug.Dwarf;
-const ElfFile = @This();
-const Allocator = std.mem.Allocator;
-const elf = std.elf;
diff --git a/lib/std/debug/Info.zig b/lib/std/debug/Info.zig
index 921cd36ab8..9268ca0247 100644
--- a/lib/std/debug/Info.zig
+++ b/lib/std/debug/Info.zig
@@ -5,19 +5,18 @@
 //! Unlike `std.debug.SelfInfo`, this API does not assume the debug information
 //! in question happens to match the host CPU architecture, OS, or other target
 //! properties.
+const Info = @This();
 
 const std = @import("../std.zig");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const Path = std.Build.Cache.Path;
 const assert = std.debug.assert;
 const Coverage = std.debug.Coverage;
 const SourceLocation = std.debug.Coverage.SourceLocation;
-
 const ElfFile = std.debug.ElfFile;
 const MachOFile = std.debug.MachOFile;
 
-const Info = @This();
-
 impl: union(enum) {
     elf: ElfFile,
     macho: MachOFile,
@@ -25,13 +24,23 @@ impl: union(enum) {
 /// Externally managed, outlives this `Info` instance.
 coverage: *Coverage,
 
-pub const LoadError = std.fs.File.OpenError || ElfFile.LoadError || MachOFile.Error || std.debug.Dwarf.ScanError || error{ MissingDebugInfo, UnsupportedDebugInfo };
+pub const LoadError = error{
+    MissingDebugInfo,
+    UnsupportedDebugInfo,
+} || std.fs.File.OpenError || ElfFile.LoadError || MachOFile.Error || std.debug.Dwarf.ScanError;
 
-pub fn load(gpa: Allocator, path: Path, coverage: *Coverage, format: std.Target.ObjectFormat, arch: std.Target.Cpu.Arch) LoadError!Info {
+pub fn load(
+    gpa: Allocator,
+    io: Io,
+    path: Path,
+    coverage: *Coverage,
+    format: std.Target.ObjectFormat,
+    arch: std.Target.Cpu.Arch,
+) LoadError!Info {
     switch (format) {
         .elf => {
             var file = try path.root_dir.handle.openFile(path.sub_path, .{});
-            defer file.close();
+            defer file.close(io);
 
             var elf_file: ElfFile = try .load(gpa, file, null, &.none);
             errdefer elf_file.deinit(gpa);
diff --git a/lib/std/debug/MachOFile.zig b/lib/std/debug/MachOFile.zig
index 3be1b1daff..3f0f620a90 100644
--- a/lib/std/debug/MachOFile.zig
+++ b/lib/std/debug/MachOFile.zig
@@ -27,13 +27,13 @@ pub fn deinit(mf: *MachOFile, gpa: Allocator) void {
     posix.munmap(mf.mapped_memory);
 }
 
-pub fn load(gpa: Allocator, path: []const u8, arch: std.Target.Cpu.Arch) Error!MachOFile {
+pub fn load(gpa: Allocator, io: Io, path: []const u8, arch: std.Target.Cpu.Arch) Error!MachOFile {
     switch (arch) {
         .x86_64, .aarch64 => {},
         else => unreachable,
     }
 
-    const all_mapped_memory = try mapDebugInfoFile(path);
+    const all_mapped_memory = try mapDebugInfoFile(io, path);
     errdefer posix.munmap(all_mapped_memory);
 
     // In most cases, the file we just mapped is a Mach-O binary. However, it could be a "universal
@@ -239,7 +239,7 @@ pub fn load(gpa: Allocator, path: []const u8, arch: std.Target.Cpu.Arch) Error!M
         .text_vmaddr = text_vmaddr,
     };
 }
-pub fn getDwarfForAddress(mf: *MachOFile, gpa: Allocator, vaddr: u64) !struct { *Dwarf, u64 } {
+pub fn getDwarfForAddress(mf: *MachOFile, gpa: Allocator, io: Io, vaddr: u64) !struct { *Dwarf, u64 } {
     const symbol = Symbol.find(mf.symbols, vaddr) orelse return error.MissingDebugInfo;
 
     if (symbol.ofile == Symbol.unknown_ofile) return error.MissingDebugInfo;
@@ -254,7 +254,7 @@ pub fn getDwarfForAddress(mf: *MachOFile, gpa: Allocator, vaddr: u64) !struct {
     const gop = try mf.ofiles.getOrPut(gpa, symbol.ofile);
     if (!gop.found_existing) {
         const name = mem.sliceTo(mf.strings[symbol.ofile..], 0);
-        gop.value_ptr.* = loadOFile(gpa, name);
+        gop.value_ptr.* = loadOFile(gpa, io, name);
     }
     const of = &(gop.value_ptr.* catch |err| return err);
 
@@ -356,7 +356,7 @@ test {
     _ = Symbol;
 }
 
-fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
+fn loadOFile(gpa: Allocator, io: Io, o_file_name: []const u8) !OFile {
     const all_mapped_memory, const mapped_ofile = map: {
         const open_paren = paren: {
             if (std.mem.endsWith(u8, o_file_name, ")")) {
@@ -365,7 +365,7 @@ fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
                 }
             }
             // Not an archive, just a normal path to a .o file
-            const m = try mapDebugInfoFile(o_file_name);
+            const m = try mapDebugInfoFile(io, o_file_name);
             break :map .{ m, m };
         };
 
@@ -373,7 +373,7 @@ fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
 
         const archive_path = o_file_name[0..open_paren];
         const target_name_in_archive = o_file_name[open_paren + 1 .. o_file_name.len - 1];
-        const mapped_archive = try mapDebugInfoFile(archive_path);
+        const mapped_archive = try mapDebugInfoFile(io, archive_path);
         errdefer posix.munmap(mapped_archive);
 
         var ar_reader: Io.Reader = .fixed(mapped_archive);
@@ -511,12 +511,12 @@ fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
 }
 
 /// Uses `mmap` to map the file at `path` into memory.
-fn mapDebugInfoFile(path: []const u8) ![]align(std.heap.page_size_min) const u8 {
+fn mapDebugInfoFile(io: Io, path: []const u8) ![]align(std.heap.page_size_min) const u8 {
     const file = std.fs.cwd().openFile(path, .{}) catch |err| switch (err) {
         error.FileNotFound => return error.MissingDebugInfo,
         else => return error.ReadFailed,
     };
-    defer file.close();
+    defer file.close(io);
 
     const file_len = std.math.cast(
         usize,
diff --git a/lib/std/debug/SelfInfo/Elf.zig b/lib/std/debug/SelfInfo/Elf.zig
index 59c0b42451..155dac6fb8 100644
--- a/lib/std/debug/SelfInfo/Elf.zig
+++ b/lib/std/debug/SelfInfo/Elf.zig
@@ -319,14 +319,14 @@ const Module = struct {
     }
 
     /// Assumes we already hold an exclusive lock.
-    fn getLoadedElf(mod: *Module, gpa: Allocator) Error!*LoadedElf {
-        if (mod.loaded_elf == null) mod.loaded_elf = loadElf(mod, gpa);
+    fn getLoadedElf(mod: *Module, gpa: Allocator, io: Io) Error!*LoadedElf {
+        if (mod.loaded_elf == null) mod.loaded_elf = loadElf(mod, gpa, io);
         return if (mod.loaded_elf.?) |*elf| elf else |err| err;
     }
-    fn loadElf(mod: *Module, gpa: Allocator) Error!LoadedElf {
+    fn loadElf(mod: *Module, gpa: Allocator, io: Io) Error!LoadedElf {
         const load_result = if (mod.name.len > 0) res: {
             var file = std.fs.cwd().openFile(mod.name, .{}) catch return error.MissingDebugInfo;
-            defer file.close();
+            defer file.close(io);
             break :res std.debug.ElfFile.load(gpa, file, mod.build_id, &.native(mod.name));
         } else res: {
             const path = std.fs.selfExePathAlloc(gpa) catch |err| switch (err) {
@@ -335,7 +335,7 @@ const Module = struct {
             };
             defer gpa.free(path);
             var file = std.fs.cwd().openFile(path, .{}) catch return error.MissingDebugInfo;
-            defer file.close();
+            defer file.close(io);
             break :res std.debug.ElfFile.load(gpa, file, mod.build_id, &.native(path));
         };
 
diff --git a/lib/std/debug/SelfInfo/MachO.zig b/lib/std/debug/SelfInfo/MachO.zig
index dd11b4c8bf..2491cf416c 100644
--- a/lib/std/debug/SelfInfo/MachO.zig
+++ b/lib/std/debug/SelfInfo/MachO.zig
@@ -615,12 +615,12 @@ test {
 }
 
 /// Uses `mmap` to map the file at `path` into memory.
-fn mapDebugInfoFile(path: []const u8) ![]align(std.heap.page_size_min) const u8 {
+fn mapDebugInfoFile(io: Io, path: []const u8) ![]align(std.heap.page_size_min) const u8 {
     const file = std.fs.cwd().openFile(path, .{}) catch |err| switch (err) {
         error.FileNotFound => return error.MissingDebugInfo,
         else => return error.ReadFailed,
     };
-    defer file.close();
+    defer file.close(io);
 
     const file_end_pos = file.getEndPos() catch |err| switch (err) {
         error.Unexpected => |e| return e,
diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig
index 0e923a0f16..557f3901eb 100644
--- a/lib/std/debug/SelfInfo/Windows.zig
+++ b/lib/std/debug/SelfInfo/Windows.zig
@@ -207,11 +207,11 @@ const Module = struct {
             file: fs.File,
             section_handle: windows.HANDLE,
             section_view: []const u8,
-            fn deinit(mf: *const MappedFile) void {
+            fn deinit(mf: *const MappedFile, io: Io) void {
                 const process_handle = windows.GetCurrentProcess();
                 assert(windows.ntdll.NtUnmapViewOfSection(process_handle, @constCast(mf.section_view.ptr)) == .SUCCESS);
                 windows.CloseHandle(mf.section_handle);
-                mf.file.close();
+                mf.file.close(io);
             }
         };
 
@@ -447,7 +447,7 @@ const Module = struct {
                 error.FileNotFound, error.IsDir => break :pdb null,
                 else => return error.ReadFailed,
             };
-            errdefer pdb_file.close();
+            errdefer pdb_file.close(io);
 
             const pdb_reader = try arena.create(Io.File.Reader);
             pdb_reader.* = pdb_file.reader(io, try arena.alloc(u8, 4096));