std.Io: delete BufferedWriter

lib/compiler/aro/aro/Driver.zig

@@ -585,6 +585,8 @@ pub fn errorDescription(e: anyerror) []const u8 {
     };
 }
 
+var stdout_buffer: [4096]u8 = undefined;
+
 /// The entry point of the Aro compiler.
 /// **MAY call `exit` if `fast_exit` is set.**
 pub fn main(d: *Driver, tc: *Toolchain, args: []const []const u8, comptime fast_exit: bool) !void {
@@ -688,13 +690,13 @@ fn processSource(
         else
             std.fs.File.stdout();
         defer if (d.output_name != null) file.close();
+        var file_buffer: [1024]u8 = undefined;
+        var file_writer = file.writer(&file_buffer);
 
-        var buf_w = std.io.bufferedWriter(file.deprecatedWriter());
-
-        pp.prettyPrintTokens(buf_w.writer(), dump_mode) catch |er|
+        pp.prettyPrintTokens(&file_writer.interface, dump_mode) catch |er|
             return d.fatal("unable to write result: {s}", .{errorDescription(er)});
 
-        buf_w.flush() catch |er|
+        file_writer.interface.flush() catch |er|
             return d.fatal("unable to write result: {s}", .{errorDescription(er)});
         if (fast_exit) std.process.exit(0); // Not linking, no need for cleanup.
         return;
@@ -704,10 +706,9 @@ fn processSource(
     defer tree.deinit();
 
     if (d.verbose_ast) {
-        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 {};
+        var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+        tree.dump(d.detectConfig(.stdout()), &stdout_writer.interface) catch {};
+        stdout_writer.interface.flush() catch {};
     }
 
     const prev_errors = d.comp.diagnostics.errors;
@@ -734,10 +735,9 @@ fn processSource(
     defer ir.deinit(d.comp.gpa);
 
     if (d.verbose_ir) {
-        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 {};
+        var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
+        ir.dump(d.comp.gpa, d.detectConfig(.stdout()), &stdout_writer.interface) catch {};
+        stdout_writer.interface.flush() catch {};
     }
 
     var render_errors: Ir.Renderer.ErrorList = .{};

lib/compiler/aro/aro/Preprocessor.zig

@@ -811,10 +811,9 @@ fn verboseLog(pp: *Preprocessor, raw: RawToken, comptime fmt: []const u8, args:
     const source = pp.comp.getSource(raw.source);
     const line_col = source.lineCol(.{ .id = raw.source, .line = raw.line, .byte_offset = raw.start });
 
-    const stderr = std.fs.File.stderr().deprecatedWriter();
-    var buf_writer = std.io.bufferedWriter(stderr);
-    const writer = buf_writer.writer();
-    defer buf_writer.flush() catch {};
+    var stderr_buffer: [64]u8 = undefined;
+    var writer = std.debug.lockStderrWriter(&stderr_buffer);
+    defer std.debug.unlockStderrWriter();
     writer.print("{s}:{d}:{d}: ", .{ source.path, line_col.line_no, line_col.col }) catch return;
     writer.print(fmt, args) catch return;
     writer.writeByte('\n') catch return;

lib/compiler/aro/backend/Object/Elf.zig

@@ -171,8 +171,9 @@ pub fn addRelocation(elf: *Elf, name: []const u8, section_kind: Object.Section,
 /// strtab
 /// section headers
 pub fn finish(elf: *Elf, file: std.fs.File) !void {
-    var buf_writer = std.io.bufferedWriter(file.deprecatedWriter());
-    const w = buf_writer.writer();
+    var file_buffer: [1024]u8 = undefined;
+    var file_writer = file.writer(&file_buffer);
+    const w = &file_writer.interface;
 
     var num_sections: std.elf.Elf64_Half = additional_sections;
     var relocations_len: std.elf.Elf64_Off = 0;
@@ -374,5 +375,5 @@ pub fn finish(elf: *Elf, file: std.fs.File) !void {
             name_offset += @as(u32, @intCast(entry.key_ptr.len + ".\x00".len)) + rela_name_offset;
         }
     }
-    try buf_writer.flush();
+    try w.flush();
 }

lib/compiler/libc.zig

@@ -22,6 +22,8 @@ const usage_libc =
     \\
 ;
 
+var stdout_buffer: [4096]u8 = undefined;
+
 pub fn main() !void {
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena_instance.deinit();
@@ -34,14 +36,16 @@ 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);
+    const stdout = &stdout_writer.interface;
     {
         var i: usize = 2;
         while (i < args.len) : (i += 1) {
             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().deprecatedWriter();
                     try stdout.writeAll(usage_libc);
+                    try stdout.flush();
                     return std.process.cleanExit();
                 } else if (mem.eql(u8, arg, "-target")) {
                     if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
@@ -97,13 +101,11 @@ pub fn main() !void {
             fatal("no include dirs detected for target {s}", .{zig_target});
         }
 
-        var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
-        var writer = bw.writer();
         for (libc_dirs.libc_include_dir_list) |include_dir| {
-            try writer.writeAll(include_dir);
-            try writer.writeByte('\n');
+            try stdout.writeAll(include_dir);
+            try stdout.writeByte('\n');
         }
-        try bw.flush();
+        try stdout.flush();
         return std.process.cleanExit();
     }
 
@@ -125,9 +127,8 @@ pub fn main() !void {
         };
         defer libc.deinit(gpa);
 
-        var bw = std.io.bufferedWriter(std.fs.File.stdout().deprecatedWriter());
-        try libc.render(bw.writer());
-        try bw.flush();
+        try libc.render(stdout);
+        try stdout.flush();
     }
 }
 

lib/compiler/resinator/compile.zig

@@ -1268,21 +1268,17 @@ pub const Compiler = struct {
         try header.write(writer, self.errContext(id_token));
     }
 
-    pub fn writeResourceDataNoPadding(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
-        var adapted = writer.adaptToNewApi();
-        var buffer: [128]u8 = undefined;
-        adapted.new_interface.buffer = &buffer;
-        try data_reader.streamExact(&adapted.new_interface, data_size);
-        try adapted.new_interface.flush();
+    pub fn writeResourceDataNoPadding(writer: *std.Io.Writer, data_reader: *std.Io.Reader, data_size: u32) !void {
+        try data_reader.streamExact(writer, data_size);
     }
 
     pub fn writeResourceData(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
         try writeResourceDataNoPadding(writer, data_reader, data_size);
         try writeDataPadding(writer, data_size);
     }
 
-    pub fn writeDataPadding(writer: anytype, data_size: u32) !void {
-        try writer.writeByteNTimes(0, numPaddingBytesNeeded(data_size));
+    pub fn writeDataPadding(writer: *std.Io.Writer, data_size: u32) !void {
+        try writer.splatByteAll(0, numPaddingBytesNeeded(data_size));
     }
 
     pub fn numPaddingBytesNeeded(data_size: u32) u2 {
@@ -2100,8 +2096,10 @@ pub const Compiler = struct {
         const resource = ResourceType.fromString(type_bytes);
         std.debug.assert(resource == .menu or resource == .menuex);
 
-        self.writeMenuData(node, data_writer, resource) catch |err| switch (err) {
-            error.NoSpaceLeft => {
+        var adapted = data_writer.adaptToNewApi(&.{});
+
+        self.writeMenuData(node, &adapted.new_interface, resource) catch |err| switch (err) {
+            error.WriteFailed => {
                 return self.addErrorDetailsAndFail(.{
                     .err = .resource_data_size_exceeds_max,
                     .token = node.id,
@@ -2129,7 +2127,7 @@ pub const Compiler = struct {
 
     /// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
     /// the writer within this function could return error.NoSpaceLeft
-    pub fn writeMenuData(self: *Compiler, node: *Node.Menu, data_writer: anytype, resource: ResourceType) !void {
+    pub fn writeMenuData(self: *Compiler, node: *Node.Menu, data_writer: *std.Io.Writer, resource: ResourceType) !void {
         // menu header
         const version: u16 = if (resource == .menu) 0 else 1;
         try data_writer.writeInt(u16, version, .little);
@@ -2156,7 +2154,7 @@ pub const Compiler = struct {
         }
     }
 
-    pub fn writeMenuItem(self: *Compiler, node: *Node, writer: anytype, is_last_of_parent: bool) !void {
+    pub fn writeMenuItem(self: *Compiler, node: *Node, writer: *std.Io.Writer, is_last_of_parent: bool) !void {
         switch (node.id) {
             .menu_item_separator => {
                 // This is the 'alternate compability form' of the separator, see
@@ -2356,8 +2354,9 @@ pub const Compiler = struct {
         try fixed_file_info.write(data_writer);
 
         for (node.block_statements) |statement| {
-            self.writeVersionNode(statement, data_writer, &data_buffer) catch |err| switch (err) {
-                error.NoSpaceLeft => {
+            var adapted = data_writer.adaptToNewApi(&.{});
+            self.writeVersionNode(statement, &adapted.new_interface, &data_buffer) catch |err| switch (err) {
+                error.WriteFailed => {
                     try self.addErrorDetails(.{
                         .err = .version_node_size_exceeds_max,
                         .token = node.id,
@@ -2395,7 +2394,7 @@ pub const Compiler = struct {
     /// Expects writer to be a LimitedWriter limited to u16, meaning all writes to
     /// the writer within this function could return error.NoSpaceLeft, and that buf.items.len
     /// will never be able to exceed maxInt(u16).
-    pub fn writeVersionNode(self: *Compiler, node: *Node, writer: anytype, buf: *std.ArrayList(u8)) !void {
+    pub fn writeVersionNode(self: *Compiler, node: *Node, writer: *std.Io.Writer, buf: *std.ArrayList(u8)) !void {
         // We can assume that buf.items.len will never be able to exceed the limits of a u16
         try writeDataPadding(writer, @as(u16, @intCast(buf.items.len)));
 
@@ -2700,12 +2699,12 @@ pub const Compiler = struct {
             return self.writeSizeInfo(writer, size_info);
         }
 
-        pub fn writeSizeInfo(self: ResourceHeader, writer: anytype, size_info: SizeInfo) !void {
+        pub fn writeSizeInfo(self: ResourceHeader, writer: *std.Io.Writer, size_info: SizeInfo) !void {
             try writer.writeInt(DWORD, self.data_size, .little); // DataSize
             try writer.writeInt(DWORD, size_info.bytes, .little); // HeaderSize
             try self.type_value.write(writer); // TYPE
             try self.name_value.write(writer); // NAME
-            try writer.writeByteNTimes(0, size_info.padding_after_name);
+            try writer.splatByteAll(0, size_info.padding_after_name);
 
             try writer.writeInt(DWORD, self.data_version, .little); // DataVersion
             try writer.writeInt(WORD, self.memory_flags.value, .little); // MemoryFlags
@@ -3120,7 +3119,7 @@ pub const FontDir = struct {
             // First, the ID is written, though
             try writer.writeInt(u16, font.id, .little);
             try writer.writeAll(&font.header_bytes);
-            try writer.writeByteNTimes(0, 2);
+            try writer.splatByteAll(0, 2);
         }
         try Compiler.writeDataPadding(writer, data_size);
     }

lib/compiler/resinator/cvtres.zig

@@ -188,7 +188,7 @@ pub const Diagnostics = union {
     overflow_resource: usize,
 };
 
-pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resource, options: CoffOptions, diagnostics: ?*Diagnostics) !void {
+pub fn writeCoff(allocator: Allocator, writer: *std.Io.Writer, resources: []const Resource, options: CoffOptions, diagnostics: ?*Diagnostics) !void {
     var resource_tree = ResourceTree.init(allocator, options);
     defer resource_tree.deinit();
 
@@ -232,7 +232,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
         .flags = flags,
     };
 
-    try writer.writeStructEndian(coff_header, .little);
+    try writer.writeStruct(coff_header, .little);
 
     const rsrc01_header = std.coff.SectionHeader{
         .name = ".rsrc$01".*,
@@ -250,7 +250,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
             .MEM_READ = 1,
         },
     };
-    try writer.writeStructEndian(rsrc01_header, .little);
+    try writer.writeStruct(rsrc01_header, .little);
 
     const rsrc02_header = std.coff.SectionHeader{
         .name = ".rsrc$02".*,
@@ -268,7 +268,7 @@ pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resou
             .MEM_READ = 1,
         },
     };
-    try writer.writeStructEndian(rsrc02_header, .little);
+    try writer.writeStruct(rsrc02_header, .little);
 
     // TODO: test surrogate pairs
     try resource_tree.sort();
@@ -665,13 +665,13 @@ const ResourceTree = struct {
     pub fn writeCoff(
         self: *const ResourceTree,
         allocator: Allocator,
-        w: anytype,
+        w: *std.Io.Writer,
         resources_in_data_order: []const Resource,
         lengths: Lengths,
         coff_string_table: *StringTable,
     ) ![]const std.coff.Symbol {
         if (self.type_to_name_map.count() == 0) {
-            try w.writeByteNTimes(0, 16);
+            try w.splatByteAll(0, 16);
             return &.{};
         }
 
@@ -710,7 +710,7 @@ const ResourceTree = struct {
                 .number_of_id_entries = counts.ids,
                 .number_of_name_entries = counts.names,
             };
-            try w.writeStructEndian(table, .little);
+            try w.writeStruct(table, .little);
 
             var it = self.type_to_name_map.iterator();
             while (it.next()) |entry| {
@@ -745,7 +745,7 @@ const ResourceTree = struct {
                 .number_of_id_entries = counts.ids,
                 .number_of_name_entries = counts.names,
             };
-            try w.writeStructEndian(table, .little);
+            try w.writeStruct(table, .little);
 
             var it = name_to_lang_map.iterator();
             while (it.next()) |entry| {
@@ -786,7 +786,7 @@ const ResourceTree = struct {
                 .number_of_id_entries = counts.ids,
                 .number_of_name_entries = counts.names,
             };
-            try w.writeStructEndian(table, .little);
+            try w.writeStruct(table, .little);
 
             var it = lang_to_resources_map.iterator();
             while (it.next()) |entry| {
@@ -819,7 +819,7 @@ const ResourceTree = struct {
                 .size = @intCast(orig_resource.data.len),
                 .codepage = 0,
             };
-            try w.writeStructEndian(data_entry, .little);
+            try w.writeStruct(data_entry, .little);
         }
 
         for (self.rsrc_string_table.keys()) |v| {
@@ -828,7 +828,7 @@ const ResourceTree = struct {
             try w.writeAll(std.mem.sliceAsBytes(str));
         }
 
-        try w.writeByteNTimes(0, lengths.padding);
+        try w.splatByteAll(0, lengths.padding);
 
         for (relocations.list.items) |relocation| {
             try writeRelocation(w, std.coff.Relocation{
@@ -842,13 +842,13 @@ const ResourceTree = struct {
             for (self.deduplicated_data.keys()) |data| {
                 const padding_bytes: u4 = @intCast((8 -% data.len) % 8);
                 try w.writeAll(data);
-                try w.writeByteNTimes(0, padding_bytes);
+                try w.splatByteAll(0, padding_bytes);
             }
         } else {
             for (resources_in_data_order) |resource| {
                 const padding_bytes: u4 = @intCast((8 -% resource.data.len) % 8);
                 try w.writeAll(resource.data);
-                try w.writeByteNTimes(0, padding_bytes);
+                try w.splatByteAll(0, padding_bytes);
             }
         }
 

lib/compiler/resinator/main.zig

@@ -248,10 +248,11 @@ pub fn main() !void {
                 var diagnostics = Diagnostics.init(allocator);
                 defer diagnostics.deinit();
 
-                const res_stream_writer = res_stream.source.writer(allocator);
-                var output_buffered_stream = std.io.bufferedWriter(res_stream_writer);
+                var output_buffer: [4096]u8 = undefined;
+                var res_stream_writer = res_stream.source.writer(allocator).adaptToNewApi(&output_buffer);
+                const output_buffered_stream = &res_stream_writer.new_interface;
 
-                compile(allocator, final_input, output_buffered_stream.writer(), .{
+                compile(allocator, final_input, output_buffered_stream, .{
                     .cwd = std.fs.cwd(),
                     .diagnostics = &diagnostics,
                     .source_mappings = &mapping_results.mappings,
@@ -340,10 +341,11 @@ pub fn main() !void {
     };
     defer coff_stream.deinit(allocator);
 
-    var coff_output_buffered_stream = std.io.bufferedWriter(coff_stream.source.writer(allocator));
+    var coff_output_buffer: [4096]u8 = undefined;
+    var coff_output_buffered_stream = coff_stream.source.writer(allocator).adaptToNewApi(&coff_output_buffer);
 
     var cvtres_diagnostics: cvtres.Diagnostics = .{ .none = {} };
-    cvtres.writeCoff(allocator, coff_output_buffered_stream.writer(), resources.list.items, options.coff_options, &cvtres_diagnostics) catch |err| {
+    cvtres.writeCoff(allocator, &coff_output_buffered_stream.new_interface, resources.list.items, options.coff_options, &cvtres_diagnostics) catch |err| {
         switch (err) {
             error.DuplicateResource => {
                 const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
@@ -380,7 +382,7 @@ pub fn main() !void {
         std.process.exit(1);
     };
 
-    try coff_output_buffered_stream.flush();
+    try coff_output_buffered_stream.new_interface.flush();
 }
 
 const IoStream = struct {