Merge pull request #24329 from ziglang/writergate

Deprecates all existing std.io readers and writers in favor of the newly
provided std.io.Reader and std.io.Writer which are non-generic and have the
buffer above the vtable - in other words the buffer is in the interface, not
the implementation. This means that although Reader and Writer are no longer
generic, they are still transparent to optimization; all of the interface
functions have a concrete hot path operating on the buffer, and only make
vtable calls when the buffer is full.

Author: andrewrk

CMakeLists.txt

@@ -436,7 +436,6 @@ set(ZIG_STAGE2_SOURCES
     lib/std/elf.zig
     lib/std/fifo.zig
     lib/std/fmt.zig
-    lib/std/fmt/format_float.zig
     lib/std/fmt/parse_float.zig
     lib/std/fs.zig
     lib/std/fs/AtomicFile.zig

build.zig

@@ -279,7 +279,7 @@ pub fn build(b: *std.Build) !void {
 
                 const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
                 if (zig_version.order(ancestor_ver) != .gt) {
-                    std.debug.print("Zig version '{}' must be greater than tagged ancestor '{}'\n", .{ zig_version, ancestor_ver });
+                    std.debug.print("Zig version '{f}' must be greater than tagged ancestor '{f}'\n", .{ zig_version, ancestor_ver });
                     std.process.exit(1);
                 }
 
@@ -1449,7 +1449,7 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
     }
 
     var dir = b.build_root.handle.openDir("doc/langref", .{ .iterate = true }) catch |err| {
-        std.debug.panic("unable to open '{}doc/langref' directory: {s}", .{
+        std.debug.panic("unable to open '{f}doc/langref' directory: {s}", .{
             b.build_root, @errorName(err),
         });
     };
@@ -1470,7 +1470,7 @@ fn generateLangRef(b: *std.Build) std.Build.LazyPath {
             // in a temporary directory
             "--cache-root", b.cache_root.path orelse ".",
         });
-        cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{}", .{b.graph.zig_lib_directory}) });
+        cmd.addArgs(&.{ "--zig-lib-dir", b.fmt("{f}", .{b.graph.zig_lib_directory}) });
         cmd.addArgs(&.{"-i"});
         cmd.addFileArg(b.path(b.fmt("doc/langref/{s}", .{entry.name})));
 

doc/langref.html.in

@@ -374,7 +374,8 @@
       <p>
       Most of the time, it is more appropriate to write to stderr rather than stdout, and
       whether or not the message is successfully written to the stream is irrelevant.
-      For this common case, there is a simpler API:
+      Also, formatted printing often comes in handy. For this common case,
+      there is a simpler API:
       </p>
       {#code|hello_again.zig#}
 

doc/langref/bad_default_value.zig

@@ -17,7 +17,7 @@ pub fn main() !void {
         .maximum = 0.20,
     };
     const category = threshold.categorize(0.90);
-    try std.io.getStdOut().writeAll(@tagName(category));
+    try std.fs.File.stdout().writeAll(@tagName(category));
 }
 
 const std = @import("std");

doc/langref/hello.zig

@@ -1,8 +1,7 @@
 const std = @import("std");
 
 pub fn main() !void {
-    const stdout = std.io.getStdOut().writer();
-    try stdout.print("Hello, {s}!\n", .{"world"});
+    try std.fs.File.stdout().writeAll("Hello, World!\n");
 }
 
 // exe=succeed

doc/langref/hello_again.zig

@@ -1,7 +1,7 @@
 const std = @import("std");
 
 pub fn main() void {
-    std.debug.print("Hello, world!\n", .{});
+    std.debug.print("Hello, {s}!\n", .{"World"});
 }
 
 // exe=succeed

lib/compiler/aro/aro/Compilation.zig

@@ -1432,7 +1432,7 @@ fn getFileContents(comp: *Compilation, path: []const u8, limit: ?u32) ![]const u
     defer buf.deinit();
 
     const max = limit orelse std.math.maxInt(u32);
-    file.reader().readAllArrayList(&buf, max) catch |e| switch (e) {
+    file.deprecatedReader().readAllArrayList(&buf, max) catch |e| switch (e) {
         error.StreamTooLong => if (limit == null) return e,
         else => return e,
     };

lib/compiler/aro/aro/Diagnostics.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const assert = std.debug.assert;
 const Allocator = mem.Allocator;
 const mem = std.mem;
 const Source = @import("Source.zig");
@@ -323,12 +324,13 @@ pub fn addExtra(
 
 pub fn render(comp: *Compilation, config: std.io.tty.Config) void {
     if (comp.diagnostics.list.items.len == 0) return;
-    var m = defaultMsgWriter(config);
+    var buffer: [1000]u8 = undefined;
+    var m = defaultMsgWriter(config, &buffer);
     defer m.deinit();
     renderMessages(comp, &m);
 }
-pub fn defaultMsgWriter(config: std.io.tty.Config) MsgWriter {
-    return MsgWriter.init(config);
+pub fn defaultMsgWriter(config: std.io.tty.Config, buffer: []u8) MsgWriter {
+    return MsgWriter.init(config, buffer);
 }
 
 pub fn renderMessages(comp: *Compilation, m: anytype) void {
@@ -443,18 +445,13 @@ pub fn renderMessage(comp: *Compilation, m: anytype, msg: Message) void {
                 printRt(m, prop.msg, .{"{s}"}, .{&str});
             } else {
                 var buf: [3]u8 = undefined;
-                const str = std.fmt.bufPrint(&buf, "x{x}", .{std.fmt.fmtSliceHexLower(&.{msg.extra.invalid_escape.char})}) catch unreachable;
+                const str = std.fmt.bufPrint(&buf, "x{x}", .{msg.extra.invalid_escape.char}) catch unreachable;
                 printRt(m, prop.msg, .{"{s}"}, .{str});
             }
         },
         .normalized => {
             const f = struct {
-                pub fn f(
-                    bytes: []const u8,
-                    comptime _: []const u8,
-                    _: std.fmt.FormatOptions,
-                    writer: anytype,
-                ) !void {
+                pub fn f(bytes: []const u8, writer: *std.io.Writer) std.io.Writer.Error!void {
                     var it: std.unicode.Utf8Iterator = .{
                         .bytes = bytes,
                         .i = 0,
@@ -464,22 +461,16 @@ pub fn renderMessage(comp: *Compilation, m: anytype, msg: Message) void {
                             try writer.writeByte(@intCast(codepoint));
                         } else if (codepoint < 0xFFFF) {
                             try writer.writeAll("\\u");
-                            try std.fmt.formatInt(codepoint, 16, .upper, .{
-                                .fill = '0',
-                                .width = 4,
-                            }, writer);
+                            try writer.printInt(codepoint, 16, .upper, .{ .fill = '0', .width = 4 });
                         } else {
                             try writer.writeAll("\\U");
-                            try std.fmt.formatInt(codepoint, 16, .upper, .{
-                                .fill = '0',
-                                .width = 8,
-                            }, writer);
+                            try writer.printInt(codepoint, 16, .upper, .{ .fill = '0', .width = 8 });
                         }
                     }
                 }
             }.f;
-            printRt(m, prop.msg, .{"{s}"}, .{
-                std.fmt.Formatter(f){ .data = msg.extra.normalized },
+            printRt(m, prop.msg, .{"{f}"}, .{
+                std.fmt.Formatter([]const u8, f){ .data = msg.extra.normalized },
             });
         },
         .none, .offset => m.write(prop.msg),
@@ -535,32 +526,31 @@ fn tagKind(d: *Diagnostics, tag: Tag, langopts: LangOpts) Kind {
 }
 
 const MsgWriter = struct {
-    w: std.io.BufferedWriter(4096, std.fs.File.Writer),
+    writer: *std.io.Writer,
     config: std.io.tty.Config,
 
-    fn init(config: std.io.tty.Config) MsgWriter {
-        std.debug.lockStdErr();
+    fn init(config: std.io.tty.Config, buffer: []u8) MsgWriter {
         return .{
-            .w = std.io.bufferedWriter(std.io.getStdErr().writer()),
+            .writer = std.debug.lockStderrWriter(buffer),
             .config = config,
         };
     }
 
     pub fn deinit(m: *MsgWriter) void {
-        m.w.flush() catch {};
-        std.debug.unlockStdErr();
+        std.debug.unlockStderrWriter();
+        m.* = undefined;
     }
 
     pub fn print(m: *MsgWriter, comptime fmt: []const u8, args: anytype) void {
-        m.w.writer().print(fmt, args) catch {};
+        m.writer.print(fmt, args) catch {};
     }
 
     fn write(m: *MsgWriter, msg: []const u8) void {
-        m.w.writer().writeAll(msg) catch {};
+        m.writer.writeAll(msg) catch {};
     }
 
     fn setColor(m: *MsgWriter, color: std.io.tty.Color) void {
-        m.config.setColor(m.w.writer(), color) catch {};
+        m.config.setColor(m.writer, color) catch {};
     }
 
     fn location(m: *MsgWriter, path: []const u8, line: u32, col: u32) void {

lib/compiler/aro/aro/Driver.zig

@@ -519,7 +519,7 @@ fn option(arg: []const u8, name: []const u8) ?[]const u8 {
 
 fn addSource(d: *Driver, path: []const u8) !Source {
     if (mem.eql(u8, "-", path)) {
-        const stdin = std.io.getStdIn().reader();
+        const stdin = std.fs.File.stdin().deprecatedReader();
         const input = try stdin.readAllAlloc(d.comp.gpa, std.math.maxInt(u32));
         defer d.comp.gpa.free(input);
         return d.comp.addSourceFromBuffer("<stdin>", input);
@@ -541,7 +541,7 @@ pub fn fatal(d: *Driver, comptime fmt: []const u8, args: anytype) error{ FatalEr
 }
 
 pub fn renderErrors(d: *Driver) void {
-    Diagnostics.render(d.comp, d.detectConfig(std.io.getStdErr()));
+    Diagnostics.render(d.comp, d.detectConfig(std.fs.File.stderr()));
 }
 
 pub fn detectConfig(d: *Driver, file: std.fs.File) std.io.tty.Config {
@@ -591,7 +591,7 @@ pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_
     var macro_buf = std.ArrayList(u8).init(d.comp.gpa);
     defer macro_buf.deinit();
 
-    const std_out = std.io.getStdOut().writer();
+    const std_out = std.fs.File.stdout().deprecatedWriter();
     if (try parseArgs(d, std_out, macro_buf.writer(), args)) return;
 
     const linking = !(d.only_preprocess or d.only_syntax or d.only_compile or d.only_preprocess_and_compile);
@@ -686,10 +686,10 @@ fn processSource(
             std.fs.cwd().createFile(some, .{}) catch |er|
                 return d.fatal("unable to create output file '{s}': {s}", .{ some, errorDescription(er) })
         else
-            std.io.getStdOut();
+            std.fs.File.stdout();
         defer if (d.output_name != null) file.close();
 
-        var buf_w = std.io.bufferedWriter(file.writer());
+        var buf_w = std.io.bufferedWriter(file.deprecatedWriter());
 
         pp.prettyPrintTokens(buf_w.writer(), dump_mode) catch |er|
             return d.fatal("unable to write result: {s}", .{errorDescription(er)});
@@ -704,8 +704,8 @@ fn processSource(
     defer tree.deinit();
 
     if (d.verbose_ast) {
-        const stdout = std.io.getStdOut();
-        var buf_writer = std.io.bufferedWriter(stdout.writer());
+        const stdout = std.fs.File.stdout();
+        var buf_writer = std.io.bufferedWriter(stdout.deprecatedWriter());
         tree.dump(d.detectConfig(stdout), buf_writer.writer()) catch {};
         buf_writer.flush() catch {};
     }
@@ -734,8 +734,8 @@ fn processSource(
     defer ir.deinit(d.comp.gpa);
 
     if (d.verbose_ir) {
-        const stdout = std.io.getStdOut();
-        var buf_writer = std.io.bufferedWriter(stdout.writer());
+        const stdout = std.fs.File.stdout();
+        var buf_writer = std.io.bufferedWriter(stdout.deprecatedWriter());
         ir.dump(d.comp.gpa, d.detectConfig(stdout), buf_writer.writer()) catch {};
         buf_writer.flush() catch {};
     }
@@ -806,10 +806,10 @@ fn processSource(
 }
 
 fn dumpLinkerArgs(items: []const []const u8) !void {
-    const stdout = std.io.getStdOut().writer();
+    const stdout = std.fs.File.stdout().deprecatedWriter();
     for (items, 0..) |item, i| {
         if (i > 0) try stdout.writeByte(' ');
-        try stdout.print("\"{}\"", .{std.zig.fmtEscapes(item)});
+        try stdout.print("\"{f}\"", .{std.zig.fmtString(item)});
     }
     try stdout.writeByte('\n');
 }

lib/compiler/aro/aro/Parser.zig

@@ -500,8 +500,8 @@ fn checkDeprecatedUnavailable(p: *Parser, ty: Type, usage_tok: TokenIndex, decl_
 
         const w = p.strings.writer();
         const msg_str = p.comp.interner.get(@"error".msg.ref()).bytes;
-        try w.print("call to '{s}' declared with attribute error: {}", .{
-            p.tokSlice(@"error".__name_tok), std.zig.fmtEscapes(msg_str),
+        try w.print("call to '{s}' declared with attribute error: {f}", .{
+            p.tokSlice(@"error".__name_tok), std.zig.fmtString(msg_str),
         });
         const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
         try p.errStr(.error_attribute, usage_tok, str);
@@ -512,8 +512,8 @@ fn checkDeprecatedUnavailable(p: *Parser, ty: Type, usage_tok: TokenIndex, decl_
 
         const w = p.strings.writer();
         const msg_str = p.comp.interner.get(warning.msg.ref()).bytes;
-        try w.print("call to '{s}' declared with attribute warning: {}", .{
-            p.tokSlice(warning.__name_tok), std.zig.fmtEscapes(msg_str),
+        try w.print("call to '{s}' declared with attribute warning: {f}", .{
+            p.tokSlice(warning.__name_tok), std.zig.fmtString(msg_str),
         });
         const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
         try p.errStr(.warning_attribute, usage_tok, str);
@@ -542,7 +542,7 @@ fn errDeprecated(p: *Parser, tag: Diagnostics.Tag, tok_i: TokenIndex, msg: ?Valu
     try w.writeAll(reason);
     if (msg) |m| {
         const str = p.comp.interner.get(m.ref()).bytes;
-        try w.print(": {}", .{std.zig.fmtEscapes(str)});
+        try w.print(": {f}", .{std.zig.fmtString(str)});
     }
     const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
     return p.errStr(tag, tok_i, str);