archives/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2026-03-08 03:24:46 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

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

Browse source
This commit is contained in:
Andrew Kelley 2025-12-06 17:23:07 -08:00
parent 1b1fb7fab6
commit 3204fb7569
70 changed files with 400 additions and 360 deletions
Download patch file Download diff file Expand all files Collapse all files

4
lib/compiler/aro/aro/Compilation.zig vendored
View file

@ -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);

15
lib/compiler/aro/aro/Driver.zig vendored
View file

@ -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.?)});
};

3
lib/compiler/aro/aro/Preprocessor.zig vendored
View file

@ -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;

3
lib/compiler/aro/backend/Assembly.zig vendored
View file

@ -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 };

3
lib/compiler/aro/main.zig vendored
View file

@ -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),

6
lib/compiler/build_runner.zig
View file

@ -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;
}

3
lib/compiler/libc.zig
View file

@ -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;

13
lib/compiler/objcopy.zig
View file

@ -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,

3
lib/compiler/reduce.zig
View file

@ -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, "--")) {

3
lib/compiler/resinator/cli.zig vendored
View file

@ -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 };

8
lib/compiler/resinator/errors.zig vendored
View file

@ -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(

10
lib/compiler/resinator/main.zig vendored
View file

@ -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.*) {

4
lib/compiler/resinator/utils.zig vendored
View file

@ -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

10
lib/compiler/test_runner.zig
View file

@ -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) {

13
lib/compiler/translate-c/main.zig vendored
View file

@ -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: {

6
lib/std/Build.zig
View file

@ -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");

2
lib/std/Build/Step.zig
View file

@ -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,

2
lib/std/Build/Step/ObjCopy.zig
View file

@ -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;

21
lib/std/Build/Step/Run.zig
View file

@ -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,

2
lib/std/Io.zig
View file

@ -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 {

9
lib/std/Io/Writer.zig
View file

@ -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();

2
lib/std/Io/test.zig
View file

@ -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;

7
lib/std/Io/tty.zig
View file

@ -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,

18
lib/std/Progress.zig
View file

@ -1,19 +1,21 @@
//! This API is non-allocating, non-fallible, thread-safe, and lock-free.
const Progress = @This();
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 builtin = @import("builtin");
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,
};

6
lib/std/Random/benchmark.zig
View file

@ -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;

4
lib/std/Thread.zig
View file

@ -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.

8
lib/std/crypto/Certificate/Bundle.zig
View file

@ -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 };

2
lib/std/crypto/Certificate/Bundle/macos.zig
View file

@ -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();

8
lib/std/crypto/benchmark.zig
View file

@ -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);

6
lib/std/debug.zig
View file

@ -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.
}

4
lib/std/debug/ElfFile.zig
View file

@ -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: {

2
lib/std/debug/Info.zig
View file

@ -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,

2
lib/std/debug/Pdb.zig
View file

@ -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;

2
lib/std/debug/SelfInfo/Windows.zig
View file

@ -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 {

2
lib/std/debug/simple_panic.zig
View file

@ -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();
}

2
lib/std/dynamic_library.zig
View file

@ -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;

8
lib/std/fs/test.zig
View file

@ -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);

5
lib/std/hash/benchmark.zig
View file

@ -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;

2
lib/std/http.zig
View file

@ -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");

2
lib/std/pdb.zig
View file

@ -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;

18
lib/std/posix/test.zig
View file

@ -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");
}

4
lib/std/process/Child.zig
View file

@ -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;
}

6
lib/std/unicode/throughput_test.zig
View file

@ -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", .{});

8
lib/std/zig/Zir.zig
View file

@ -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,
};

15
lib/std/zig/Zoir.zig
View file

@ -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();

4
lib/std/zig/llvm/Builder.zig
View file

@ -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();

3
lib/std/zig/perf_test.zig
View file

@ -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();

5
lib/std/zip.zig
View file

@ -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;

4
src/Compilation.zig
View file

@ -5325,7 +5325,7 @@ fn docsCopyModule(
comp: *Compilation,
module: *Package.Module,
name: []const u8,
tar_file_writer: *fs.File.Writer,
tar_file_writer: *Io.File.Writer,
) !void {
const io = comp.io;
const root = module.root;
@ -5361,7 +5361,7 @@ fn docsCopyModule(
};
defer file.close(io);
const stat = try file.stat();
var file_reader: fs.File.Reader = .initSize(file.adaptToNewApi(), io, &buffer, stat.size);
var file_reader: Io.File.Reader = .initSize(file.adaptToNewApi(), 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}", .{

16
src/Package/Fetch.zig
View file

@ -882,7 +882,7 @@ fn fail(f: *Fetch, msg_tok: std.zig.Ast.TokenIndex, msg_str: u32) RunError {
}
const Resource = union(enum) {
file: fs.File.Reader,
file: Io.File.Reader,
http_request: HttpRequest,
git: Git,
dir: Io.Dir,
@ -1653,7 +1653,7 @@ fn computeHash(f: *Fetch, pkg_path: Cache.Path, filter: Filter) RunError!Compute
fn dumpHashInfo(all_files: []const *const HashedFile) !void {
var stdout_buffer: [1024]u8 = undefined;
var stdout_writer: fs.File.Writer = .initStreaming(.stdout(), &stdout_buffer);
var stdout_writer: Io.File.Writer = .initStreaming(.stdout(), &stdout_buffer);
const w = &stdout_writer.interface;
for (all_files) |hashed_file| {
try w.print("{t}: {x}: {s}\n", .{ hashed_file.kind, &hashed_file.hash, hashed_file.normalized_path });
@ -1712,11 +1712,11 @@ fn deleteFileFallible(dir: Io.Dir, deleted_file: *DeletedFile) DeletedFile.Error
try dir.deleteFile(deleted_file.fs_path);
}
fn setExecutable(file: fs.File) !void {
fn setExecutable(file: Io.File) !void {
if (!std.fs.has_executable_bit) return;
const S = std.posix.S;
const mode = fs.File.default_mode | S.IXUSR | S.IXGRP | S.IXOTH;
const mode = Io.File.default_mode | S.IXUSR | S.IXGRP | S.IXOTH;
try file.chmod(mode);
}
@ -1738,10 +1738,10 @@ const HashedFile = struct {
size: u64,
const Error =
fs.File.OpenError ||
fs.File.ReadError ||
fs.File.StatError ||
fs.File.ChmodError ||
Io.File.OpenError ||
Io.File.ReadError ||
Io.File.StatError ||
Io.File.ChmodError ||
Io.Dir.ReadLinkError;
const Kind = enum { file, link };

22
src/Package/Fetch/git.zig
View file

@ -198,8 +198,8 @@ pub const Repository = struct {
repo: *Repository,
allocator: Allocator,
format: Oid.Format,
pack_file: *std.fs.File.Reader,
index_file: *std.fs.File.Reader,
pack_file: *Io.File.Reader,
index_file: *Io.File.Reader,
) !void {
repo.* = .{ .odb = undefined };
try repo.odb.init(allocator, format, pack_file, index_file);
@ -372,9 +372,9 @@ pub const Repository = struct {
/// [pack-format](https://git-scm.com/docs/pack-format).
const Odb = struct {
format: Oid.Format,
pack_file: *std.fs.File.Reader,
pack_file: *Io.File.Reader,
index_header: IndexHeader,
index_file: *std.fs.File.Reader,
index_file: *Io.File.Reader,
cache: ObjectCache = .{},
allocator: Allocator,
@ -383,8 +383,8 @@ const Odb = struct {
odb: *Odb,
allocator: Allocator,
format: Oid.Format,
pack_file: *std.fs.File.Reader,
index_file: *std.fs.File.Reader,
pack_file: *Io.File.Reader,
index_file: *Io.File.Reader,
) !void {
try pack_file.seekTo(0);
try index_file.seekTo(0);
@ -1272,8 +1272,8 @@ const IndexEntry = struct {
pub fn indexPack(
allocator: Allocator,
format: Oid.Format,
pack: *std.fs.File.Reader,
index_writer: *std.fs.File.Writer,
pack: *Io.File.Reader,
index_writer: *Io.File.Writer,
) !void {
try pack.seekTo(0);
@ -1372,7 +1372,7 @@ pub fn indexPack(
fn indexPackFirstPass(
allocator: Allocator,
format: Oid.Format,
pack: *std.fs.File.Reader,
pack: *Io.File.Reader,
index_entries: *std.AutoHashMapUnmanaged(Oid, IndexEntry),
pending_deltas: *std.ArrayList(IndexEntry),
) !Oid {
@ -1425,7 +1425,7 @@ fn indexPackFirstPass(
fn indexPackHashDelta(
allocator: Allocator,
format: Oid.Format,
pack: *std.fs.File.Reader,
pack: *Io.File.Reader,
delta: IndexEntry,
index_entries: std.AutoHashMapUnmanaged(Oid, IndexEntry),
cache: *ObjectCache,
@ -1477,7 +1477,7 @@ fn indexPackHashDelta(
fn resolveDeltaChain(
allocator: Allocator,
format: Oid.Format,
pack: *std.fs.File.Reader,
pack: *Io.File.Reader,
base_object: Object,
delta_offsets: []const u64,
cache: *ObjectCache,

8
src/Zcu.zig
View file

@ -1200,7 +1200,7 @@ pub const EmbedFile = struct {
/// `.none` means the file was not loaded, so `stat` is undefined.
val: InternPool.Index,
/// If this is `null` and `val` is `.none`, the file has never been loaded.
err: ?(std.fs.File.OpenError || std.fs.File.StatError || std.fs.File.ReadError || error{UnexpectedEof}),
err: ?(Io.File.OpenError || Io.File.StatError || Io.File.ReadError || error{UnexpectedEof}),
stat: Cache.File.Stat,
pub const Index = enum(u32) {
@ -2927,7 +2927,7 @@ comptime {
}
}
pub fn loadZirCache(gpa: Allocator, io: Io, cache_file: std.fs.File) !Zir {
pub fn loadZirCache(gpa: Allocator, io: Io, cache_file: Io.File) !Zir {
var buffer: [2000]u8 = undefined;
var file_reader = cache_file.reader(io, &buffer);
return result: {
@ -2986,7 +2986,7 @@ pub fn loadZirCacheBody(gpa: Allocator, header: Zir.Header, cache_br: *Io.Reader
return zir;
}
pub fn saveZirCache(gpa: Allocator, cache_file: std.fs.File, stat: std.fs.File.Stat, zir: Zir) (std.fs.File.WriteError || Allocator.Error)!void {
pub fn saveZirCache(gpa: Allocator, cache_file: Io.File, stat: Io.File.Stat, zir: Zir) (Io.File.WriteError || Allocator.Error)!void {
const safety_buffer = if (data_has_safety_tag)
try gpa.alloc([8]u8, zir.instructions.len)
else
@ -3026,7 +3026,7 @@ pub fn saveZirCache(gpa: Allocator, cache_file: std.fs.File, stat: std.fs.File.S
};
}
pub fn saveZoirCache(cache_file: std.fs.File, stat: std.fs.File.Stat, zoir: Zoir) std.fs.File.WriteError!void {
pub fn saveZoirCache(cache_file: Io.File, stat: Io.File.Stat, zoir: Zoir) Io.File.WriteError!void {
const header: Zoir.Header = .{
.nodes_len = @intCast(zoir.nodes.len),
.extra_len = @intCast(zoir.extra.len),

6
src/Zcu/PerThread.zig
View file

@ -118,7 +118,7 @@ pub fn updateFile(
const zir_dir = cache_directory.handle;
// Determine whether we need to reload the file from disk and redo parsing and AstGen.
var lock: std.fs.File.Lock = switch (file.status) {
var lock: Io.File.Lock = switch (file.status) {
.never_loaded, .retryable_failure => lock: {
// First, load the cached ZIR code, if any.
log.debug("AstGen checking cache: {f} (local={}, digest={s})", .{
@ -346,8 +346,8 @@ pub fn updateFile(
fn loadZirZoirCache(
zcu: *Zcu,
cache_file: std.fs.File,
stat: std.fs.File.Stat,
cache_file: Io.File,
stat: Io.File.Stat,
file: *Zcu.File,
comptime mode: Ast.Mode,
) !enum { success, invalid, truncated, stale } {

16
src/fmt.zig
View file

@ -37,9 +37,9 @@ const Fmt = struct {
arena: Allocator,
io: Io,
out_buffer: std.Io.Writer.Allocating,
stdout_writer: *fs.File.Writer,
stdout_writer: *Io.File.Writer,
const SeenMap = std.AutoHashMap(fs.File.INode, void);
const SeenMap = std.AutoHashMap(Io.File.INode, void);
};
pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !void {
@ -59,7 +59,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
const arg = args[i];
if (mem.startsWith(u8, arg, "-")) {
if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
try fs.File.stdout().writeAll(usage_fmt);
try Io.File.stdout().writeAll(usage_fmt);
return process.cleanExit();
} else if (mem.eql(u8, arg, "--color")) {
if (i + 1 >= args.len) {
@ -99,9 +99,9 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
fatal("cannot use --stdin with positional arguments", .{});
}
const stdin: fs.File = .stdin();
const stdin: Io.File = .stdin();
var stdio_buffer: [1024]u8 = undefined;
var file_reader: fs.File.Reader = stdin.reader(io, &stdio_buffer);
var file_reader: Io.File.Reader = stdin.reader(io, &stdio_buffer);
const source_code = std.zig.readSourceFileToEndAlloc(gpa, &file_reader) catch |err| {
fatal("unable to read stdin: {}", .{err});
};
@ -154,7 +154,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
process.exit(code);
}
return fs.File.stdout().writeAll(formatted);
return Io.File.stdout().writeAll(formatted);
}
if (input_files.items.len == 0) {
@ -162,7 +162,7 @@ pub fn run(gpa: Allocator, arena: Allocator, io: Io, args: []const []const u8) !
}
var stdout_buffer: [4096]u8 = undefined;
var stdout_writer = fs.File.stdout().writer(&stdout_buffer);
var stdout_writer = Io.File.stdout().writer(&stdout_buffer);
var fmt: Fmt = .{
.gpa = gpa,
@ -272,7 +272,7 @@ fn fmtPathFile(
return error.IsDir;
var read_buffer: [1024]u8 = undefined;
var file_reader: fs.File.Reader = source_file.reader(io, &read_buffer);
var file_reader: Io.File.Reader = source_file.reader(io, &read_buffer);
file_reader.size = stat.size;
const gpa = fmt.gpa;

20
src/link.zig
View file

@ -393,7 +393,7 @@ pub const File = struct {
comp: *Compilation,
emit: Path,
file: ?fs.File,
file: ?Io.File,
/// When using the LLVM backend, the emitted object is written to a file with this name. This
/// object file then becomes a normal link input to LLD or a self-hosted linker.
///
@ -1110,7 +1110,7 @@ pub const File = struct {
};
}
fn loadGnuLdScript(base: *File, path: Path, parent_query: UnresolvedInput.Query, file: fs.File) anyerror!void {
fn loadGnuLdScript(base: *File, path: Path, parent_query: UnresolvedInput.Query, file: Io.File) anyerror!void {
const comp = base.comp;
const diags = &comp.link_diags;
const gpa = comp.gpa;
@ -1238,7 +1238,7 @@ pub const File = struct {
pub fn determineMode(
output_mode: std.builtin.OutputMode,
link_mode: std.builtin.LinkMode,
) fs.File.Mode {
) Io.File.Mode {
// On common systems with a 0o022 umask, 0o777 will still result in a file created
// with 0o755 permissions, but it works appropriately if the system is configured
// more leniently. As another data point, C's fopen seems to open files with the
@ -1247,10 +1247,10 @@ pub const File = struct {
switch (output_mode) {
.Lib => return switch (link_mode) {
.dynamic => executable_mode,
.static => fs.File.default_mode,
.static => Io.File.default_mode,
},
.Exe => return executable_mode,
.Obj => return fs.File.default_mode,
.Obj => return Io.File.default_mode,
}
}
@ -1660,19 +1660,19 @@ pub const Input = union(enum) {
pub const Object = struct {
path: Path,
file: fs.File,
file: Io.File,
must_link: bool,
hidden: bool,
};
pub const Res = struct {
path: Path,
file: fs.File,
file: Io.File,
};
pub const Dso = struct {
path: Path,
file: fs.File,
file: Io.File,
needed: bool,
weak: bool,
reexport: bool,
@ -1694,7 +1694,7 @@ pub const Input = union(enum) {
}
/// Returns `null` in the case of `dso_exact`.
pub fn pathAndFile(input: Input) ?struct { Path, fs.File } {
pub fn pathAndFile(input: Input) ?struct { Path, Io.File } {
return switch (input) {
.object, .archive => |obj| .{ obj.path, obj.file },
inline .res, .dso => |x| .{ x.path, x.file },
@ -2075,7 +2075,7 @@ fn resolveLibInput(
fn finishResolveLibInput(
resolved_inputs: *std.ArrayList(Input),
path: Path,
file: std.fs.File,
file: Io.File,
link_mode: std.builtin.LinkMode,
query: UnresolvedInput.Query,
) ResolveLibInputResult {

53
src/link/Dwarf.zig
View file

@ -1,3 +1,24 @@
const Dwarf = @This();
const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const DW = std.dwarf;
const Zir = std.zig.Zir;
const assert = std.debug.assert;
const log = std.log.scoped(.dwarf);
const Writer = std.Io.Writer;
const InternPool = @import("../InternPool.zig");
const Module = @import("../Package.zig").Module;
const Type = @import("../Type.zig");
const Value = @import("../Value.zig");
const Zcu = @import("../Zcu.zig");
const codegen = @import("../codegen.zig");
const dev = @import("../dev.zig");
const link = @import("../link.zig");
const target_info = @import("../target.zig");
gpa: Allocator,
bin_file: *link.File,
format: DW.Format,
@ -29,16 +50,16 @@ pub const UpdateError = error{
UnexpectedEndOfFile,
} ||
codegen.GenerateSymbolError ||
std.fs.File.OpenError ||
std.fs.File.SetEndPosError ||
std.fs.File.CopyRangeError ||
std.fs.File.PReadError ||
std.fs.File.PWriteError;
Io.File.OpenError ||
Io.File.SetEndPosError ||
Io.File.CopyRangeError ||
Io.File.PReadError ||
Io.File.PWriteError;
pub const FlushError = UpdateError;
pub const RelocError =
std.fs.File.PWriteError;
Io.File.PWriteError;
pub const AddressSize = enum(u8) {
@"32" = 4,
@ -6350,7 +6371,7 @@ const AbbrevCode = enum {
});
};
fn getFile(dwarf: *Dwarf) ?std.fs.File {
fn getFile(dwarf: *Dwarf) ?Io.File {
if (dwarf.bin_file.cast(.macho)) |macho_file| if (macho_file.d_sym) |*d_sym| return d_sym.file;
return dwarf.bin_file.file;
}
@ -6429,21 +6450,3 @@ const force_incremental = false;
inline fn incremental(dwarf: Dwarf) bool {
return force_incremental or dwarf.bin_file.comp.config.incremental;
}
const Allocator = std.mem.Allocator;
const DW = std.dwarf;
const Dwarf = @This();
const InternPool = @import("../InternPool.zig");
const Module = @import("../Package.zig").Module;
const Type = @import("../Type.zig");
const Value = @import("../Value.zig");
const Zcu = @import("../Zcu.zig");
const Zir = std.zig.Zir;
const assert = std.debug.assert;
const codegen = @import("../codegen.zig");
const dev = @import("../dev.zig");
const link = @import("../link.zig");
const log = std.log.scoped(.dwarf);
const std = @import("std");
const target_info = @import("../target.zig");
const Writer = std.Io.Writer;

5
src/link/Elf.zig
View file

@ -3651,7 +3651,7 @@ fn fileLookup(files: std.MultiArrayList(File.Entry), index: File.Index, zig_obje
pub fn addFileHandle(
gpa: Allocator,
file_handles: *std.ArrayList(File.Handle),
handle: fs.File,
handle: Io.File,
) Allocator.Error!File.HandleIndex {
try file_handles.append(gpa, handle);
return @intCast(file_handles.items.len - 1);
@ -4068,7 +4068,7 @@ fn fmtDumpState(self: *Elf, writer: *std.Io.Writer) std.Io.Writer.Error!void {
}
/// Caller owns the memory.
pub fn preadAllAlloc(allocator: Allocator, handle: fs.File, offset: u64, size: u64) ![]u8 {
pub fn preadAllAlloc(allocator: Allocator, handle: Io.File, offset: u64, size: u64) ![]u8 {
const buffer = try allocator.alloc(u8, math.cast(usize, size) orelse return error.Overflow);
errdefer allocator.free(buffer);
const amt = try handle.preadAll(buffer, offset);
@ -4460,6 +4460,7 @@ pub fn cast(elf_file: *Elf, comptime T: type, x: anytype) error{LinkFailure}!T {
}
const std = @import("std");
const Io = std.Io;
const build_options = @import("build_options");
const builtin = @import("builtin");
const assert = std.debug.assert;

65
src/link/Elf/Object.zig
View file

@ -1,3 +1,30 @@
const Object = @This();
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const eh_frame = @import("eh_frame.zig");
const elf = std.elf;
const fs = std.fs;
const log = std.log.scoped(.link);
const math = std.math;
const mem = std.mem;
const Path = std.Build.Cache.Path;
const Allocator = std.mem.Allocator;
const Diags = @import("../../link.zig").Diags;
const Archive = @import("Archive.zig");
const Atom = @import("Atom.zig");
const AtomList = @import("AtomList.zig");
const Cie = eh_frame.Cie;
const Elf = @import("../Elf.zig");
const Fde = eh_frame.Fde;
const File = @import("file.zig").File;
const Merge = @import("Merge.zig");
const Symbol = @import("Symbol.zig");
const Alignment = Atom.Alignment;
const riscv = @import("../riscv.zig");
archive: ?InArchive = null,
/// Archive files cannot contain subdirectories, so only the basename is needed
/// for output. However, the full path is kept for error reporting.
@ -68,7 +95,7 @@ pub fn parse(
diags: *Diags,
/// For error reporting purposes only.
path: Path,
handle: fs.File,
handle: Io.File,
target: *const std.Target,
debug_fmt_strip: bool,
default_sym_version: elf.Versym,
@ -97,7 +124,7 @@ pub fn parseCommon(
gpa: Allocator,
diags: *Diags,
path: Path,
handle: fs.File,
handle: Io.File,
target: *const std.Target,
) !void {
const offset = if (self.archive) |ar| ar.offset else 0;
@ -264,7 +291,7 @@ fn initAtoms(
gpa: Allocator,
diags: *Diags,
path: Path,
handle: fs.File,
handle: Io.File,
debug_fmt_strip: bool,
target: *const std.Target,
) !void {
@ -421,7 +448,7 @@ fn initSymbols(
fn parseEhFrame(
self: *Object,
gpa: Allocator,
handle: fs.File,
handle: Io.File,
shndx: u32,
target: *const std.Target,
) !void {
@ -1310,7 +1337,7 @@ fn addString(self: *Object, gpa: Allocator, str: []const u8) !u32 {
}
/// Caller owns the memory.
fn preadShdrContentsAlloc(self: Object, gpa: Allocator, handle: fs.File, index: u32) ![]u8 {
fn preadShdrContentsAlloc(self: Object, gpa: Allocator, handle: Io.File, index: u32) ![]u8 {
assert(index < self.shdrs.items.len);
const offset = if (self.archive) |ar| ar.offset else 0;
const shdr = self.shdrs.items[index];
@ -1320,7 +1347,7 @@ fn preadShdrContentsAlloc(self: Object, gpa: Allocator, handle: fs.File, index:
}
/// Caller owns the memory.
fn preadRelocsAlloc(self: Object, gpa: Allocator, handle: fs.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {
fn preadRelocsAlloc(self: Object, gpa: Allocator, handle: Io.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {
const raw = try self.preadShdrContentsAlloc(gpa, handle, shndx);
const num = @divExact(raw.len, @sizeOf(elf.Elf64_Rela));
return @as([*]align(1) const elf.Elf64_Rela, @ptrCast(raw.ptr))[0..num];
@ -1552,29 +1579,3 @@ const InArchive = struct {
offset: u64,
size: u32,
};
const Object = @This();
const std = @import("std");
const assert = std.debug.assert;
const eh_frame = @import("eh_frame.zig");
const elf = std.elf;
const fs = std.fs;
const log = std.log.scoped(.link);
const math = std.math;
const mem = std.mem;
const Path = std.Build.Cache.Path;
const Allocator = std.mem.Allocator;
const Diags = @import("../../link.zig").Diags;
const Archive = @import("Archive.zig");
const Atom = @import("Atom.zig");
const AtomList = @import("AtomList.zig");
const Cie = eh_frame.Cie;
const Elf = @import("../Elf.zig");
const Fde = eh_frame.Fde;
const File = @import("file.zig").File;
const Merge = @import("Merge.zig");
const Symbol = @import("Symbol.zig");
const Alignment = Atom.Alignment;
const riscv = @import("../riscv.zig");

37
src/link/Elf/SharedObject.zig
View file

@ -1,3 +1,20 @@
const SharedObject = @This();
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const elf = std.elf;
const log = std.log.scoped(.elf);
const mem = std.mem;
const Path = std.Build.Cache.Path;
const Stat = std.Build.Cache.File.Stat;
const Allocator = mem.Allocator;
const Elf = @import("../Elf.zig");
const File = @import("file.zig").File;
const Symbol = @import("Symbol.zig");
const Diags = @import("../../link.zig").Diags;
path: Path,
index: File.Index,
@ -94,7 +111,7 @@ pub fn parseHeader(
gpa: Allocator,
diags: *Diags,
file_path: Path,
fs_file: std.fs.File,
fs_file: Io.File,
stat: Stat,
target: *const std.Target,
) !Header {
@ -192,7 +209,7 @@ pub fn parse(
gpa: Allocator,
/// Moves resources from header. Caller may unconditionally deinit.
header: *Header,
fs_file: std.fs.File,
fs_file: Io.File,
) !Parsed {
const symtab = if (header.dynsym_sect_index) |index| st: {
const shdr = header.sections[index];
@ -534,19 +551,3 @@ const Format = struct {
}
}
};
const SharedObject = @This();
const std = @import("std");
const assert = std.debug.assert;
const elf = std.elf;
const log = std.log.scoped(.elf);
const mem = std.mem;
const Path = std.Build.Cache.Path;
const Stat = std.Build.Cache.File.Stat;
const Allocator = mem.Allocator;
const Elf = @import("../Elf.zig");
const File = @import("file.zig").File;
const Symbol = @import("Symbol.zig");
const Diags = @import("../../link.zig").Diags;

35
src/link/Elf/file.zig
View file

@ -1,3 +1,20 @@
const std = @import("std");
const Io = std.Io;
const elf = std.elf;
const log = std.log.scoped(.link);
const Path = std.Build.Cache.Path;
const Allocator = std.mem.Allocator;
const Archive = @import("Archive.zig");
const Atom = @import("Atom.zig");
const Cie = @import("eh_frame.zig").Cie;
const Elf = @import("../Elf.zig");
const LinkerDefined = @import("LinkerDefined.zig");
const Object = @import("Object.zig");
const SharedObject = @import("SharedObject.zig");
const Symbol = @import("Symbol.zig");
const ZigObject = @import("ZigObject.zig");
pub const File = union(enum) {
zig_object: *ZigObject,
linker_defined: *LinkerDefined,
@ -279,22 +296,6 @@ pub const File = union(enum) {
shared_object: SharedObject,
};
pub const Handle = std.fs.File;
pub const Handle = Io.File;
pub const HandleIndex = Index;
};
const std = @import("std");
const elf = std.elf;
const log = std.log.scoped(.link);
const Path = std.Build.Cache.Path;
const Allocator = std.mem.Allocator;
const Archive = @import("Archive.zig");
const Atom = @import("Atom.zig");
const Cie = @import("eh_frame.zig").Cie;
const Elf = @import("../Elf.zig");
const LinkerDefined = @import("LinkerDefined.zig");
const Object = @import("Object.zig");
const SharedObject = @import("SharedObject.zig");
const Symbol = @import("Symbol.zig");
const ZigObject = @import("ZigObject.zig");

46
src/link/Elf2.zig
View file

@ -1,3 +1,23 @@
const Elf = @This();
const builtin = @import("builtin");
const native_endian = builtin.cpu.arch.endian();
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const log = std.log.scoped(.link);
const codegen = @import("../codegen.zig");
const Compilation = @import("../Compilation.zig");
const InternPool = @import("../InternPool.zig");
const link = @import("../link.zig");
const MappedFile = @import("MappedFile.zig");
const target_util = @import("../target.zig");
const Type = @import("../Type.zig");
const Value = @import("../Value.zig");
const Zcu = @import("../Zcu.zig");
base: link.File,
options: link.File.OpenOptions,
mf: MappedFile,
@ -1973,8 +1993,8 @@ pub fn lazySymbol(elf: *Elf, lazy: link.File.LazySymbol) !Symbol.Index {
return lazy_gop.value_ptr.*;
}
pub fn loadInput(elf: *Elf, input: link.Input) (std.fs.File.Reader.SizeError ||
std.Io.File.Reader.Error || MappedFile.Error || error{ EndOfStream, BadMagic, LinkFailure })!void {
pub fn loadInput(elf: *Elf, input: link.Input) (Io.File.Reader.SizeError ||
Io.File.Reader.Error || MappedFile.Error || error{ EndOfStream, BadMagic, LinkFailure })!void {
const io = elf.base.comp.io;
var buf: [4096]u8 = undefined;
switch (input) {
@ -2007,7 +2027,7 @@ pub fn loadInput(elf: *Elf, input: link.Input) (std.fs.File.Reader.SizeError ||
.dso_exact => |dso_exact| try elf.loadDsoExact(dso_exact.name),
}
}
fn loadArchive(elf: *Elf, path: std.Build.Cache.Path, fr: *std.Io.File.Reader) !void {
fn loadArchive(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) !void {
const comp = elf.base.comp;
const gpa = comp.gpa;
const diags = &comp.link_diags;
@ -2067,7 +2087,7 @@ fn loadObject(
elf: *Elf,
path: std.Build.Cache.Path,
member: ?[]const u8,
fr: *std.Io.File.Reader,
fr: *Io.File.Reader,
fl: MappedFile.Node.FileLocation,
) !void {
const comp = elf.base.comp;
@ -2310,7 +2330,7 @@ fn loadObject(
},
}
}
fn loadDso(elf: *Elf, path: std.Build.Cache.Path, fr: *std.Io.File.Reader) !void {
fn loadDso(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) !void {
const comp = elf.base.comp;
const diags = &comp.link_diags;
const r = &fr.interface;
@ -3822,19 +3842,3 @@ pub fn printNode(
try w.writeByte('\n');
}
}
const assert = std.debug.assert;
const builtin = @import("builtin");
const codegen = @import("../codegen.zig");
const Compilation = @import("../Compilation.zig");
const Elf = @This();
const InternPool = @import("../InternPool.zig");
const link = @import("../link.zig");
const log = std.log.scoped(.link);
const MappedFile = @import("MappedFile.zig");
const native_endian = builtin.cpu.arch.endian();
const std = @import("std");
const target_util = @import("../target.zig");
const Type = @import("../Type.zig");
const Value = @import("../Value.zig");
const Zcu = @import("../Zcu.zig");

23
src/link/MachO.zig
View file

@ -890,7 +890,7 @@ pub fn classifyInputFile(self: *MachO, input: link.Input) !void {
_ = try self.addTbd(.fromLinkInput(input), true, fh);
}
fn parseFatFile(self: *MachO, file: std.fs.File, path: Path) !?fat.Arch {
fn parseFatFile(self: *MachO, file: Io.File, path: Path) !?fat.Arch {
const diags = &self.base.comp.link_diags;
const fat_h = fat.readFatHeader(file) catch return null;
if (fat_h.magic != macho.FAT_MAGIC and fat_h.magic != macho.FAT_MAGIC_64) return null;
@ -903,7 +903,7 @@ fn parseFatFile(self: *MachO, file: std.fs.File, path: Path) !?fat.Arch {
return diags.failParse(path, "missing arch in universal file: expected {s}", .{@tagName(cpu_arch)});
}
pub fn readMachHeader(file: std.fs.File, offset: usize) !macho.mach_header_64 {
pub fn readMachHeader(file: Io.File, offset: usize) !macho.mach_header_64 {
var buffer: [@sizeOf(macho.mach_header_64)]u8 = undefined;
const nread = try file.preadAll(&buffer, offset);
if (nread != buffer.len) return error.InputOutput;
@ -911,7 +911,7 @@ pub fn readMachHeader(file: std.fs.File, offset: usize) !macho.mach_header_64 {
return hdr;
}
pub fn readArMagic(file: std.fs.File, offset: usize, buffer: *[Archive.SARMAG]u8) ![]const u8 {
pub fn readArMagic(file: Io.File, offset: usize, buffer: *[Archive.SARMAG]u8) ![]const u8 {
const nread = try file.preadAll(buffer, offset);
if (nread != buffer.len) return error.InputOutput;
return buffer[0..Archive.SARMAG];
@ -3768,7 +3768,7 @@ pub fn getInternalObject(self: *MachO) ?*InternalObject {
return self.getFile(index).?.internal;
}
pub fn addFileHandle(self: *MachO, file: fs.File) !File.HandleIndex {
pub fn addFileHandle(self: *MachO, file: Io.File) !File.HandleIndex {
const gpa = self.base.comp.gpa;
const index: File.HandleIndex = @intCast(self.file_handles.items.len);
const fh = try self.file_handles.addOne(gpa);
@ -5373,10 +5373,11 @@ const max_distance = (1 << (jump_bits - 1));
const max_allowed_distance = max_distance - 0x500_000;
const MachO = @This();
const std = @import("std");
const build_options = @import("build_options");
const builtin = @import("builtin");
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const fs = std.fs;
const log = std.log.scoped(.link);
@ -5386,6 +5387,11 @@ const math = std.math;
const mem = std.mem;
const meta = std.meta;
const Writer = std.Io.Writer;
const AtomicBool = std.atomic.Value(bool);
const Cache = std.Build.Cache;
const Hash = std.hash.Wyhash;
const Md5 = std.crypto.hash.Md5;
const Allocator = std.mem.Allocator;
const aarch64 = codegen.aarch64.encoding;
const bind = @import("MachO/dyld_info/bind.zig");
@ -5403,11 +5409,8 @@ const trace = @import("../tracy.zig").trace;
const synthetic = @import("MachO/synthetic.zig");
const Alignment = Atom.Alignment;
const Allocator = mem.Allocator;
const Archive = @import("MachO/Archive.zig");
const AtomicBool = std.atomic.Value(bool);
const Bind = bind.Bind;
const Cache = std.Build.Cache;
const CodeSignature = @import("MachO/CodeSignature.zig");
const Compilation = @import("../Compilation.zig");
const DataInCode = synthetic.DataInCode;
@ -5417,14 +5420,12 @@ const ExportTrie = @import("MachO/dyld_info/Trie.zig");
const Path = Cache.Path;
const File = @import("MachO/file.zig").File;
const GotSection = synthetic.GotSection;
const Hash = std.hash.Wyhash;
const Indsymtab = synthetic.Indsymtab;
const InternalObject = @import("MachO/InternalObject.zig");
const ObjcStubsSection = synthetic.ObjcStubsSection;
const Object = @import("MachO/Object.zig");
const LazyBind = bind.LazyBind;
const LaSymbolPtrSection = synthetic.LaSymbolPtrSection;
const Md5 = std.crypto.hash.Md5;
const Zcu = @import("../Zcu.zig");
const InternPool = @import("../InternPool.zig");
const Rebase = @import("MachO/dyld_info/Rebase.zig");

8
src/link/MachO/CodeSignature.zig
View file

@ -1,17 +1,19 @@
const CodeSignature = @This();
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const fs = std.fs;
const log = std.log.scoped(.link);
const macho = std.macho;
const mem = std.mem;
const testing = std.testing;
const Sha256 = std.crypto.hash.sha2.Sha256;
const Allocator = std.mem.Allocator;
const trace = @import("../../tracy.zig").trace;
const Allocator = mem.Allocator;
const Hasher = @import("hasher.zig").ParallelHasher;
const MachO = @import("../MachO.zig");
const Sha256 = std.crypto.hash.sha2.Sha256;
const hash_size = Sha256.digest_length;
@ -250,7 +252,7 @@ pub fn addEntitlements(self: *CodeSignature, allocator: Allocator, path: []const
}
pub const WriteOpts = struct {
file: fs.File,
file: Io.File,
exec_seg_base: u64,
exec_seg_limit: u64,
file_size: u32,

14
src/link/MachO/fat.zig
View file

@ -1,18 +1,20 @@
const std = @import("std");
const assert = std.debug.assert;
const builtin = @import("builtin");
const native_endian = builtin.target.cpu.arch.endian();
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const log = std.log.scoped(.macho);
const macho = std.macho;
const mem = std.mem;
const native_endian = builtin.target.cpu.arch.endian();
const MachO = @import("../MachO.zig");
pub fn readFatHeader(file: std.fs.File) !macho.fat_header {
pub fn readFatHeader(file: Io.File) !macho.fat_header {
return readFatHeaderGeneric(macho.fat_header, file, 0);
}
fn readFatHeaderGeneric(comptime Hdr: type, file: std.fs.File, offset: usize) !Hdr {
fn readFatHeaderGeneric(comptime Hdr: type, file: Io.File, offset: usize) !Hdr {
var buffer: [@sizeOf(Hdr)]u8 = undefined;
const nread = try file.preadAll(&buffer, offset);
if (nread != buffer.len) return error.InputOutput;
@ -27,7 +29,7 @@ pub const Arch = struct {
size: u32,
};
pub fn parseArchs(file: std.fs.File, fat_header: macho.fat_header, out: *[2]Arch) ![]const Arch {
pub fn parseArchs(file: Io.File, fat_header: macho.fat_header, out: *[2]Arch) ![]const Arch {
var count: usize = 0;
var fat_arch_index: u32 = 0;
while (fat_arch_index < fat_header.nfat_arch and count < out.len) : (fat_arch_index += 1) {

3
src/link/MachO/file.zig
View file

@ -355,11 +355,12 @@ pub const File = union(enum) {
dylib: Dylib,
};
pub const Handle = std.fs.File;
pub const Handle = Io.File;
pub const HandleIndex = Index;
};
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const log = std.log.scoped(.link);
const macho = std.macho;

22
src/link/MachO/hasher.zig
View file

@ -1,3 +1,9 @@
const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const trace = @import("../../tracy.zig").trace;
pub fn ParallelHasher(comptime Hasher: type) type {
const hash_size = Hasher.digest_length;
@ -5,7 +11,7 @@ pub fn ParallelHasher(comptime Hasher: type) type {
allocator: Allocator,
io: std.Io,
pub fn hash(self: Self, file: fs.File, out: [][hash_size]u8, opts: struct {
pub fn hash(self: Self, file: Io.File, out: [][hash_size]u8, opts: struct {
chunk_size: u64 = 0x4000,
max_file_size: ?u64 = null,
}) !void {
@ -23,7 +29,7 @@ pub fn ParallelHasher(comptime Hasher: type) type {
const buffer = try self.allocator.alloc(u8, chunk_size * out.len);
defer self.allocator.free(buffer);
const results = try self.allocator.alloc(fs.File.PReadError!usize, out.len);
const results = try self.allocator.alloc(Io.File.PReadError!usize, out.len);
defer self.allocator.free(results);
{
@ -51,11 +57,11 @@ pub fn ParallelHasher(comptime Hasher: type) type {
}
fn worker(
file: fs.File,
file: Io.File,
fstart: usize,
buffer: []u8,
out: *[hash_size]u8,
err: *fs.File.PReadError!usize,
err: *Io.File.PReadError!usize,
) void {
const tracy = trace(@src());
defer tracy.end();
@ -66,11 +72,3 @@ pub fn ParallelHasher(comptime Hasher: type) type {
const Self = @This();
};
}
const assert = std.debug.assert;
const fs = std.fs;
const mem = std.mem;
const std = @import("std");
const trace = @import("../../tracy.zig").trace;
const Allocator = mem.Allocator;

19
src/link/MachO/uuid.zig
View file

@ -1,10 +1,18 @@
const std = @import("std");
const Io = std.Io;
const Md5 = std.crypto.hash.Md5;
const trace = @import("../../tracy.zig").trace;
const Compilation = @import("../../Compilation.zig");
const Hasher = @import("hasher.zig").ParallelHasher;
/// Calculates Md5 hash of each chunk in parallel and then hashes all Md5 hashes to produce
/// the final digest.
/// While this is NOT a correct MD5 hash of the contents, this methodology is used by LLVM/LLD
/// and we will use it too as it seems accepted by Apple OSes.
/// TODO LLD also hashes the output filename to disambiguate between same builds with different
/// output files. Should we also do that?
pub fn calcUuid(comp: *const Compilation, file: fs.File, file_size: u64, out: *[Md5.digest_length]u8) !void {
pub fn calcUuid(comp: *const Compilation, file: Io.File, file_size: u64, out: *[Md5.digest_length]u8) !void {
const tracy = trace(@src());
defer tracy.end();
@ -37,12 +45,3 @@ inline fn conform(out: *[Md5.digest_length]u8) void {
out[6] = (out[6] & 0x0F) | (3 << 4);
out[8] = (out[8] & 0x3F) | 0x80;
}
const fs = std.fs;
const mem = std.mem;
const std = @import("std");
const trace = @import("../../tracy.zig").trace;
const Compilation = @import("../../Compilation.zig");
const Md5 = std.crypto.hash.Md5;
const Hasher = @import("hasher.zig").ParallelHasher;

25
src/link/MappedFile.zig
View file

@ -1,3 +1,15 @@
const MappedFile = @This();
const builtin = @import("builtin");
const is_linux = builtin.os.tag == .linux;
const is_windows = builtin.os.tag == .windows;
const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const linux = std.os.linux;
const windows = std.os.windows;
file: std.Io.File,
flags: packed struct {
block_size: std.mem.Alignment,
@ -16,7 +28,7 @@ writers: std.SinglyLinkedList,
pub const growth_factor = 4;
pub const Error = std.posix.MMapError || std.posix.MRemapError || std.fs.File.SetEndPosError || error{
pub const Error = std.posix.MMapError || std.posix.MRemapError || Io.File.SetEndPosError || error{
NotFile,
SystemResources,
IsDir,
@ -618,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 std.fs.File.adaptFromNewApi(mf.file).setEndPos(new_size);
try Io.File.adaptFromNewApi(mf.file).setEndPos(new_size);
try mf.ensureTotalCapacity(@intCast(new_size));
ni.setLocationAssumeCapacity(mf, old_offset, new_size);
return;
@ -1059,12 +1071,3 @@ fn verifyNode(mf: *MappedFile, parent_ni: Node.Index) void {
ni = node.next;
}
}
const assert = std.debug.assert;
const builtin = @import("builtin");
const is_linux = builtin.os.tag == .linux;
const is_windows = builtin.os.tag == .windows;
const linux = std.os.linux;
const MappedFile = @This();
const std = @import("std");
const windows = std.os.windows;

5
src/link/Wasm.zig
View file

@ -20,6 +20,7 @@ const native_endian = builtin.cpu.arch.endian();
const build_options = @import("build_options");
const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const Cache = std.Build.Cache;
const Path = Cache.Path;
@ -3001,9 +3002,9 @@ pub fn createEmpty(
.read = true,
.mode = if (fs.has_executable_bit)
if (target.os.tag == .wasi and output_mode == .Exe)
fs.File.default_mode | 0b001_000_000
Io.File.default_mode | 0b001_000_000
else
fs.File.default_mode
Io.File.default_mode
else
0,
});

10
src/link/tapi.zig
View file

@ -1,10 +1,10 @@
const std = @import("std");
const fs = std.fs;
const Io = std.Io;
const mem = std.mem;
const log = std.log.scoped(.tapi);
const yaml = @import("tapi/yaml.zig");
const Allocator = std.mem.Allocator;
const Allocator = mem.Allocator;
const yaml = @import("tapi/yaml.zig");
const Yaml = yaml.Yaml;
const VersionField = union(enum) {
@ -130,7 +130,7 @@ pub const Tbd = union(enum) {
pub const TapiError = error{
NotLibStub,
InputOutput,
} || yaml.YamlError || std.fs.File.PReadError;
} || yaml.YamlError || Io.File.PReadError;
pub const LibStub = struct {
/// Underlying memory for stub's contents.
@ -139,7 +139,7 @@ pub const LibStub = struct {
/// Typed contents of the tbd file.
inner: []Tbd,
pub fn loadFromFile(allocator: Allocator, file: fs.File) TapiError!LibStub {
pub fn loadFromFile(allocator: Allocator, file: Io.File) TapiError!LibStub {
const filesize = blk: {
const stat = file.stat() catch break :blk std.math.maxInt(u32);
break :blk @min(stat.size, std.math.maxInt(u32));