Mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2026-04-27 19:09:47 +03:00
Code Issues Packages Projects Releases Wiki Activity

update all occurrences of openFile to receive an io instance

Browse Source
This commit is contained in:
Andrew Kelley
2025-12-06 17:52:57 -08:00
parent dd1d15b72a
commit 8328de24f1
41 changed files with 124 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/compiler/aro/aro/Compilation.zig
Vendored
+2 -2
View File
@@ -1641,7 +1641,7 @@ fn addSourceFromPathExtra(comp: *Compilation, path: []const u8, kind: Source.Kin
const io = comp.io;
const file = try comp.cwd.openFile(path, .{});
const file = try comp.cwd.openFile(io, path, .{});
defer file.close(io);
return comp.addSourceFromFile(file, path, kind);
}
@@ -1975,7 +1975,7 @@ fn getPathContents(comp: *Compilation, path: []const u8, limit: Io.Limit) ![]u8
const io = comp.io;
const file = try comp.cwd.openFile(path, .{});
const file = try comp.cwd.openFile(io, path, .{});
defer file.close(io);
return comp.getFileContents(file, limit);
}
lib/compiler/aro/aro/Driver/Filesystem.zig
Vendored
+1 -1
View File
@@ -213,7 +213,7 @@ pub const Filesystem = union(enum) {
pub fn readFile(fs: Filesystem, io: Io, path: []const u8, buf: []u8) ?[]const u8 {
return switch (fs) {
.real => |cwd| {
const file = cwd.openFile(path, .{}) catch return null;
const file = cwd.openFile(io, path, .{}) catch return null;
defer file.close(io);
const bytes_read = file.readAll(buf) catch return null;
lib/compiler/aro/aro/Toolchain.zig
Vendored
+3 -3
View File
@@ -524,12 +524,12 @@ pub fn addBuiltinIncludeDir(tc: *const Toolchain) !void {
/// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
pub fn readFile(tc: *const Toolchain, path: []const u8, buf: []u8) ?[]const u8 {
const comp = tc.driver.comp;
return comp.cwd.adaptToNewApi().readFile(comp.io, path, buf) catch null;
return comp.cwd.readFile(comp.io, path, buf) catch null;
}
pub fn exists(tc: *const Toolchain, path: []const u8) bool {
const comp = tc.driver.comp;
comp.cwd.adaptToNewApi().access(comp.io, path, .{}) catch return false;
comp.cwd.access(comp.io, path, .{}) catch return false;
return true;
}
@@ -547,7 +547,7 @@ pub fn canExecute(tc: *const Toolchain, path: []const u8) bool {
}
const comp = tc.driver.comp;
comp.cwd.adaptToNewApi().access(comp.io, path, .{ .execute = true }) catch return false;
comp.cwd.access(comp.io, path, .{ .execute = true }) catch return false;
// Todo: ensure path is not a directory
return true;
}
lib/compiler/objcopy.zig
+1 -1
View File
@@ -157,7 +157,7 @@ fn cmdObjCopy(gpa: Allocator, arena: Allocator, args: []const []const u8) !void
const stat = input_file.stat() catch |err| fatal("failed to stat {s}: {t}", .{ input, err });
var in: File.Reader = .initSize(input_file.adaptToNewApi(), io, &input_buffer, stat.size);
var in: File.Reader = .initSize(input_file, io, &input_buffer, stat.size);
const elf_hdr = std.elf.Header.read(&in.interface) catch |err| switch (err) {
error.ReadFailed => fatal("unable to read {s}: {t}", .{ input, in.err.? }),
lib/compiler/std-docs.zig
+1 -1
View File
@@ -225,7 +225,7 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
},
else => continue,
}
var file = try entry.dir.openFile(entry.basename, .{});
var file = try entry.dir.openFile(io, entry.basename, .{});
defer file.close(io);
const stat = try file.stat();
var file_reader: std.Io.File.Reader = .{
lib/std/Build/Cache.zig
+5 -3
View File
@@ -502,6 +502,8 @@ pub const Manifest = struct {
@memcpy(manifest_file_path[0..self.hex_digest.len], &self.hex_digest);
manifest_file_path[hex_digest_len..][0..ext.len].* = ext.*;
const io = self.cache.io;
// We'll try to open the cache with an exclusive lock, but if that would block
// and `want_shared_lock` is set, a shared lock might be sufficient, so we'll
// open with a shared lock instead.
@@ -517,7 +519,7 @@ pub const Manifest = struct {
break;
} else |err| switch (err) {
error.WouldBlock => {
self.manifest_file = self.cache.manifest_dir.openFile(&manifest_file_path, .{
self.manifest_file = self.cache.manifest_dir.openFile(io, &manifest_file_path, .{
.mode = .read_write,
.lock = .shared,
}) catch |e| {
@@ -757,7 +759,7 @@ pub const Manifest = struct {
const pp = cache_hash_file.prefixed_path;
const dir = self.cache.prefixes()[pp.prefix].handle;
const this_file = dir.openFile(pp.sub_path, .{ .mode = .read_only }) catch |err| switch (err) {
const this_file = dir.openFile(io, pp.sub_path, .{ .mode = .read_only }) catch |err| switch (err) {
error.FileNotFound => {
// Every digest before this one has been populated successfully.
return .{ .miss = .{ .file_digests_populated = idx } };
@@ -900,7 +902,7 @@ pub const Manifest = struct {
} else {
const pp = ch_file.prefixed_path;
const dir = self.cache.prefixes()[pp.prefix].handle;
const handle = try dir.openFile(pp.sub_path, .{});
const handle = try dir.openFile(io, pp.sub_path, .{});
defer handle.close(io);
return populateFileHashHandle(self, ch_file, handle);
}
lib/std/Build/Cache/Path.zig
+2 -6
View File
@@ -59,18 +59,14 @@ pub fn joinStringZ(p: Path, gpa: Allocator, sub_path: []const u8) Allocator.Erro
return p.root_dir.joinZ(gpa, parts);
}
pub fn openFile(
p: Path,
sub_path: []const u8,
flags: Io.File.OpenFlags,
) !Io.File {
pub fn openFile(p: Path, io: Io, sub_path: []const u8, flags: Io.File.OpenFlags) !Io.File {
var buf: [fs.max_path_bytes]u8 = undefined;
const joined_path = if (p.sub_path.len == 0) sub_path else p: {
break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{
p.sub_path, sub_path,
}) catch return error.NameTooLong;
};
return p.root_dir.handle.openFile(joined_path, flags);
return p.root_dir.handle.openFile(io, joined_path, flags);
}
pub fn openDir(
lib/std/Build/Fuzz.zig
+2 -2
View File
@@ -405,7 +405,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
.root_dir = run_step.step.owner.cache_root,
.sub_path = "v/" ++ std.fmt.hex(coverage_id),
};
var coverage_file = coverage_file_path.root_dir.handle.openFile(coverage_file_path.sub_path, .{}) catch |err| {
var coverage_file = coverage_file_path.root_dir.handle.openFile(io, coverage_file_path.sub_path, .{}) catch |err| {
log.err("step '{s}': failed to load coverage file '{f}': {t}", .{
run_step.step.name, coverage_file_path, err,
});
@@ -528,7 +528,7 @@ pub fn waitAndPrintReport(fuzz: *Fuzz) void {
.root_dir = cov.run.step.owner.cache_root,
.sub_path = "v/" ++ std.fmt.hex(cov.id),
};
var coverage_file = coverage_file_path.root_dir.handle.openFile(coverage_file_path.sub_path, .{}) catch |err| {
var coverage_file = coverage_file_path.root_dir.handle.openFile(io, coverage_file_path.sub_path, .{}) catch |err| {
fatal("step '{s}': failed to load coverage file '{f}': {t}", .{
cov.run.step.name, coverage_file_path, err,
});
lib/std/Build/Step/Run.zig
+3 -3
View File
@@ -846,7 +846,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
errdefer result.deinit();
result.writer.writeAll(file_plp.prefix) catch return error.OutOfMemory;
const file = file_path.root_dir.handle.openFile(file_path.subPathOrDot(), .{}) catch |err| {
const file = file_path.root_dir.handle.openFile(io, file_path.subPathOrDot(), .{}) catch |err| {
return step.fail(
"unable to open input file '{f}': {t}",
.{ file_path, err },
@@ -1111,7 +1111,7 @@ pub fn rerunInFuzzMode(
errdefer result.deinit();
result.writer.writeAll(file_plp.prefix) catch return error.OutOfMemory;
const file = try file_path.root_dir.handle.openFile(file_path.subPathOrDot(), .{});
const file = try file_path.root_dir.handle.openFile(io, file_path.subPathOrDot(), .{});
defer file.close(io);
var buf: [1024]u8 = undefined;
@@ -2185,7 +2185,7 @@ fn evalGeneric(run: *Run, child: *std.process.Child) !EvalGenericResult {
},
.lazy_path => |lazy_path| {
const path = lazy_path.getPath3(b, &run.step);
const file = path.root_dir.handle.openFile(path.subPathOrDot(), .{}) catch |err| {
const file = path.root_dir.handle.openFile(io, path.subPathOrDot(), .{}) catch |err| {
return run.step.fail("unable to open stdin file: {s}", .{@errorName(err)});
};
defer file.close(io);
lib/std/Build/Step/UpdateSourceFiles.zig
+1 -1
View File
@@ -99,7 +99,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
.cwd(),
io,
source_path,
b.build_root.handle.adaptToNewApi(),
b.build_root.handle,
output_source_file.sub_path,
.{},
) catch |err| {
lib/std/Build/Step/WriteFile.zig
+3 -3
View File
@@ -284,7 +284,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
},
.copy => |file_source| {
const source_path = file_source.getPath2(b, step);
const prev_status = Io.Dir.updateFile(.cwd(), io, source_path, cache_dir.adaptToNewApi(), file.sub_path, .{}) catch |err| {
const prev_status = Io.Dir.updateFile(.cwd(), io, source_path, cache_dir, file.sub_path, .{}) catch |err| {
return step.fail("unable to update file from '{s}' to '{f}{s}{c}{s}': {t}", .{
source_path, b.cache_root, cache_path, fs.path.sep, file.sub_path, err,
});
@@ -321,10 +321,10 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
.directory => try cache_dir.makePath(dest_path),
.file => {
const prev_status = Io.Dir.updateFile(
src_entry_path.root_dir.handle.adaptToNewApi(),
src_entry_path.root_dir.handle,
io,
src_entry_path.sub_path,
cache_dir.adaptToNewApi(),
cache_dir,
dest_path,
.{},
) catch |err| {
lib/std/Build/WebServer.zig
+2 -2
View File
@@ -504,14 +504,14 @@ pub fn serveTarFile(ws: *WebServer, request: *http.Server.Request, paths: []cons
var archiver: std.tar.Writer = .{ .underlying_writer = &response.writer };
for (paths) |path| {
var file = path.root_dir.handle.openFile(path.sub_path, .{}) catch |err| {
var file = path.root_dir.handle.openFile(io, path.sub_path, .{}) catch |err| {
log.err("failed to open '{f}': {s}", .{ path, @errorName(err) });
continue;
};
defer file.close(io);
const stat = try file.stat();
var read_buffer: [1024]u8 = undefined;
var file_reader: Io.File.Reader = .initSize(file.adaptToNewApi(), io, &read_buffer, stat.size);
var file_reader: Io.File.Reader = .initSize(file, io, &read_buffer, stat.size);
// TODO: this logic is completely bogus -- obviously so, because `path.root_dir.path` can
// be cwd-relative. This is also related to why linkification doesn't work in the fuzzer UI:
lib/std/Io/Dir.zig
+1 -1
View File
@@ -481,7 +481,7 @@ pub fn updateFile(
}
var buffer: [1000]u8 = undefined; // Used only when direct fd-to-fd is not available.
var atomic_file = try Dir.atomicFile(.adaptFromNewApi(dest_dir), dest_path, .{
var atomic_file = try Dir.atomicFile(dest_dir, dest_path, .{
.permissions = actual_permissions,
.write_buffer = &buffer,
});
lib/std/Io/test.zig
+1 -1
View File
@@ -44,7 +44,7 @@ test "write a file, read it, then delete it" {
}
{
var file = try tmp.dir.openFile(tmp_file_name, .{});
var file = try tmp.dir.openFile(io, tmp_file_name, .{});
defer file.close(io);
const file_size = try file.getEndPos();
lib/std/Thread.zig
+2 -2
View File
@@ -208,7 +208,7 @@ pub fn setName(self: Thread, io: Io, 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, .{ .mode = .write_only });
const file = try std.fs.cwd().openFile(io, path, .{ .mode = .write_only });
defer file.close(io);
try file.writeAll(name);
@@ -325,7 +325,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co
var threaded: std.Io.Threaded = .init_single_threaded;
const io = threaded.ioBasic();
const file = try std.fs.cwd().openFile(path, .{});
const file = try std.fs.cwd().openFile(io, path, .{});
defer file.close(io);
var file_reader = file.readerStreaming(io, &.{});
lib/std/crypto/Certificate/Bundle.zig
+1 -1
View File
@@ -208,7 +208,7 @@ pub fn addCertsFromDir(cb: *Bundle, gpa: Allocator, io: Io, now: Io.Timestamp, i
else => continue,
}
try addCertsFromFilePath(cb, gpa, io, now, iterable_dir.adaptToNewApi(), entry.name);
try addCertsFromFilePath(cb, gpa, io, now, iterable_dir, entry.name);
}
}
lib/std/debug/ElfFile.zig
+1 -1
View File
@@ -375,7 +375,7 @@ fn loadSeparateDebugFile(
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;
const elf_file = std.fs.cwd().openFile(io, path, .{}) catch return null;
defer elf_file.close(io);
const result = loadInner(arena, elf_file, opt_crc) catch |err| switch (err) {
lib/std/debug/Info.zig
+1 -1
View File
@@ -39,7 +39,7 @@ pub fn load(
) LoadError!Info {
switch (format) {
.elf => {
var file = try path.root_dir.handle.openFile(path.sub_path, .{});
var file = try path.root_dir.handle.openFile(io, path.sub_path, .{});
defer file.close(io);
var elf_file: ElfFile = try .load(gpa, file, null, &.none);
lib/std/debug/MachOFile.zig
+1 -1
View File
@@ -512,7 +512,7 @@ fn loadOFile(gpa: Allocator, io: Io, o_file_name: []const u8) !OFile {
/// Uses `mmap` to map the file at `path` into memory.
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) {
const file = std.fs.cwd().openFile(io, path, .{}) catch |err| switch (err) {
error.FileNotFound => return error.MissingDebugInfo,
else => return error.ReadFailed,
};
lib/std/debug/SelfInfo/Elf.zig
+2 -2
View File
@@ -325,7 +325,7 @@ const Module = struct {
}
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;
var file = std.fs.cwd().openFile(io, mod.name, .{}) catch return error.MissingDebugInfo;
defer file.close(io);
break :res std.debug.ElfFile.load(gpa, file, mod.build_id, &.native(mod.name));
} else res: {
@@ -334,7 +334,7 @@ const Module = struct {
else => return error.ReadFailed,
};
defer gpa.free(path);
var file = std.fs.cwd().openFile(path, .{}) catch return error.MissingDebugInfo;
var file = std.fs.cwd().openFile(io, path, .{}) catch return error.MissingDebugInfo;
defer file.close(io);
break :res std.debug.ElfFile.load(gpa, file, mod.build_id, &.native(path));
};
lib/std/debug/SelfInfo/MachO.zig
+1 -1
View File
@@ -616,7 +616,7 @@ test {
/// Uses `mmap` to map the file at `path` into memory.
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) {
const file = std.fs.cwd().openFile(io, path, .{}) catch |err| switch (err) {
error.FileNotFound => return error.MissingDebugInfo,
else => return error.ReadFailed,
};
lib/std/debug/SelfInfo/Windows.zig
+3 -3
View File
@@ -387,7 +387,7 @@ const Module = struct {
const section_view = section_view_ptr.?[0..coff_len];
coff_obj = coff.Coff.init(section_view, false) catch return error.InvalidDebugInfo;
break :mapped .{
.file = .adaptFromNewApi(coff_file),
.file = coff_file,
.section_handle = section_handle,
.section_view = section_view,
};
@@ -432,7 +432,7 @@ const Module = struct {
break :pdb null;
};
const pdb_file_open_result = if (fs.path.isAbsolute(path)) res: {
break :res std.fs.cwd().openFile(path, .{});
break :res std.fs.cwd().openFile(io, path, .{});
} else res: {
const self_dir = fs.selfExeDirPathAlloc(gpa) catch |err| switch (err) {
error.OutOfMemory, error.Unexpected => |e| return e,
@@ -441,7 +441,7 @@ const Module = struct {
defer gpa.free(self_dir);
const abs_path = try fs.path.join(gpa, &.{ self_dir, path });
defer gpa.free(abs_path);
break :res std.fs.cwd().openFile(abs_path, .{});
break :res std.fs.cwd().openFile(io, abs_path, .{});
};
const pdb_file = pdb_file_open_result catch |err| switch (err) {
error.FileNotFound, error.IsDir => break :pdb null,
lib/std/fs.zig
-17
View File
@@ -287,23 +287,6 @@ pub fn symLinkAbsoluteW(
return windows.CreateSymbolicLink(null, mem.span(sym_link_path_w), mem.span(target_path_w), flags.is_directory);
}
pub const OpenSelfExeError = Io.File.OpenSelfExeError;
/// Deprecated in favor of `Io.File.openSelfExe`.
pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
if (native_os == .linux or native_os == .serenity or native_os == .windows) {
var threaded: Io.Threaded = .init_single_threaded;
const io = threaded.ioBasic();
return .adaptFromNewApi(try Io.File.openSelfExe(io, flags));
}
// Use of max_path_bytes here is valid as the resulting path is immediately
// opened with no modification.
var buf: [max_path_bytes]u8 = undefined;
const self_exe_path = try selfExePath(&buf);
buf[self_exe_path.len] = 0;
return openFileAbsolute(buf[0..self_exe_path.len :0], flags);
}
// This is `posix.ReadLinkError || posix.RealPathError` with impossible errors excluded
pub const SelfExePathError = error{
FileNotFound,
lib/std/fs/test.zig
+23 -23
View File
@@ -855,7 +855,7 @@ test "directory operations on files" {
}
// ensure the file still exists and is a file as a sanity check
file = try ctx.dir.openFile(test_file_name, .{});
file = try ctx.dir.openFile(io, test_file_name, .{});
const stat = try file.stat();
try testing.expectEqual(File.Kind.file, stat.kind);
file.close(io);
@@ -895,12 +895,12 @@ test "file operations on directories" {
if (native_os == .wasi and builtin.link_libc) {
// wasmtime unexpectedly succeeds here, see https://github.com/ziglang/zig/issues/20747
const handle = try ctx.dir.openFile(test_dir_name, .{ .mode = .read_write });
const handle = try ctx.dir.openFile(io, test_dir_name, .{ .mode = .read_write });
handle.close(io);
} else {
// Note: The `.mode = .read_write` is necessary to ensure the error occurs on all platforms.
// TODO: Add a read-only test as well, see https://github.com/ziglang/zig/issues/5732
try testing.expectError(error.IsDir, ctx.dir.openFile(test_dir_name, .{ .mode = .read_write }));
try testing.expectError(error.IsDir, ctx.dir.openFile(io, test_dir_name, .{ .mode = .read_write }));
}
if (ctx.path_type == .absolute and comptime PathType.absolute.isSupported(builtin.os)) {
@@ -973,8 +973,8 @@ test "Dir.rename files" {
try ctx.dir.rename(test_file_name, renamed_test_file_name);
// Ensure the file was renamed
try testing.expectError(error.FileNotFound, ctx.dir.openFile(test_file_name, .{}));
file = try ctx.dir.openFile(renamed_test_file_name, .{});
try testing.expectError(error.FileNotFound, ctx.dir.openFile(io, test_file_name, .{}));
file = try ctx.dir.openFile(io, renamed_test_file_name, .{});
file.close(io);
// Rename to self succeeds
@@ -986,8 +986,8 @@ test "Dir.rename files" {
existing_file.close(io);
try ctx.dir.rename(renamed_test_file_name, existing_file_path);
try testing.expectError(error.FileNotFound, ctx.dir.openFile(renamed_test_file_name, .{}));
file = try ctx.dir.openFile(existing_file_path, .{});
try testing.expectError(error.FileNotFound, ctx.dir.openFile(io, renamed_test_file_name, .{}));
file = try ctx.dir.openFile(io, existing_file_path, .{});
file.close(io);
}
}.impl);
@@ -1026,7 +1026,7 @@ test "Dir.rename directories" {
// Ensure the directory was renamed and the file still exists in it
try testing.expectError(error.FileNotFound, ctx.dir.openDir(test_dir_renamed_path, .{}));
dir = try ctx.dir.openDir(test_dir_renamed_again_path, .{});
file = try dir.openFile("test_file", .{});
file = try dir.openFile(io, "test_file", .{});
file.close(io);
dir.close(io);
}
@@ -1119,8 +1119,8 @@ test "rename" {
try fs.rename(tmp_dir1.dir, test_file_name, tmp_dir2.dir, renamed_test_file_name);
// ensure the file was renamed
try testing.expectError(error.FileNotFound, tmp_dir1.dir.openFile(test_file_name, .{}));
file = try tmp_dir2.dir.openFile(renamed_test_file_name, .{});
try testing.expectError(error.FileNotFound, tmp_dir1.dir.openFile(io, test_file_name, .{}));
file = try tmp_dir2.dir.openFile(io, renamed_test_file_name, .{});
file.close(io);
}
@@ -1156,8 +1156,8 @@ test "renameAbsolute" {
);
// ensure the file was renamed
try testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(test_file_name, .{}));
file = try tmp_dir.dir.openFile(renamed_test_file_name, .{});
try testing.expectError(error.FileNotFound, tmp_dir.dir.openFile(io, test_file_name, .{}));
file = try tmp_dir.dir.openFile(io, renamed_test_file_name, .{});
const stat = try file.stat();
try testing.expectEqual(File.Kind.file, stat.kind);
file.close(io);
@@ -1512,7 +1512,7 @@ test "setEndPos" {
const file_name = "afile.txt";
try tmp.dir.writeFile(.{ .sub_path = file_name, .data = "ninebytes" });
const f = try tmp.dir.openFile(file_name, .{ .mode = .read_write });
const f = try tmp.dir.openFile(io, file_name, .{ .mode = .read_write });
defer f.close(io);
const initial_size = try f.getEndPos();
@@ -1856,7 +1856,7 @@ test "read from locked file" {
.lock = .exclusive,
});
defer f.close(io);
const f2 = try ctx.dir.openFile(filename, .{});
const f2 = try ctx.dir.openFile(io, filename, .{});
defer f2.close(io);
var buffer: [1]u8 = undefined;
if (builtin.os.tag == .windows) {
@@ -2041,12 +2041,12 @@ test "'.' and '..' in Io.Dir functions" {
try ctx.dir.copyFile(file_path, ctx.dir, copy_path, .{});
try ctx.dir.rename(copy_path, rename_path);
const renamed_file = try ctx.dir.openFile(rename_path, .{});
const renamed_file = try ctx.dir.openFile(io, rename_path, .{});
renamed_file.close(io);
try ctx.dir.deleteFile(rename_path);
try ctx.dir.writeFile(.{ .sub_path = update_path, .data = "something" });
var dir = ctx.dir.adaptToNewApi();
var dir = ctx.dir;
const prev_status = try dir.updateFile(io, file_path, dir, update_path, .{});
try testing.expectEqual(Io.Dir.PrevStatus.stale, prev_status);
@@ -2186,7 +2186,7 @@ test "invalid UTF-8/WTF-8 paths" {
try testing.expectError(expected_err, ctx.dir.access(invalid_path, .{}));
var dir = ctx.dir.adaptToNewApi();
var dir = ctx.dir;
try testing.expectError(expected_err, dir.updateFile(io, invalid_path, dir, invalid_path, .{}));
try testing.expectError(expected_err, ctx.dir.copyFile(invalid_path, ctx.dir, invalid_path, .{}));
@@ -2235,7 +2235,7 @@ test "read file non vectored" {
try file_writer.interface.flush();
}
var file_reader: std.Io.File.Reader = .initAdapted(file, io, &.{});
var file_reader: std.Io.File.Reader = .init(file, io, &.{});
var write_buffer: [100]u8 = undefined;
var w: std.Io.Writer = .fixed(&write_buffer);
@@ -2268,7 +2268,7 @@ test "seek keeping partial buffer" {
}
var read_buffer: [3]u8 = undefined;
var file_reader: Io.File.Reader = .initAdapted(file, io, &read_buffer);
var file_reader: Io.File.Reader = .init(file, io, &read_buffer);
try testing.expectEqual(0, file_reader.logicalPos());
@@ -2301,7 +2301,7 @@ test "seekBy" {
defer tmp_dir.cleanup();
try tmp_dir.dir.writeFile(.{ .sub_path = "blah.txt", .data = "let's test seekBy" });
const f = try tmp_dir.dir.openFile("blah.txt", .{ .mode = .read_only });
const f = try tmp_dir.dir.openFile(io, "blah.txt", .{ .mode = .read_only });
defer f.close(io);
var reader = f.readerStreaming(io, &.{});
try reader.seekBy(2);
@@ -2332,7 +2332,7 @@ test "seekTo flushes buffered data" {
}
var read_buffer: [16]u8 = undefined;
var file_reader: std.Io.File.Reader = .initAdapted(file, io, &read_buffer);
var file_reader: std.Io.File.Reader = .init(file, io, &read_buffer);
var buf: [4]u8 = undefined;
try file_reader.interface.readSliceAll(&buf);
@@ -2347,7 +2347,7 @@ test "File.Writer sendfile with buffered contents" {
{
try tmp_dir.dir.writeFile(.{ .sub_path = "a", .data = "bcd" });
const in = try tmp_dir.dir.openFile("a", .{});
const in = try tmp_dir.dir.openFile(io, "a", .{});
defer in.close(io);
const out = try tmp_dir.dir.createFile("b", .{});
defer out.close(io);
@@ -2364,7 +2364,7 @@ test "File.Writer sendfile with buffered contents" {
try out_w.interface.flush();
}
var check = try tmp_dir.dir.openFile("b", .{});
var check = try tmp_dir.dir.openFile(io, "b", .{});
defer check.close(io);
var check_buf: [4]u8 = undefined;
var check_r = check.reader(io, &check_buf);
lib/std/os/linux/IoUring.zig
+3 -3
View File
@@ -3002,7 +3002,7 @@ test "renameat" {
}, cqe);
// Validate that the old file doesn't exist anymore
try testing.expectError(error.FileNotFound, tmp.dir.openFile(old_path, .{}));
try testing.expectError(error.FileNotFound, tmp.dir.openFile(io, old_path, .{}));
// Validate that the new file exists with the proper content
var new_file_data: [16]u8 = undefined;
@@ -3057,7 +3057,7 @@ test "unlinkat" {
}, cqe);
// Validate that the file doesn't exist anymore
_ = tmp.dir.openFile(path, .{}) catch |err| switch (err) {
_ = tmp.dir.openFile(io, path, .{}) catch |err| switch (err) {
error.FileNotFound => {},
else => std.debug.panic("unexpected error: {}", .{err}),
};
@@ -3154,7 +3154,7 @@ test "symlinkat" {
}, cqe);
// Validate that the symlink exist
_ = try tmp.dir.openFile(link_path, .{});
_ = try tmp.dir.openFile(io, link_path, .{});
}
test "linkat" {
lib/std/posix/test.zig
+4 -4
View File
@@ -164,10 +164,10 @@ test "linkat with different directories" {
// Test 1: link from file in subdir back up to target in parent directory
try posix.linkat(tmp.dir.fd, target_name, subdir.fd, link_name, 0);
const efd = try tmp.dir.openFile(target_name, .{});
const efd = try tmp.dir.openFile(io, target_name, .{});
defer efd.close(io);
const nfd = try subdir.openFile(link_name, .{});
const nfd = try subdir.openFile(io, link_name, .{});
defer nfd.close(io);
{
@@ -429,7 +429,7 @@ test "mmap" {
// Map the whole file
{
const file = try tmp.dir.openFile(test_out_file, .{});
const file = try tmp.dir.openFile(io, test_out_file, .{});
defer file.close(io);
const data = try posix.mmap(
@@ -454,7 +454,7 @@ test "mmap" {
// Map the upper half of the file
{
const file = try tmp.dir.openFile(test_out_file, .{});
const file = try tmp.dir.openFile(io, test_out_file, .{});
defer file.close(io);
const data = try posix.mmap(
lib/std/zig/system.zig
+3 -3
View File
@@ -817,7 +817,7 @@ fn glibcVerFromRPath(io: Io, rpath: []const u8) !std.SemanticVersion {
// .dynstr section, and finding the max version number of symbols
// that start with "GLIBC_2.".
const glibc_so_basename = "libc.so.6";
var file = dir.openFile(glibc_so_basename, .{}) catch |err| switch (err) {
var file = dir.openFile(io, glibc_so_basename, .{}) catch |err| switch (err) {
error.NameTooLong => return error.Unexpected,
error.BadPathName => return error.Unexpected,
error.PipeBusy => return error.Unexpected, // Windows-only
@@ -851,7 +851,7 @@ fn glibcVerFromRPath(io: Io, rpath: []const u8) !std.SemanticVersion {
// Empirically, glibc 2.34 libc.so .dynstr section is 32441 bytes on my system.
var buffer: [8000]u8 = undefined;
var file_reader: Io.File.Reader = .initAdapted(file, io, &buffer);
var file_reader: Io.File.Reader = .init(file, io, &buffer);
return glibcVerFromSoFile(&file_reader) catch |err| switch (err) {
error.InvalidElfMagic,
@@ -1053,7 +1053,7 @@ fn detectAbiAndDynamicLinker(io: Io, cpu: Target.Cpu, os: Target.Os, query: Targ
var is_elf_file = false;
defer if (!is_elf_file) file.close(io);
file_reader = .initAdapted(file, io, &file_reader_buffer);
file_reader = .init(file, io, &file_reader_buffer);
file_name = undefined; // it aliases file_reader_buffer
const header = elf.Header.read(&file_reader.interface) catch |hdr_err| switch (hdr_err) {
src/Compilation.zig
+4 -4
View File
@@ -1104,7 +1104,7 @@ pub const CObject = struct {
const source_line = source_line: {
if (diag.src_loc.offset == 0 or diag.src_loc.column == 0) break :source_line 0;
const file = fs.cwd().openFile(file_name, .{}) catch break :source_line 0;
const file = fs.cwd().openFile(io, file_name, .{}) catch break :source_line 0;
defer file.close(io);
var buffer: [1024]u8 = undefined;
var file_reader = file.reader(io, &buffer);
@@ -1179,7 +1179,7 @@ pub const CObject = struct {
};
var buffer: [1024]u8 = undefined;
const file = try fs.cwd().openFile(path, .{});
const file = try fs.cwd().openFile(io, path, .{});
defer file.close(io);
var file_reader = file.reader(io, &buffer);
var bc = std.zig.llvm.BitcodeReader.init(gpa, .{ .reader = &file_reader.interface });
@@ -5354,14 +5354,14 @@ fn docsCopyModule(
},
else => continue,
}
var file = mod_dir.openFile(entry.path, .{}) catch |err| {
var file = mod_dir.openFile(io, entry.path, .{}) catch |err| {
return comp.lockAndSetMiscFailure(.docs_copy, "unable to open {f}{s}: {t}", .{
root.fmt(comp), entry.path, err,
});
};
defer file.close(io);
const stat = try file.stat();
var file_reader: Io.File.Reader = .initSize(file.adaptToNewApi(), io, &buffer, stat.size);
var file_reader: Io.File.Reader = .initSize(file, io, &buffer, stat.size);
archiver.writeFileTimestamp(entry.path, &file_reader, stat.mtime) catch |err| {
return comp.lockAndSetMiscFailure(.docs_copy, "unable to archive {f}{s}: {t}", .{
src/Package/Fetch.zig
+3 -3
View File
@@ -390,7 +390,7 @@ pub fn run(f: *Fetch) RunError!void {
var server_header_buffer: [init_resource_buffer_size]u8 = undefined;
const file_err = if (dir_err == error.NotDir) e: {
if (fs.cwd().openFile(path_or_url, .{})) |file| {
if (fs.cwd().openFile(io, path_or_url, .{})) |file| {
var resource: Resource = .{ .file = file.reader(io, &server_header_buffer) };
return f.runResource(path_or_url, &resource, null);
} else |err| break :e err;
@@ -995,7 +995,7 @@ fn initResource(f: *Fetch, uri: std.Uri, resource: *Resource, reader_buffer: []u
if (ascii.eqlIgnoreCase(uri.scheme, "file")) {
const path = try uri.path.toRawMaybeAlloc(arena);
const file = f.parent_package_root.openFile(path, .{}) catch |err| {
const file = f.parent_package_root.openFile(io, path, .{}) catch |err| {
return f.fail(f.location_tok, try eb.printString("unable to open '{f}{s}': {t}", .{
f.parent_package_root, path, err,
}));
@@ -1677,7 +1677,7 @@ fn hashFileFallible(io: Io, dir: Io.Dir, hashed_file: *HashedFile) HashedFile.Er
switch (hashed_file.kind) {
.file => {
var file = try dir.openFile(hashed_file.fs_path, .{});
var file = try dir.openFile(io, hashed_file.fs_path, .{});
defer file.close(io);
// Hard-coded false executable bit: https://github.com/ziglang/zig/issues/17463
hasher.update(&.{ 0, 0 });
src/Package/Fetch/git.zig
+1 -1
View File
@@ -1714,7 +1714,7 @@ pub fn main() !void {
const format = std.meta.stringToEnum(Oid.Format, args[1]) orelse return error.InvalidFormat;
var pack_file = try std.fs.cwd().openFile(args[2], .{});
var pack_file = try std.fs.cwd().openFile(io, args[2], .{});
defer pack_file.close(io);
var pack_file_buffer: [4096]u8 = undefined;
var pack_file_reader = pack_file.reader(io, &pack_file_buffer);
src/Zcu.zig
+1 -1
View File
@@ -1076,7 +1076,7 @@ pub const File = struct {
var f = f: {
const dir, const sub_path = file.path.openInfo(zcu.comp.dirs);
break :f try dir.openFile(sub_path, .{});
break :f try dir.openFile(io, sub_path, .{});
};
defer f.close(io);
src/Zcu/PerThread.zig
+2 -2
View File
@@ -94,7 +94,7 @@ pub fn updateFile(
// In any case we need to examine the stat of the file to determine the course of action.
var source_file = f: {
const dir, const sub_path = file.path.openInfo(comp.dirs);
break :f try dir.openFile(sub_path, .{});
break :f try dir.openFile(io, sub_path, .{});
};
defer source_file.close(io);
@@ -2466,7 +2466,7 @@ fn updateEmbedFileInner(
var file = f: {
const dir, const sub_path = ef.path.openInfo(zcu.comp.dirs);
break :f try dir.openFile(sub_path, .{});
break :f try dir.openFile(io, sub_path, .{});
};
defer file.close(io);
src/fmt.zig
+1 -1
View File
@@ -262,7 +262,7 @@ fn fmtPathFile(
) !void {
const io = fmt.io;
const source_file = try dir.openFile(sub_path, .{});
const source_file = try dir.openFile(io, sub_path, .{});
var file_closed = false;
errdefer if (!file_closed) source_file.close(io);
src/introspect.zig
+2 -2
View File
@@ -22,7 +22,7 @@ fn testZigInstallPrefix(io: Io, base_dir: Io.Dir) ?Cache.Directory {
// Try lib/zig/std/std.zig
const lib_zig = "lib" ++ fs.path.sep_str ++ "zig";
var test_zig_dir = base_dir.openDir(lib_zig, .{}) catch break :zig_dir;
const file = test_zig_dir.openFile(test_index_file, .{}) catch {
const file = test_zig_dir.openFile(io, test_index_file, .{}) catch {
test_zig_dir.close(io);
break :zig_dir;
};
@@ -32,7 +32,7 @@ fn testZigInstallPrefix(io: Io, base_dir: Io.Dir) ?Cache.Directory {
// Try lib/std/std.zig
var test_zig_dir = base_dir.openDir("lib", .{}) catch return null;
const file = test_zig_dir.openFile(test_index_file, .{}) catch {
const file = test_zig_dir.openFile(io, test_index_file, .{}) catch {
test_zig_dir.close(io);
return null;
};
src/link.zig
+12 -12
View File
@@ -637,7 +637,7 @@ pub const File = struct {
}
}
}
base.file = try emit.root_dir.handle.openFile(emit.sub_path, .{ .mode = .read_write });
base.file = try emit.root_dir.handle.openFile(io, emit.sub_path, .{ .mode = .read_write });
},
.elf2, .coff2 => if (base.file == null) {
const mf = if (base.cast(.elf2)) |elf|
@@ -646,10 +646,10 @@ pub const File = struct {
&coff.mf
else
unreachable;
mf.file = try base.emit.root_dir.handle.adaptToNewApi().openFile(io, base.emit.sub_path, .{
mf.file = try base.emit.root_dir.handle.openFile(io, base.emit.sub_path, .{
.mode = .read_write,
});
base.file = .adaptFromNewApi(mf.file);
base.file = mf.file;
try mf.ensureTotalCapacity(@intCast(mf.nodes.items[0].location().resolve(mf)[1]));
},
.c, .spirv => dev.checkAny(&.{ .c_linker, .spirv_linker }),
@@ -2007,7 +2007,7 @@ fn resolveLibInput(
.sub_path = try std.fmt.allocPrint(arena, "lib{s}.tbd", .{lib_name}),
};
try checked_paths.print(gpa, "\n {f}", .{test_path});
var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
var file = test_path.root_dir.handle.openFile(io, test_path.sub_path, .{}) catch |err| switch (err) {
error.FileNotFound => break :tbd,
else => |e| fatal("unable to search for tbd library '{f}': {s}", .{ test_path, @errorName(e) }),
};
@@ -2043,7 +2043,7 @@ fn resolveLibInput(
.sub_path = try std.fmt.allocPrint(arena, "lib{s}.so", .{lib_name}),
};
try checked_paths.print(gpa, "\n {f}", .{test_path});
var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
var file = test_path.root_dir.handle.openFile(io, test_path.sub_path, .{}) catch |err| switch (err) {
error.FileNotFound => break :so,
else => |e| fatal("unable to search for so library '{f}': {s}", .{
test_path, @errorName(e),
@@ -2061,7 +2061,7 @@ fn resolveLibInput(
.sub_path = try std.fmt.allocPrint(arena, "lib{s}.a", .{lib_name}),
};
try checked_paths.print(gpa, "\n {f}", .{test_path});
var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
var file = test_path.root_dir.handle.openFile(io, test_path.sub_path, .{}) catch |err| switch (err) {
error.FileNotFound => break :mingw,
else => |e| fatal("unable to search for static library '{f}': {s}", .{ test_path, @errorName(e) }),
};
@@ -2115,7 +2115,7 @@ fn resolvePathInput(
.static_library => return try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .static, color),
.shared_library => return try resolvePathInputLib(gpa, arena, io, unresolved_inputs, resolved_inputs, ld_script_bytes, target, pq, .dynamic, color),
.object => {
var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
var file = pq.path.root_dir.handle.openFile(io, pq.path.sub_path, .{}) catch |err|
fatal("failed to open object {f}: {s}", .{ pq.path, @errorName(err) });
errdefer file.close(io);
try resolved_inputs.append(gpa, .{ .object = .{
@@ -2127,7 +2127,7 @@ fn resolvePathInput(
return null;
},
.res => {
var file = pq.path.root_dir.handle.openFile(pq.path.sub_path, .{}) catch |err|
var file = pq.path.root_dir.handle.openFile(io, pq.path.sub_path, .{}) catch |err|
fatal("failed to open windows resource {f}: {s}", .{ pq.path, @errorName(err) });
errdefer file.close(io);
try resolved_inputs.append(gpa, .{ .res = .{
@@ -2164,7 +2164,7 @@ fn resolvePathInputLib(
.static_library, .shared_library => true,
else => false,
}) {
var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
var file = test_path.root_dir.handle.openFile(io, test_path.sub_path, .{}) catch |err| switch (err) {
error.FileNotFound => return .no_match,
else => |e| fatal("unable to search for {s} library '{f}': {s}", .{
@tagName(link_mode), std.fmt.alt(test_path, .formatEscapeChar), @errorName(e),
@@ -2242,7 +2242,7 @@ fn resolvePathInputLib(
return .ok;
}
var file = test_path.root_dir.handle.openFile(test_path.sub_path, .{}) catch |err| switch (err) {
var file = test_path.root_dir.handle.openFile(io, test_path.sub_path, .{}) catch |err| switch (err) {
error.FileNotFound => return .no_match,
else => |e| fatal("unable to search for {s} library {f}: {s}", .{
@tagName(link_mode), test_path, @errorName(e),
@@ -2253,7 +2253,7 @@ fn resolvePathInputLib(
}
pub fn openObject(io: Io, path: Path, must_link: bool, hidden: bool) !Input.Object {
var file = try path.root_dir.handle.openFile(path.sub_path, .{});
var file = try path.root_dir.handle.openFile(io, path.sub_path, .{});
errdefer file.close(io);
return .{
.path = path,
@@ -2264,7 +2264,7 @@ pub fn openObject(io: Io, path: Path, must_link: bool, hidden: bool) !Input.Obje
}
pub fn openDso(io: Io, path: Path, needed: bool, weak: bool, reexport: bool) !Input.Dso {
var file = try path.root_dir.handle.openFile(path.sub_path, .{});
var file = try path.root_dir.handle.openFile(io, path.sub_path, .{});
errdefer file.close(io);
return .{
.path = path,
src/link/Coff.zig
+2 -2
View File
@@ -632,7 +632,7 @@ fn create(
};
const coff = try arena.create(Coff);
const file = try path.root_dir.handle.adaptToNewApi().createFile(comp.io, path.sub_path, .{
const file = try path.root_dir.handle.createFile(comp.io, path.sub_path, .{
.read = true,
.mode = link.File.determineMode(comp.config.output_mode, comp.config.link_mode),
});
@@ -644,7 +644,7 @@ fn create(
.comp = comp,
.emit = path,
.file = .adaptFromNewApi(file),
.file = file,
.gc_sections = false,
.print_gc_sections = false,
.build_id = .none,
src/link/Elf2.zig
+8 -6
View File
@@ -928,6 +928,7 @@ fn create(
path: std.Build.Cache.Path,
options: link.File.OpenOptions,
) !*Elf {
const io = comp.io;
const target = &comp.root_mod.resolved_target.result;
assert(target.ofmt == .elf);
const class: std.elf.CLASS = switch (target.ptrBitWidth()) {
@@ -973,11 +974,11 @@ fn create(
};
const elf = try arena.create(Elf);
const file = try path.root_dir.handle.adaptToNewApi().createFile(comp.io, path.sub_path, .{
const file = try path.root_dir.handle.createFile(io, path.sub_path, .{
.read = true,
.mode = link.File.determineMode(comp.config.output_mode, comp.config.link_mode),
});
errdefer file.close(comp.io);
errdefer file.close(io);
elf.* = .{
.base = .{
.tag = .elf2,
@@ -985,7 +986,7 @@ fn create(
.comp = comp,
.emit = path,
.file = .adaptFromNewApi(file),
.file = file,
.gc_sections = false,
.print_gc_sections = false,
.build_id = .none,
@@ -3325,12 +3326,13 @@ fn flushInputSection(elf: *Elf, isi: Node.InputSectionIndex) !void {
const file_loc = isi.fileLocation(elf);
if (file_loc.size == 0) return;
const comp = elf.base.comp;
const io = comp.io;
const gpa = comp.gpa;
const ii = isi.input(elf);
const path = ii.path(elf);
const file = try path.root_dir.handle.adaptToNewApi().openFile(comp.io, path.sub_path, .{});
defer file.close(comp.io);
var fr = file.reader(comp.io, &.{});
const file = try path.root_dir.handle.openFile(io, path.sub_path, .{});
defer file.close(io);
var fr = file.reader(io, &.{});
try fr.seekTo(file_loc.offset);
var nw: MappedFile.Node.Writer = undefined;
const si = isi.symbol(elf);
src/link/MachO.zig
+5 -3
View File
@@ -1126,7 +1126,9 @@ fn parseDependentDylibs(self: *MachO) !void {
if (self.dylibs.items.len == 0) return;
const gpa = self.base.comp.gpa;
const comp = self.base.comp;
const gpa = comp.gpa;
const io = comp.io;
const framework_dirs = self.framework_dirs;
// TODO delete this, directories must instead be resolved by the frontend
@@ -1183,7 +1185,7 @@ fn parseDependentDylibs(self: *MachO) !void {
const path = if (existing_ext.len > 0) id.name[0 .. id.name.len - existing_ext.len] else id.name;
for (&[_][]const u8{ ".tbd", ".dylib", "" }) |ext| {
test_path.clearRetainingCapacity();
if (self.base.comp.sysroot) |root| {
if (comp.sysroot) |root| {
try test_path.print("{s}" ++ fs.path.sep_str ++ "{s}{s}", .{ root, path, ext });
} else {
try test_path.print("{s}{s}", .{ path, ext });
@@ -1235,7 +1237,7 @@ fn parseDependentDylibs(self: *MachO) !void {
.path = Path.initCwd(full_path),
.weak = is_weak,
};
const file = try lib.path.root_dir.handle.openFile(lib.path.sub_path, .{});
const file = try lib.path.root_dir.handle.openFile(io, lib.path.sub_path, .{});
const fh = try self.addFileHandle(file);
const fat_arch = try self.parseFatFile(file, lib.path);
const offset = if (fat_arch) |fa| fa.offset else 0;
src/link/MachO/relocatable.zig
+4 -3
View File
@@ -1,6 +1,7 @@
pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Path) link.File.FlushError!void {
const gpa = macho_file.base.comp.gpa;
const diags = &macho_file.base.comp.link_diags;
const gpa = comp.gpa;
const io = comp.io;
const diags = &comp.link_diags;
// TODO: "positional arguments" is a CLI concept, not a linker concept. Delete this unnecessary array list.
var positionals = std.array_list.Managed(link.Input).init(gpa);
@@ -19,7 +20,7 @@ pub fn flushObject(macho_file: *MachO, comp: *Compilation, module_obj_path: ?Pat
// debug info segments/sections (this is apparently by design by Apple), we copy
// the *only* input file over.
const path = positionals.items[0].path().?;
const in_file = path.root_dir.handle.openFile(path.sub_path, .{}) catch |err|
const in_file = path.root_dir.handle.openFile(io, path.sub_path, .{}) catch |err|
return diags.fail("failed to open {f}: {s}", .{ path, @errorName(err) });
const stat = in_file.stat() catch |err|
return diags.fail("failed to stat {f}: {s}", .{ path, @errorName(err) });
src/link/MappedFile.zig
+1 -1
View File
@@ -630,7 +630,7 @@ fn resizeNode(mf: *MappedFile, gpa: std.mem.Allocator, ni: Node.Index, requested
// Resize the entire file
if (ni == Node.Index.root) {
try mf.ensureCapacityForSetLocation(gpa);
try Io.File.adaptFromNewApi(mf.file).setEndPos(new_size);
try mf.file.setEndPos(new_size);
try mf.ensureTotalCapacity(@intCast(new_size));
ni.setLocationAssumeCapacity(mf, old_offset, new_size);
return;
src/main.zig
+5 -5
View File
@@ -4681,7 +4681,7 @@ fn cmdTranslateC(
} else {
const hex_digest = Cache.binToHex(result.digest);
const out_zig_path = try fs.path.join(arena, &.{ "o", &hex_digest, translated_basename });
const zig_file = comp.dirs.local_cache.handle.openFile(out_zig_path, .{}) catch |err| {
const zig_file = comp.dirs.local_cache.handle.openFile(io, out_zig_path, .{}) catch |err| {
const path = comp.dirs.local_cache.path orelse ".";
fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{
path,
@@ -6187,7 +6187,7 @@ fn cmdAstCheck(arena: Allocator, io: Io, args: []const []const u8) !void {
const display_path = zig_source_path orelse "<stdin>";
const source: [:0]const u8 = s: {
var f = if (zig_source_path) |p| file: {
break :file fs.cwd().openFile(p, .{}) catch |err| {
break :file fs.cwd().openFile(io, p, .{}) catch |err| {
fatal("unable to open file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });
};
} else Io.File.stdin();
@@ -6494,7 +6494,7 @@ fn cmdDumpZir(arena: Allocator, io: Io, args: []const []const u8) !void {
const cache_file = args[0];
var f = fs.cwd().openFile(cache_file, .{}) catch |err| {
var f = fs.cwd().openFile(io, cache_file, .{}) catch |err| {
fatal("unable to open zir cache file for dumping '{s}': {s}", .{ cache_file, @errorName(err) });
};
defer f.close(io);
@@ -6541,7 +6541,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
const new_source_path = args[1];
const old_source = source: {
var f = fs.cwd().openFile(old_source_path, .{}) catch |err|
var f = fs.cwd().openFile(io, old_source_path, .{}) catch |err|
fatal("unable to open old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
defer f.close(io);
var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);
@@ -6549,7 +6549,7 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8) !void {
fatal("unable to read old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
};
const new_source = source: {
var f = fs.cwd().openFile(new_source_path, .{}) catch |err|
var f = fs.cwd().openFile(io, new_source_path, .{}) catch |err|
fatal("unable to open new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
defer f.close(io);
var file_reader: Io.File.Reader = f.reader(io, &stdin_buffer);