File.close invalidates

Author: marler8997

lib/std/Thread.zig

@@ -80,7 +80,7 @@ pub fn setName(self: Thread, name: []const u8) SetNameError!void {
             var buf: [32]u8 = undefined;
             const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
 
-            const file = try std.fs.cwd().openFile(path, .{ .write = true });
+            var file = try std.fs.cwd().openFile(path, .{ .write = true });
             defer file.close();
 
             try file.writer().writeAll(name);
@@ -168,7 +168,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co
             var buf: [32]u8 = undefined;
             const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
 
-            const file = try std.fs.cwd().openFile(path, .{});
+            var file = try std.fs.cwd().openFile(path, .{});
             defer file.close();
 
             const data_len = try file.reader().readAll(buffer_ptr[0 .. max_name_len + 1]);

lib/std/build.zig

@@ -3129,7 +3129,7 @@ fn findVcpkgRoot(allocator: *Allocator) !?[]const u8 {
     const path_file = try fs.path.join(allocator, &[_][]const u8{ appdata_path, "vcpkg.path.txt" });
     defer allocator.free(path_file);
 
-    const file = fs.cwd().openFile(path_file, .{}) catch return null;
+    var file = fs.cwd().openFile(path_file, .{}) catch return null;
     defer file.close();
 
     const size = @intCast(usize, try file.getEndPos());

lib/std/debug.zig

@@ -690,12 +690,12 @@ pub fn openSelfDebugInfo(allocator: *mem.Allocator) anyerror!DebugInfo {
 /// it themselves, even on error.
 /// TODO resources https://github.com/ziglang/zig/issues/4353
 /// TODO it's weird to take ownership even on error, rework this code.
-fn readCoffDebugInfo(allocator: *mem.Allocator, coff_file: File) !ModuleDebugInfo {
+fn readCoffDebugInfo(allocator: *mem.Allocator, coff_file: *File) !ModuleDebugInfo {
     nosuspend {
         errdefer coff_file.close();
 
         const coff_obj = try allocator.create(coff.Coff);
-        coff_obj.* = coff.Coff.init(allocator, coff_file);
+        coff_obj.* = coff.Coff.init(allocator, coff_file.*);
 
         var di = ModuleDebugInfo{
             .base_address = undefined,
@@ -757,7 +757,7 @@ fn chopSlice(ptr: []const u8, offset: u64, size: u64) ![]const u8 {
 /// it themselves, even on error.
 /// TODO resources https://github.com/ziglang/zig/issues/4353
 /// TODO it's weird to take ownership even on error, rework this code.
-pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: File) !ModuleDebugInfo {
+pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: *File) !ModuleDebugInfo {
     nosuspend {
         const mapped_mem = try mapWholeFile(elf_file);
         const hdr = @ptrCast(*const elf.Ehdr, &mapped_mem[0]);
@@ -829,7 +829,7 @@ pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: File) !ModuleDebugI
 /// This takes ownership of macho_file: users of this function should not close
 /// it themselves, even on error.
 /// TODO it's weird to take ownership even on error, rework this code.
-fn readMachODebugInfo(allocator: *mem.Allocator, macho_file: File) !ModuleDebugInfo {
+fn readMachODebugInfo(allocator: *mem.Allocator, macho_file: *File) !ModuleDebugInfo {
     const mapped_mem = try mapWholeFile(macho_file);
 
     const hdr = @ptrCast(
@@ -966,7 +966,7 @@ const MachoSymbol = struct {
 /// `file` is expected to have been opened with .intended_io_mode == .blocking.
 /// Takes ownership of file, even on error.
 /// TODO it's weird to take ownership even on error, rework this code.
-fn mapWholeFile(file: File) ![]align(mem.page_size) const u8 {
+fn mapWholeFile(file: *File) ![]align(mem.page_size) const u8 {
     nosuspend {
         defer file.close();
 
@@ -1135,11 +1135,11 @@ pub const DebugInfo = struct {
                 const obj_di = try self.allocator.create(ModuleDebugInfo);
                 errdefer self.allocator.destroy(obj_di);
 
-                const coff_file = fs.openFileAbsoluteW(name_buffer[0 .. len + 4 :0], .{}) catch |err| switch (err) {
+                var coff_file = fs.openFileAbsoluteW(name_buffer[0 .. len + 4 :0], .{}) catch |err| switch (err) {
                     error.FileNotFound => return error.MissingDebugInfo,
                     else => return err,
                 };
-                obj_di.* = try readCoffDebugInfo(self.allocator, coff_file);
+                obj_di.* = try readCoffDebugInfo(self.allocator, &coff_file);
                 obj_di.base_address = seg_start;
 
                 try self.address_map.putNoClobber(seg_start, obj_di);
@@ -1205,12 +1205,12 @@ pub const DebugInfo = struct {
         else
             fs.openSelfExe(.{ .intended_io_mode = .blocking });
 
-        const elf_file = copy catch |err| switch (err) {
+        var elf_file = copy catch |err| switch (err) {
             error.FileNotFound => return error.MissingDebugInfo,
             else => return err,
         };
 
-        obj_di.* = try readElfDebugInfo(self.allocator, elf_file);
+        obj_di.* = try readElfDebugInfo(self.allocator, &elf_file);
         obj_di.base_address = ctx.base_address;
 
         try self.address_map.putNoClobber(ctx.base_address, obj_di);
@@ -1240,7 +1240,7 @@ pub const ModuleDebugInfo = switch (native_os) {
         }
 
         fn loadOFile(self: *@This(), o_file_path: []const u8) !DW.DwarfInfo {
-            const o_file = try fs.cwd().openFile(o_file_path, .{ .intended_io_mode = .blocking });
+            var o_file = try fs.cwd().openFile(o_file_path, .{ .intended_io_mode = .blocking });
             const mapped_mem = try mapWholeFile(o_file);
 
             const hdr = @ptrCast(

lib/std/fs/file.zig

@@ -179,14 +179,15 @@ pub const File = struct {
 
     /// Upon success, the stream is in an uninitialized state. To continue using it,
     /// you must use the open() function.
-    pub fn close(self: File) void {
+    pub fn close(self: *File) void {
         if (is_windows) {
             windows.CloseHandle(self.handle);
         } else if (self.capable_io_mode != self.intended_io_mode) {
             std.event.Loop.instance.?.close(self.handle);
         } else {
             os.close(self.handle);
         }
+        self.* = undefined;
     }
 
     /// Test whether the file refers to a terminal.

lib/std/fs/test.zig

@@ -151,7 +151,7 @@ test "Dir.Iterator" {
     defer tmp_dir.cleanup();
 
     // First, create a couple of entries to iterate over.
-    const file = try tmp_dir.dir.createFile("some_file", .{});
+    var file = try tmp_dir.dir.createFile("some_file", .{});
     file.close();
 
     try tmp_dir.dir.makeDir("some_dir");
@@ -523,7 +523,7 @@ test "renameAbsolute" {
 test "openSelfExe" {
     if (builtin.os.tag == .wasi) return error.SkipZigTest;
 
-    const self_exe_file = try std.fs.openSelfExe(.{});
+    var self_exe_file = try std.fs.openSelfExe(.{});
     self_exe_file.close();
 }
 
@@ -803,10 +803,10 @@ test "open file with exclusive nonblocking lock twice" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    const file1 = try tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
+    var file1 = try tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
     defer file1.close();
 
-    const file2 = tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
+    var file2 = tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
     try testing.expectError(error.WouldBlock, file2);
 }
 
@@ -818,10 +818,10 @@ test "open file with shared and exclusive nonblocking lock" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    const file1 = try tmp.dir.createFile(filename, .{ .lock = .Shared, .lock_nonblocking = true });
+    var file1 = try tmp.dir.createFile(filename, .{ .lock = .Shared, .lock_nonblocking = true });
     defer file1.close();
 
-    const file2 = tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
+    var file2 = tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
     try testing.expectError(error.WouldBlock, file2);
 }
 
@@ -833,10 +833,10 @@ test "open file with exclusive and shared nonblocking lock" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    const file1 = try tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
+    var file1 = try tmp.dir.createFile(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
     defer file1.close();
 
-    const file2 = tmp.dir.createFile(filename, .{ .lock = .Shared, .lock_nonblocking = true });
+    var file2 = tmp.dir.createFile(filename, .{ .lock = .Shared, .lock_nonblocking = true });
     try testing.expectError(error.WouldBlock, file2);
 }
 
@@ -853,12 +853,12 @@ test "open file with exclusive lock twice, make sure it waits" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    const file = try tmp.dir.createFile(filename, .{ .lock = .Exclusive });
+    var file = try tmp.dir.createFile(filename, .{ .lock = .Exclusive });
     errdefer file.close();
 
     const S = struct {
         fn checkFn(dir: *fs.Dir, evt: *std.Thread.ResetEvent) !void {
-            const file1 = try dir.createFile(filename, .{ .lock = .Exclusive });
+            var file1 = try dir.createFile(filename, .{ .lock = .Exclusive });
             defer file1.close();
             evt.set();
         }
@@ -892,9 +892,9 @@ test "open file with exclusive nonblocking lock twice (absolute paths)" {
     const filename = try fs.path.resolve(allocator, &file_paths);
     defer allocator.free(filename);
 
-    const file1 = try fs.createFileAbsolute(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
+    var file1 = try fs.createFileAbsolute(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
 
-    const file2 = fs.createFileAbsolute(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
+    var file2 = fs.createFileAbsolute(filename, .{ .lock = .Exclusive, .lock_nonblocking = true });
     file1.close();
     try testing.expectError(error.WouldBlock, file2);
 
@@ -962,13 +962,13 @@ test ". and .. in fs.Dir functions" {
     var created_subdir = try tmp.dir.openDir("./subdir", .{});
     created_subdir.close();
 
-    const created_file = try tmp.dir.createFile("./subdir/../file", .{});
+    var created_file = try tmp.dir.createFile("./subdir/../file", .{});
     created_file.close();
     try tmp.dir.access("./subdir/../file", .{});
 
     try tmp.dir.copyFile("./subdir/../file", tmp.dir, "./subdir/../copy", .{});
     try tmp.dir.rename("./subdir/../copy", "./subdir/../rename");
-    const renamed_file = try tmp.dir.openFile("./subdir/../rename", .{});
+    var renamed_file = try tmp.dir.openFile("./subdir/../rename", .{});
     renamed_file.close();
     try tmp.dir.deleteFile("./subdir/../rename");
 
@@ -1001,20 +1001,20 @@ test ". and .. in absolute functions" {
     created_subdir.close();
 
     const created_file_path = try fs.path.join(allocator, &[_][]const u8{ subdir_path, "../file" });
-    const created_file = try fs.createFileAbsolute(created_file_path, .{});
+    var created_file = try fs.createFileAbsolute(created_file_path, .{});
     created_file.close();
     try fs.accessAbsolute(created_file_path, .{});
 
     const copied_file_path = try fs.path.join(allocator, &[_][]const u8{ subdir_path, "../copy" });
     try fs.copyFileAbsolute(created_file_path, copied_file_path, .{});
     const renamed_file_path = try fs.path.join(allocator, &[_][]const u8{ subdir_path, "../rename" });
     try fs.renameAbsolute(copied_file_path, renamed_file_path);
-    const renamed_file = try fs.openFileAbsolute(renamed_file_path, .{});
+    var renamed_file = try fs.openFileAbsolute(renamed_file_path, .{});
     renamed_file.close();
     try fs.deleteFileAbsolute(renamed_file_path);
 
     const update_file_path = try fs.path.join(allocator, &[_][]const u8{ subdir_path, "../update" });
-    const update_file = try fs.createFileAbsolute(update_file_path, .{});
+    var update_file = try fs.createFileAbsolute(update_file_path, .{});
     try update_file.writeAll("something");
     update_file.close();
     const prev_status = try fs.updateFileAbsolute(created_file_path, update_file_path, .{});
@@ -1030,7 +1030,7 @@ test "chmod" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    const file = try tmp.dir.createFile("test_file", .{ .mode = 0o600 });
+    var file = try tmp.dir.createFile("test_file", .{ .mode = 0o600 });
     defer file.close();
     try testing.expect((try file.stat()).mode & 0o7777 == 0o600);
 
@@ -1052,7 +1052,7 @@ test "chown" {
     var tmp = tmpDir(.{});
     defer tmp.cleanup();
 
-    const file = try tmp.dir.createFile("test_file", .{});
+    var file = try tmp.dir.createFile("test_file", .{});
     defer file.close();
     try file.chown(null, null);
 

lib/std/net.zig

@@ -1114,7 +1114,7 @@ fn linuxLookupNameFromHosts(
     family: os.sa_family_t,
     port: u16,
 ) !void {
-    const file = fs.openFileAbsoluteZ("/etc/hosts", .{}) catch |err| switch (err) {
+    var file = fs.openFileAbsoluteZ("/etc/hosts", .{}) catch |err| switch (err) {
         error.FileNotFound,
         error.NotDir,
         error.AccessDenied,
@@ -1313,7 +1313,7 @@ fn getResolvConf(allocator: *mem.Allocator, rc: *ResolvConf) !void {
     };
     errdefer rc.deinit();
 
-    const file = fs.openFileAbsoluteZ("/etc/resolv.conf", .{}) catch |err| switch (err) {
+    var file = fs.openFileAbsoluteZ("/etc/resolv.conf", .{}) catch |err| switch (err) {
         error.FileNotFound,
         error.NotDir,
         error.AccessDenied,

lib/std/os/linux/io_uring.zig

@@ -1413,7 +1413,7 @@ test "writev/fsync/readv" {
     defer ring.deinit();
 
     const path = "test_io_uring_writev_fsync_readv";
-    const file = try std.fs.cwd().createFile(path, .{ .read = true, .truncate = true });
+    var file = try std.fs.cwd().createFile(path, .{ .read = true, .truncate = true });
     defer file.close();
     defer std.fs.cwd().deleteFile(path) catch {};
     const fd = file.handle;
@@ -1481,7 +1481,7 @@ test "write/read" {
     defer ring.deinit();
 
     const path = "test_io_uring_write_read";
-    const file = try std.fs.cwd().createFile(path, .{ .read = true, .truncate = true });
+    var file = try std.fs.cwd().createFile(path, .{ .read = true, .truncate = true });
     defer file.close();
     defer std.fs.cwd().deleteFile(path) catch {};
     const fd = file.handle;
@@ -1527,7 +1527,7 @@ test "write_fixed/read_fixed" {
     defer ring.deinit();
 
     const path = "test_io_uring_write_read_fixed";
-    const file = try std.fs.cwd().createFile(path, .{ .read = true, .truncate = true });
+    var file = try std.fs.cwd().createFile(path, .{ .read = true, .truncate = true });
     defer file.close();
     defer std.fs.cwd().deleteFile(path) catch {};
     const fd = file.handle;
@@ -1633,7 +1633,7 @@ test "close" {
     defer ring.deinit();
 
     const path = "test_io_uring_close";
-    const file = try std.fs.cwd().createFile(path, .{});
+    var file = try std.fs.cwd().createFile(path, .{});
     errdefer file.close();
     defer std.fs.cwd().deleteFile(path) catch {};
 
@@ -1914,7 +1914,7 @@ test "fallocate" {
     defer ring.deinit();
 
     const path = "test_io_uring_fallocate";
-    const file = try std.fs.cwd().createFile(path, .{ .truncate = true, .mode = 0o666 });
+    var file = try std.fs.cwd().createFile(path, .{ .truncate = true, .mode = 0o666 });
     defer file.close();
     defer std.fs.cwd().deleteFile(path) catch {};
 
@@ -1958,7 +1958,7 @@ test "statx" {
     defer ring.deinit();
 
     const path = "test_io_uring_statx";
-    const file = try std.fs.cwd().createFile(path, .{ .truncate = true, .mode = 0o666 });
+    var file = try std.fs.cwd().createFile(path, .{ .truncate = true, .mode = 0o666 });
     defer file.close();
     defer std.fs.cwd().deleteFile(path) catch {};
 

lib/std/os/linux/test.zig

@@ -9,7 +9,7 @@ const fs = std.fs;
 
 test "fallocate" {
     const path = "test_fallocate";
-    const file = try fs.cwd().createFile(path, .{ .truncate = true, .mode = 0o666 });
+    var file = try fs.cwd().createFile(path, .{ .truncate = true, .mode = 0o666 });
     defer file.close();
     defer fs.cwd().deleteFile(path) catch {};