Merge pull request #24523 from ziglang/fifno

std.tar: update to new I/O API

Author: andrewrk

CMakeLists.txt

@@ -390,15 +390,6 @@ set(ZIG_STAGE2_SOURCES
     lib/std/Io.zig
     lib/std/Io/Reader.zig
     lib/std/Io/Writer.zig
-    lib/std/Io/buffered_atomic_file.zig
-    lib/std/Io/buffered_writer.zig
-    lib/std/Io/change_detection_stream.zig
-    lib/std/Io/counting_reader.zig
-    lib/std/Io/counting_writer.zig
-    lib/std/Io/find_byte_writer.zig
-    lib/std/Io/fixed_buffer_stream.zig
-    lib/std/Io/limited_reader.zig
-    lib/std/Io/seekable_stream.zig
     lib/std/Progress.zig
     lib/std/Random.zig
     lib/std/Target.zig

lib/compiler/std-docs.zig

@@ -60,7 +60,9 @@ pub fn main() !void {
     const should_open_browser = force_open_browser orelse (listen_port == 0);
 
     const address = std.net.Address.parseIp("127.0.0.1", listen_port) catch unreachable;
-    var http_server = try address.listen(.{});
+    var http_server = try address.listen(.{
+        .reuse_address = true,
+    });
     const port = http_server.listen_address.in.getPort();
     const url_with_newline = try std.fmt.allocPrint(arena, "http://127.0.0.1:{d}/\n", .{port});
     std.fs.File.stdout().writeAll(url_with_newline) catch {};
@@ -189,7 +191,11 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
     var walker = try std_dir.walk(gpa);
     defer walker.deinit();
 
-    var archiver = std.tar.writer(response.writer());
+    var adapter_buffer: [500]u8 = undefined;
+    var response_writer = response.writer().adaptToNewApi();
+    response_writer.new_interface.buffer = &adapter_buffer;
+
+    var archiver: std.tar.Writer = .{ .underlying_writer = &response_writer.new_interface };
     archiver.prefix = "std";
 
     while (try walker.next()) |entry| {
@@ -204,7 +210,13 @@ fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
         }
         var file = try entry.dir.openFile(entry.basename, .{});
         defer file.close();
-        try archiver.writeFile(entry.path, file);
+        const stat = try file.stat();
+        var file_reader: std.fs.File.Reader = .{
+            .file = file,
+            .interface = std.fs.File.Reader.initInterface(&.{}),
+            .size = stat.size,
+        };
+        try archiver.writeFile(entry.path, &file_reader, stat.mtime);
     }
 
     {

lib/docs/wasm/main.zig

@@ -772,10 +772,10 @@ export fn decl_type_html(decl_index: Decl.Index) String {
 const Oom = error{OutOfMemory};
 
 fn unpackInner(tar_bytes: []u8) !void {
-    var fbs = std.io.fixedBufferStream(tar_bytes);
+    var reader: std.Io.Reader = .fixed(tar_bytes);
     var file_name_buffer: [1024]u8 = undefined;
     var link_name_buffer: [1024]u8 = undefined;
-    var it = std.tar.iterator(fbs.reader(), .{
+    var it: std.tar.Iterator = .init(&reader, .{
         .file_name_buffer = &file_name_buffer,
         .link_name_buffer = &link_name_buffer,
     });
@@ -796,7 +796,7 @@ fn unpackInner(tar_bytes: []u8) !void {
                         {
                             gop.value_ptr.* = file;
                         }
-                        const file_bytes = tar_bytes[fbs.pos..][0..@intCast(tar_file.size)];
+                        const file_bytes = tar_bytes[reader.seek..][0..@intCast(tar_file.size)];
                         assert(file == try Walk.add_file(file_name, file_bytes));
                     }
                 } else {

lib/std/Build/Fuzz/WebServer.zig

@@ -522,21 +522,24 @@ fn serveSourcesTar(ws: *WebServer, request: *std.http.Server.Request) !void {
 
     var cwd_cache: ?[]const u8 = null;
 
-    var archiver = std.tar.writer(response.writer());
+    var adapter = response.writer().adaptToNewApi();
+    var archiver: std.tar.Writer = .{ .underlying_writer = &adapter.new_interface };
+    var read_buffer: [1024]u8 = undefined;
 
     for (deduped_paths) |joined_path| {
         var file = joined_path.root_dir.handle.openFile(joined_path.sub_path, .{}) catch |err| {
             log.err("failed to open {f}: {s}", .{ joined_path, @errorName(err) });
             continue;
         };
         defer file.close();
-
+        const stat = try file.stat();
+        var file_reader: std.fs.File.Reader = .initSize(file, &read_buffer, stat.size);
         archiver.prefix = joined_path.root_dir.path orelse try memoizedCwd(arena, &cwd_cache);
-        try archiver.writeFile(joined_path.sub_path, file);
+        try archiver.writeFile(joined_path.sub_path, &file_reader, stat.mtime);
     }
 
-    // intentionally omitting the pointless trailer
-    //try archiver.finish();
+    // intentionally not calling `archiver.finishPedantically`
+    try adapter.new_interface.flush();
     try response.end();
 }
 

lib/std/Io.zig

@@ -314,11 +314,11 @@ pub fn GenericReader(
         }
 
         /// Helper for bridging to the new `Reader` API while upgrading.
-        pub fn adaptToNewApi(self: *const Self) Adapter {
+        pub fn adaptToNewApi(self: *const Self, buffer: []u8) Adapter {
             return .{
                 .derp_reader = self.*,
                 .new_interface = .{
-                    .buffer = &.{},
+                    .buffer = buffer,
                     .vtable = &.{ .stream = Adapter.stream },
                     .seek = 0,
                     .end = 0,
@@ -334,10 +334,12 @@ pub fn GenericReader(
             fn stream(r: *Reader, w: *Writer, limit: Limit) Reader.StreamError!usize {
                 const a: *@This() = @alignCast(@fieldParentPtr("new_interface", r));
                 const buf = limit.slice(try w.writableSliceGreedy(1));
-                return a.derp_reader.read(buf) catch |err| {
+                const n = a.derp_reader.read(buf) catch |err| {
                     a.err = err;
                     return error.ReadFailed;
                 };
+                w.advance(n);
+                return n;
             }
         };
     };
@@ -419,9 +421,14 @@ pub fn GenericWriter(
             new_interface: Writer,
             err: ?Error = null,
 
-            fn drain(w: *Writer, data: []const []const u8, splat: usize) Writer.Error!usize {
+            fn drain(w: *std.io.Writer, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {
                 _ = splat;
                 const a: *@This() = @alignCast(@fieldParentPtr("new_interface", w));
+                const buffered = w.buffered();
+                if (buffered.len != 0) return w.consume(a.derp_writer.write(buffered) catch |err| {
+                    a.err = err;
+                    return error.WriteFailed;
+                });
                 return a.derp_writer.write(data[0]) catch |err| {
                     a.err = err;
                     return error.WriteFailed;
@@ -435,54 +442,46 @@ pub fn GenericWriter(
 pub const AnyReader = @import("Io/DeprecatedReader.zig");
 /// Deprecated in favor of `Writer`.
 pub const AnyWriter = @import("Io/DeprecatedWriter.zig");
-
+/// Deprecated in favor of `File.Reader` and `File.Writer`.
 pub const SeekableStream = @import("Io/seekable_stream.zig").SeekableStream;
-
+/// Deprecated in favor of `Writer`.
 pub const BufferedWriter = @import("Io/buffered_writer.zig").BufferedWriter;
+/// Deprecated in favor of `Writer`.
 pub const bufferedWriter = @import("Io/buffered_writer.zig").bufferedWriter;
-
+/// Deprecated in favor of `Reader`.
 pub const BufferedReader = @import("Io/buffered_reader.zig").BufferedReader;
+/// Deprecated in favor of `Reader`.
 pub const bufferedReader = @import("Io/buffered_reader.zig").bufferedReader;
+/// Deprecated in favor of `Reader`.
 pub const bufferedReaderSize = @import("Io/buffered_reader.zig").bufferedReaderSize;
-
+/// Deprecated in favor of `Reader`.
 pub const FixedBufferStream = @import("Io/fixed_buffer_stream.zig").FixedBufferStream;
+/// Deprecated in favor of `Reader`.
 pub const fixedBufferStream = @import("Io/fixed_buffer_stream.zig").fixedBufferStream;
-
-pub const CWriter = @import("Io/c_writer.zig").CWriter;
-pub const cWriter = @import("Io/c_writer.zig").cWriter;
-
+/// Deprecated in favor of `Reader.Limited`.
 pub const LimitedReader = @import("Io/limited_reader.zig").LimitedReader;
+/// Deprecated in favor of `Reader.Limited`.
 pub const limitedReader = @import("Io/limited_reader.zig").limitedReader;
-
+/// Deprecated with no replacement; inefficient pattern
 pub const CountingWriter = @import("Io/counting_writer.zig").CountingWriter;
+/// Deprecated with no replacement; inefficient pattern
 pub const countingWriter = @import("Io/counting_writer.zig").countingWriter;
+/// Deprecated with no replacement; inefficient pattern
 pub const CountingReader = @import("Io/counting_reader.zig").CountingReader;
+/// Deprecated with no replacement; inefficient pattern
 pub const countingReader = @import("Io/counting_reader.zig").countingReader;
 
-pub const MultiWriter = @import("Io/multi_writer.zig").MultiWriter;
-pub const multiWriter = @import("Io/multi_writer.zig").multiWriter;
-
 pub const BitReader = @import("Io/bit_reader.zig").BitReader;
 pub const bitReader = @import("Io/bit_reader.zig").bitReader;
 
 pub const BitWriter = @import("Io/bit_writer.zig").BitWriter;
 pub const bitWriter = @import("Io/bit_writer.zig").bitWriter;
 
-pub const ChangeDetectionStream = @import("Io/change_detection_stream.zig").ChangeDetectionStream;
-pub const changeDetectionStream = @import("Io/change_detection_stream.zig").changeDetectionStream;
-
-pub const FindByteWriter = @import("Io/find_byte_writer.zig").FindByteWriter;
-pub const findByteWriter = @import("Io/find_byte_writer.zig").findByteWriter;
-
-pub const BufferedAtomicFile = @import("Io/buffered_atomic_file.zig").BufferedAtomicFile;
-
-pub const StreamSource = @import("Io/stream_source.zig").StreamSource;
-
 pub const tty = @import("Io/tty.zig");
 
-/// A Writer that doesn't write to anything.
+/// Deprecated in favor of `Writer.Discarding`.
 pub const null_writer: NullWriter = .{ .context = {} };
-
+/// Deprecated in favor of `Writer.Discarding`.
 pub const NullWriter = GenericWriter(void, error{}, dummyWrite);
 fn dummyWrite(context: void, data: []const u8) error{}!usize {
     _ = context;
@@ -898,16 +897,14 @@ test {
     _ = Reader;
     _ = Reader.Limited;
     _ = Writer;
-    _ = @import("Io/bit_reader.zig");
-    _ = @import("Io/bit_writer.zig");
-    _ = @import("Io/buffered_atomic_file.zig");
-    _ = @import("Io/buffered_reader.zig");
-    _ = @import("Io/buffered_writer.zig");
-    _ = @import("Io/c_writer.zig");
-    _ = @import("Io/counting_writer.zig");
-    _ = @import("Io/counting_reader.zig");
-    _ = @import("Io/fixed_buffer_stream.zig");
-    _ = @import("Io/seekable_stream.zig");
-    _ = @import("Io/stream_source.zig");
+    _ = BitReader;
+    _ = BitWriter;
+    _ = BufferedReader;
+    _ = BufferedWriter;
+    _ = CountingWriter;
+    _ = CountingReader;
+    _ = FixedBufferStream;
+    _ = SeekableStream;
+    _ = tty;
     _ = @import("Io/test.zig");
 }

lib/std/Io/DeprecatedReader.zig

@@ -393,10 +393,12 @@ pub const Adapter = struct {
     fn stream(r: *std.io.Reader, w: *std.io.Writer, limit: std.io.Limit) std.io.Reader.StreamError!usize {
         const a: *@This() = @alignCast(@fieldParentPtr("new_interface", r));
         const buf = limit.slice(try w.writableSliceGreedy(1));
-        return a.derp_reader.read(buf) catch |err| {
+        const n = a.derp_reader.read(buf) catch |err| {
             a.err = err;
             return error.ReadFailed;
         };
+        w.advance(n);
+        return n;
     }
 };
 

lib/std/Io/DeprecatedWriter.zig

@@ -100,7 +100,12 @@ pub const Adapter = struct {
 
     fn drain(w: *std.io.Writer, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {
         _ = splat;
-        const a: *@This() = @fieldParentPtr("new_interface", w);
+        const a: *@This() = @alignCast(@fieldParentPtr("new_interface", w));
+        const buffered = w.buffered();
+        if (buffered.len != 0) return w.consume(a.derp_writer.write(buffered) catch |err| {
+            a.err = err;
+            return error.WriteFailed;
+        });
         return a.derp_writer.write(data[0]) catch |err| {
             a.err = err;
             return error.WriteFailed;

lib/std/Io/Reader.zig

@@ -179,6 +179,12 @@ pub fn streamExact(r: *Reader, w: *Writer, n: usize) StreamError!void {
     while (remaining != 0) remaining -= try r.stream(w, .limited(remaining));
 }
 
+/// "Pump" exactly `n` bytes from the reader to the writer.
+pub fn streamExact64(r: *Reader, w: *Writer, n: u64) StreamError!void {
+    var remaining = n;
+    while (remaining != 0) remaining -= try r.stream(w, .limited64(remaining));
+}
+
 /// "Pump" data from the reader to the writer, handling `error.EndOfStream` as
 /// a success case.
 ///