Commit ffb0e283d7aaaa896cd3db32ca11460ea63c8855 | zig

lib/compiler/build_runner.zig+15-17

 @@ -379,9 +379,11 @@ pub fn main() !void {
     validateSystemLibraryOptions(builder);
     {
-        var stdout_bw = std.fs.File.stdout().writer().buffered(&stdio_buffer);
+        var fw = std.fs.File.stdout().writer();
-        if (help_menu) return usage(builder, &stdout_bw);
+        var bw = fw.interface().buffered(&stdio_buffer);
-        if (steps_menu) return steps(builder, &stdout_bw);
+        defer bw.flush() catch {};
+        if (help_menu) return usage(builder, &bw);
+        if (steps_menu) return steps(builder, &bw);
     }
     var run: Run = .{
 @@ -694,16 +696,13 @@ fn runStepNames(
     const ttyconf = run.ttyconf;
     if (run.summary != .none) {
-        var bw = std.debug.lockStdErr2(&stdio_buffer);
+        const bw = std.debug.lockStderrWriter(&stdio_buffer);
-        defer {
+        defer std.debug.unlockStderrWriter();
-            bw.flush() catch {};
-            std.debug.unlockStdErr();
-        }
         const total_count = success_count + failure_count + pending_count + skipped_count;
-        ttyconf.setColor(&bw, .cyan) catch {};
+        ttyconf.setColor(bw, .cyan) catch {};
         bw.writeAll("Build Summary:") catch {};
-        ttyconf.setColor(&bw, .reset) catch {};
+        ttyconf.setColor(bw, .reset) catch {};
         bw.print(" {d}/{d} steps succeeded", .{ success_count, total_count }) catch {};
         if (skipped_count > 0) bw.print("; {d} skipped", .{skipped_count}) catch {};
         if (failure_count > 0) bw.print("; {d} failed", .{failure_count}) catch {};
 @@ -713,8 +712,6 @@ fn runStepNames(
         if (test_fail_count > 0) bw.print("; {d} failed", .{test_fail_count}) catch {};
         if (test_leak_count > 0) bw.print("; {d} leaked", .{test_leak_count}) catch {};
-        bw.writeByte('\n') catch {};
         // Print a fancy tree with build results.
         var step_stack_copy = try step_stack.clone(gpa);
         defer step_stack_copy.deinit(gpa);
 @@ -722,7 +719,7 @@ fn runStepNames(
         var print_node: PrintNode = .{ .parent = null };
         if (step_names.len == 0) {
             print_node.last = true;
-            printTreeStep(b, b.default_step, run, &bw, ttyconf, &print_node, &step_stack_copy) catch {};
+            printTreeStep(b, b.default_step, run, bw, ttyconf, &print_node, &step_stack_copy) catch {};
         } else {
             const last_index = if (run.summary == .all) b.top_level_steps.count() else blk: {
                 var i: usize = step_names.len;
 @@ -741,9 +738,10 @@ fn runStepNames(
             for (step_names, 0..) |step_name, i| {
                 const tls = b.top_level_steps.get(step_name).?;
                 print_node.last = i + 1 == last_index;
-                printTreeStep(b, &tls.step, run, &bw, ttyconf, &print_node, &step_stack_copy) catch {};
+                printTreeStep(b, &tls.step, run, bw, ttyconf, &print_node, &step_stack_copy) catch {};
             }
         }
+        bw.writeByte('\n') catch {};
     }
     if (failure_count == 0) {
 @@ -1129,11 +1127,11 @@ fn workerMakeOneStep(
     const show_stderr = s.result_stderr.len > 0;
     if (show_error_msgs or show_compile_errors or show_stderr) {
-        var bw = std.debug.lockStdErr2(&stdio_buffer);
+        const bw = std.debug.lockStderrWriter(&stdio_buffer);
-        defer std.debug.unlockStdErr();
+        defer std.debug.unlockStderrWriter();
         const gpa = b.allocator;
-        printErrorMessages(gpa, s, .{ .ttyconf = run.ttyconf }, &bw, run.prominent_compile_errors) catch {};
+        printErrorMessages(gpa, s, .{ .ttyconf = run.ttyconf }, bw, run.prominent_compile_errors) catch {};
     }
     handle_result: {

lib/std/Build.zig+11-11

...	@@ -2766,7 +2766,7 @@ fn dumpBadDirnameHelp(	...	@@ -2766,7 +2766,7 @@ fn dumpBadDirnameHelp(
2766	comptime msg: []const u8,	2766	comptime msg: []const u8,
2767	args: anytype,	2767	args: anytype,
2768	) anyerror!void {	2768	) anyerror!void {
2769	const w = debug.lockStderrWriter();	2769	const w = debug.lockStderrWriter(&.{});
2770	defer debug.unlockStderrWriter();	2770	defer debug.unlockStderrWriter();
2771		2771
2772	const stderr: fs.File = .stderr();	2772	const stderr: fs.File = .stderr();
...	@@ -2802,9 +2802,9 @@ pub fn dumpBadGetPathHelp(	...	@@ -2802,9 +2802,9 @@ pub fn dumpBadGetPathHelp(
2802	src_builder: *Build,	2802	src_builder: *Build,
2803	asking_step: ?*Step,	2803	asking_step: ?*Step,
2804	) anyerror!void {	2804	) anyerror!void {
2805	var buffered_writer = stderr.writer().unbuffered();	2805	var fw = stderr.writer();
2806	const w = &buffered_writer;	2806	var bw = fw.interface().unbuffered();
2807	try w.print(	2807	try bw.print(
2808	\\getPath() was called on a GeneratedFile that wasn't built yet.	2808	\\getPath() was called on a GeneratedFile that wasn't built yet.
2809	\\ source package path: {s}	2809	\\ source package path: {s}
2810	\\ Is there a missing Step dependency on step '{s}'?	2810	\\ Is there a missing Step dependency on step '{s}'?
...	@@ -2815,21 +2815,21 @@ pub fn dumpBadGetPathHelp(	...	@@ -2815,21 +2815,21 @@ pub fn dumpBadGetPathHelp(
2815	});	2815	});
2816		2816
2817	const tty_config = std.io.tty.detectConfig(stderr);	2817	const tty_config = std.io.tty.detectConfig(stderr);
2818	tty_config.setColor(w, .red) catch {};	2818	tty_config.setColor(&bw, .red) catch {};
2819	try stderr.writeAll(" The step was created by this stack trace:\n");	2819	try stderr.writeAll(" The step was created by this stack trace:\n");
2820	tty_config.setColor(w, .reset) catch {};	2820	tty_config.setColor(&bw, .reset) catch {};
2821		2821
2822	s.dump(stderr);	2822	s.dump(stderr);
2823	if (asking_step) \|as\| {	2823	if (asking_step) \|as\| {
2824	tty_config.setColor(w, .red) catch {};	2824	tty_config.setColor(&bw, .red) catch {};
2825	try w.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});	2825	try bw.print(" The step '{s}' that is missing a dependency on the above step was created by this stack trace:\n", .{as.name});
2826	tty_config.setColor(w, .reset) catch {};	2826	tty_config.setColor(&bw, .reset) catch {};
2827		2827
2828	as.dump(stderr);	2828	as.dump(stderr);
2829	}	2829	}
2830	tty_config.setColor(w, .red) catch {};	2830	tty_config.setColor(&bw, .red) catch {};
2831	try stderr.writeAll(" Hope that helps. Proceeding to panic.\n");	2831	try stderr.writeAll(" Hope that helps. Proceeding to panic.\n");
2832	tty_config.setColor(w, .reset) catch {};	2832	tty_config.setColor(&bw, .reset) catch {};
2833	}	2833	}
2834		2834
2835	pub const InstallDir = union(enum) {	2835	pub const InstallDir = union(enum) {

lib/std/Build/Cache.zig+4-3

lib/std/Build/Fuzz.zig+2-2

...	@@ -124,7 +124,7 @@ fn rebuildTestsWorkerRunFallible(run: *Step.Run, ttyconf: std.io.tty.Config, par	...	@@ -124,7 +124,7 @@ fn rebuildTestsWorkerRunFallible(run: *Step.Run, ttyconf: std.io.tty.Config, par
124	const show_stderr = compile.step.result_stderr.len > 0;	124	const show_stderr = compile.step.result_stderr.len > 0;
125		125
126	if (show_error_msgs or show_compile_errors or show_stderr) {	126	if (show_error_msgs or show_compile_errors or show_stderr) {
127	const bw = std.debug.lockStderrWriter();	127	const bw = std.debug.lockStderrWriter(&.{});
128	defer std.debug.unlockStderrWriter();	128	defer std.debug.unlockStderrWriter();
129	build_runner.printErrorMessages(gpa, &compile.step, .{ .ttyconf = ttyconf }, bw, false) catch {};	129	build_runner.printErrorMessages(gpa, &compile.step, .{ .ttyconf = ttyconf }, bw, false) catch {};
130	}	130	}
...	@@ -151,7 +151,7 @@ fn fuzzWorkerRun(	...	@@ -151,7 +151,7 @@ fn fuzzWorkerRun(
151		151
152	run.rerunInFuzzMode(web_server, unit_test_index, prog_node) catch \|err\| switch (err) {	152	run.rerunInFuzzMode(web_server, unit_test_index, prog_node) catch \|err\| switch (err) {
153	error.MakeFailed => {	153	error.MakeFailed => {
154	const bw = std.debug.lockStderrWriter();	154	const bw = std.debug.lockStderrWriter(&.{});
155	defer std.debug.unlockStderrWriter();	155	defer std.debug.unlockStderrWriter();
156	build_runner.printErrorMessages(gpa, &run.step, .{ .ttyconf = ttyconf }, bw, false) catch {};	156	build_runner.printErrorMessages(gpa, &run.step, .{ .ttyconf = ttyconf }, bw, false) catch {};
157	return;	157	return;

lib/std/Build/Fuzz/WebServer.zig+10-2

...	@@ -98,8 +98,16 @@ fn now(s: *const WebServer) i64 {	...	@@ -98,8 +98,16 @@ fn now(s: *const WebServer) i64 {
98	fn accept(ws: *WebServer, connection: std.net.Server.Connection) void {	98	fn accept(ws: *WebServer, connection: std.net.Server.Connection) void {
99	defer connection.stream.close();	99	defer connection.stream.close();
100		100
101	var read_buffer: [0x4000]u8 = undefined;	101	var sr = connection.stream.reader();
102	var server = std.http.Server.init(connection, &read_buffer);	102	var rb: [0x4000]u8 = undefined;
		103	var br: std.io.BufferedReader = undefined;
		104	br.init(sr.interface(), &rb);
		105
		106	var sw = connection.stream.writer();
		107	var wb: [0x4000]u8 = undefined;
		108	var bw = sw.interface().buffered(&wb);
		109
		110	var server: std.http.Server = .init(&br, &bw);
103	var web_socket: std.http.WebSocket = undefined;	111	var web_socket: std.http.WebSocket = undefined;
104	var send_buffer: [0x4000]u8 = undefined;	112	var send_buffer: [0x4000]u8 = undefined;
105	var ws_recv_buffer: [0x4000]u8 align(4) = undefined;	113	var ws_recv_buffer: [0x4000]u8 align(4) = undefined;

lib/std/Build/Step.zig+6-5

 @@ -287,7 +287,8 @@ pub fn cast(step: *Step, comptime T: type) ?*T {
 /// For debugging purposes, prints identifying information about this Step.
 pub fn dump(step: *Step, file: std.fs.File) void {
-    var bw = file.writer().unbuffered();
+    var fw = file.writer();
+    var bw = fw.interface().unbuffered();
     const tty_config = std.io.tty.detectConfig(file);
     const debug_info = std.debug.getSelfDebugInfo() catch |err| {
         bw.print("Unable to dump stack trace: Unable to open debug info: {s}\n", .{
 @@ -469,7 +470,7 @@ pub fn evalZigProcess(
     // This is intentionally printed for failure on the first build but not for
     // subsequent rebuilds.
     if (s.result_error_bundle.errorMessageCount() > 0) {
-        return s.fail("the following command failed with {d} compilation errors:\n{s}\n", .{
+        return s.fail("the following command failed with {d} compilation errors:\n{s}", .{
             s.result_error_bundle.errorMessageCount(),
             try allocPrintCmd(arena, null, argv),
         });
 @@ -689,7 +690,7 @@ pub inline fn handleChildProcUnsupported(
 ) error{ OutOfMemory, MakeFailed }!void {
     if (!std.process.can_spawn) {
         return s.fail(
-            "unable to execute the following command: host cannot spawn child processes\n{s}\n",
+            "unable to execute the following command: host cannot spawn child processes\n{s}",
             .{try allocPrintCmd(s.owner.allocator, opt_cwd, argv)},
         );
     }
 @@ -706,14 +707,14 @@ pub fn handleChildProcessTerm(
         .Exited => |code| {
             if (code != 0) {
                 return s.fail(
-                    "the following command exited with error code {d}:\n{s}\n",
+                    "the following command exited with error code {d}:\n{s}",
                     .{ code, try allocPrintCmd(arena, opt_cwd, argv) },
                 );
             }
         },
         .Signal, .Stopped, .Unknown => {
             return s.fail(
-                "the following command terminated unexpectedly:\n{s}\n",
+                "the following command terminated unexpectedly:\n{s}",
                 .{try allocPrintCmd(arena, opt_cwd, argv)},
             );
         },

lib/std/Build/Step/CheckObject.zig+1-1

...	@@ -1791,7 +1791,7 @@ const ElfDumper = struct {	...	@@ -1791,7 +1791,7 @@ const ElfDumper = struct {
1791	.p64 => @sizeOf(u64),	1791	.p64 => @sizeOf(u64),
1792	};	1792	};
1793	try br.discard(num * ptr_size);	1793	try br.discard(num * ptr_size);
1794	const strtab = try br.peekAll(0);	1794	const strtab = try br.peekGreedy(0);
1795		1795
1796	assert(ctx.symtab.len == 0);	1796	assert(ctx.symtab.len == 0);
1797	ctx.symtab = try ctx.gpa.alloc(ArSymtabEntry, num);	1797	ctx.symtab = try ctx.gpa.alloc(ArSymtabEntry, num);

lib/std/Build/Step/Run.zig+14-7

 @@ -73,9 +73,12 @@ skip_foreign_checks: bool,
 /// external executor (such as qemu) but not fail if the executor is unavailable.
 failing_to_execute_foreign_is_an_error: bool,
+/// Deprecated for `stdio_limit`.
+max_stdio_size: usize,
 /// If stderr or stdout exceeds this amount, the child process is killed and
 /// the step fails.
-max_stdio_size: usize,
+stdio_limit: std.io.Reader.Limit,
 captured_stdout: ?*Output,
 captured_stderr: ?*Output,
 @@ -186,6 +189,7 @@ pub fn create(owner: *std.Build, name: []const u8) *Run {
         .skip_foreign_checks = false,
         .failing_to_execute_foreign_is_an_error = true,
         .max_stdio_size = 10 * 1024 * 1024,
+        .stdio_limit = .unlimited,
         .captured_stdout = null,
         .captured_stderr = null,
         .dep_output_file = null,
 @@ -1772,6 +1776,7 @@ fn evalGeneric(run: *Run, child: *std.process.Child) !StdIoResult {
     var stdout_bytes: ?[]const u8 = null;
     var stderr_bytes: ?[]const u8 = null;
+    run.stdio_limit = .limited(run.stdio_limit.min(run.max_stdio_size));
     if (child.stdout) |stdout| {
         if (child.stderr) |stderr| {
             var poller = std.io.poll(arena, enum { stdout, stderr }, .{
 @@ -1781,19 +1786,21 @@ fn evalGeneric(run: *Run, child: *std.process.Child) !StdIoResult {
             defer poller.deinit();
             while (try poller.poll()) {
-                if (poller.fifo(.stdout).count > run.max_stdio_size)
+                if (run.stdio_limit.toInt()) |limit| {
-                    return error.StdoutStreamTooLong;
+                    if (poller.fifo(.stderr).count > limit)
-                if (poller.fifo(.stderr).count > run.max_stdio_size)
+                        return error.StdoutStreamTooLong;
-                    return error.StderrStreamTooLong;
+                    if (poller.fifo(.stderr).count > limit)
+                        return error.StderrStreamTooLong;
+                }
             }
             stdout_bytes = try poller.fifo(.stdout).toOwnedSlice();
             stderr_bytes = try poller.fifo(.stderr).toOwnedSlice();
         } else {
-            stdout_bytes = try stdout.reader().readAlloc(arena, run.max_stdio_size);
+            stdout_bytes = try stdout.readToEndAlloc(arena, run.stdio_limit);
         }
     } else if (child.stderr) |stderr| {
-        stderr_bytes = try stderr.reader().readAlloc(arena, run.max_stdio_size);
+        stderr_bytes = try stderr.readToEndAlloc(arena, run.stdio_limit);
     }
     if (stderr_bytes) |bytes| if (bytes.len > 0) {

lib/std/crypto/siphash.zig+32-7

...	@@ -239,16 +239,41 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)	...	@@ -239,16 +239,41 @@ fn SipHash(comptime T: type, comptime c_rounds: usize, comptime d_rounds: usize)
239	return State.hash(msg, key);	239	return State.hash(msg, key);
240	}	240	}
241		241
242	pub const Error = error{};	242	pub fn writer(self: *Self) std.io.Writer {
243	pub const Writer = std.io.Writer(*Self, Error, write);	243	return .{
		244	.context = self,
		245	.vtable = &.{
		246	.writeSplat = &writeSplat,
		247	.writeFile = &writeFile,
		248	},
		249	};
		250	}
244		251
245	fn write(self: *Self, bytes: []const u8) Error!usize {	252	fn writeSplat(ctx: ?*anyopaque, data: []const []const u8, splat: usize) anyerror!usize {
246	self.update(bytes);	253	const self: *Self = @alignCast(@ptrCast(ctx));
247	return bytes.len;	254	var len: usize = 0;
		255	for (0..splat) \|_\| for (data) \|slice\| {
		256	self.update(slice);
		257	len += slice.len;
		258	};
		259	return len;
248	}	260	}
249		261
250	pub fn writer(self: *Self) Writer {	262	fn writeFile(
251	return .{ .context = self };	263	ctx: ?*anyopaque,
		264	file: std.fs.File,
		265	offset: std.io.Writer.Offset,
		266	limit: std.io.Writer.Limit,
		267	headers_and_trailers: []const []const u8,
		268	headers_len: usize,
		269	) anyerror!usize {
		270	_ = ctx;
		271	_ = file;
		272	_ = offset;
		273	_ = limit;
		274	_ = headers_and_trailers;
		275	_ = headers_len;
		276	return error.Unimplemented;
252	}	277	}
253	};	278	};
254	}	279	}

lib/std/fs/Dir.zig+1-1

...	@@ -2052,7 +2052,7 @@ pub fn readFileIntoArrayList(	...	@@ -2052,7 +2052,7 @@ pub fn readFileIntoArrayList(
2052	try list.ensureUnusedCapacity(gpa, std.math.cast(usize, size) orelse return error.FileTooBig);	2052	try list.ensureUnusedCapacity(gpa, std.math.cast(usize, size) orelse return error.FileTooBig);
2053	} else \|err\| switch (err) {	2053	} else \|err\| switch (err) {
2054	// Ignore most errors; size hint is only an optimization.	2054	// Ignore most errors; size hint is only an optimization.
2055	error.Unseekable, error.Unexpected, error.AccessDenied, error.PermissionDenied => {},	2055	error.Unexpected, error.AccessDenied, error.PermissionDenied => {},
2056	else => \|e\| return e,	2056	else => \|e\| return e,
2057	}	2057	}
2058		2058

lib/std/http/Client.zig+2-2

...	@@ -115,14 +115,14 @@ pub const ConnectionPool = struct {	...	@@ -115,14 +115,14 @@ pub const ConnectionPool = struct {
115	///	115	///
116	/// Threadsafe.	116	/// Threadsafe.
117	pub fn release(pool: ConnectionPool, allocator: Allocator, connection: Connection) void {	117	pub fn release(pool: ConnectionPool, allocator: Allocator, connection: Connection) void {
118	if (connection.closing) return connection.destroy(allocator);	118	if (connection.closing) return connection.destroy();
119		119
120	pool.mutex.lock();	120	pool.mutex.lock();
121	defer pool.mutex.unlock();	121	defer pool.mutex.unlock();
122		122
123	pool.used.remove(&connection.pool_node);	123	pool.used.remove(&connection.pool_node);
124		124
125	if (pool.free_size == 0) return connection.destroy(allocator);	125	if (pool.free_size == 0) return connection.destroy();
126		126
127	if (pool.free_len >= pool.free_size) {	127	if (pool.free_len >= pool.free_size) {
128	const popped: *Connection = @fieldParentPtr("pool_node", pool.free.popFirst().?);	128	const popped: *Connection = @fieldParentPtr("pool_node", pool.free.popFirst().?);

lib/std/http/Server.zig+42-30

...	@@ -21,6 +21,9 @@ out: *std.io.BufferedWriter,	...	@@ -21,6 +21,9 @@ out: *std.io.BufferedWriter,
21	state: State,	21	state: State,
22	head_parse_err: Request.Head.ParseError,	22	head_parse_err: Request.Head.ParseError,
23		23
		24	/// being deleted...
		25	next_request_start: usize = 0,
		26
24	pub const State = enum {	27	pub const State = enum {
25	/// The connection is available to be used for the first time, or reused.	28	/// The connection is available to be used for the first time, or reused.
26	ready,	29	ready,
...	@@ -45,6 +48,7 @@ pub fn init(in: std.io.BufferedReader, out: std.io.BufferedWriter) Server {	...	@@ -45,6 +48,7 @@ pub fn init(in: std.io.BufferedReader, out: std.io.BufferedWriter) Server {
45	.in = in,	48	.in = in,
46	.out = out,	49	.out = out,
47	.state = .ready,	50	.state = .ready,
		51	.head_parse_err = undefined,
48	};	52	};
49	}	53	}
50		54
...	@@ -63,7 +67,7 @@ pub const ReceiveHeadError = error{	...	@@ -63,7 +67,7 @@ pub const ReceiveHeadError = error{
63	/// In other words, a keep-alive connection was finally closed.	67	/// In other words, a keep-alive connection was finally closed.
64	HttpConnectionClosing,	68	HttpConnectionClosing,
65	/// Transitive error occurred reading from `in`.	69	/// Transitive error occurred reading from `in`.
66	ReadFailure,	70	ReadFailed,
67	};	71	};
68		72
69	/// The header bytes reference the internal storage of `in`, which are	73	/// The header bytes reference the internal storage of `in`, which are
...	@@ -73,7 +77,7 @@ pub fn receiveHead(s: *Server) ReceiveHeadError!Request {	...	@@ -73,7 +77,7 @@ pub fn receiveHead(s: *Server) ReceiveHeadError!Request {
73	s.state = .received_head;	77	s.state = .received_head;
74	errdefer s.state = .receiving_head;	78	errdefer s.state = .receiving_head;
75		79
76	const in = &s.in;	80	const in = s.in;
77	var hp: http.HeadParser = .{};	81	var hp: http.HeadParser = .{};
78	var head_end: usize = 0;	82	var head_end: usize = 0;
79		83
...	@@ -84,7 +88,7 @@ pub fn receiveHead(s: *Server) ReceiveHeadError!Request {	...	@@ -84,7 +88,7 @@ pub fn receiveHead(s: *Server) ReceiveHeadError!Request {
84	0 => return error.HttpConnectionClosing,	88	0 => return error.HttpConnectionClosing,
85	else => return error.HttpRequestTruncated,	89	else => return error.HttpRequestTruncated,
86	},	90	},
87	error.ReadFailure => return error.ReadFailure,	91	error.ReadFailed => return error.ReadFailed,
88	};	92	};
89	head_end += hp.feed(buf[head_end..]);	93	head_end += hp.feed(buf[head_end..]);
90	if (hp.state == .finished) return .{	94	if (hp.state == .finished) return .{
...	@@ -279,7 +283,7 @@ pub const Request = struct {	...	@@ -279,7 +283,7 @@ pub const Request = struct {
279	};	283	};
280		284
281	pub fn iterateHeaders(r: *Request) http.HeaderIterator {	285	pub fn iterateHeaders(r: *Request) http.HeaderIterator {
282	return http.HeaderIterator.init(r.in.bufferContents()[0..r.head_end]);	286	return http.HeaderIterator.init(r.server.in.bufferContents()[0..r.head_end]);
283	}	287	}
284		288
285	test iterateHeaders {	289	test iterateHeaders {
...	@@ -398,8 +402,7 @@ pub const Request = struct {	...	@@ -398,8 +402,7 @@ pub const Request = struct {
398	h.appendSliceAssumeCapacity("HTTP/1.1 417 Expectation Failed\r\n");	402	h.appendSliceAssumeCapacity("HTTP/1.1 417 Expectation Failed\r\n");
399	if (!keep_alive) h.appendSliceAssumeCapacity("connection: close\r\n");	403	if (!keep_alive) h.appendSliceAssumeCapacity("connection: close\r\n");
400	h.appendSliceAssumeCapacity("content-length: 0\r\n\r\n");	404	h.appendSliceAssumeCapacity("content-length: 0\r\n\r\n");
401	var w = request.server.connection.stream.writer().unbuffered();	405	try request.server.out.writeAll(h.items);
402	try w.writeAll(h.items);
403	return;	406	return;
404	}	407	}
405	h.printAssumeCapacity("{s} {d} {s}\r\n", .{	408	h.printAssumeCapacity("{s} {d} {s}\r\n", .{
...	@@ -472,8 +475,7 @@ pub const Request = struct {	...	@@ -472,8 +475,7 @@ pub const Request = struct {
472	}	475	}
473	}	476	}
474		477
475	var w = request.server.connection.stream.writer().unbuffered();	478	try request.server.out.writeVecAll(iovecs[0..iovecs_len]);
476	try w.writevAll(iovecs[0..iovecs_len]);
477	}	479	}
478		480
479	pub const RespondStreamingOptions = struct {	481	pub const RespondStreamingOptions = struct {
...	@@ -553,7 +555,7 @@ pub const Request = struct {	...	@@ -553,7 +555,7 @@ pub const Request = struct {
553	};	555	};
554		556
555	return .{	557	return .{
556	.stream = request.server.connection.stream,	558	.out = request.server.out,
557	.send_buffer = options.send_buffer,	559	.send_buffer = options.send_buffer,
558	.send_buffer_start = 0,	560	.send_buffer_start = 0,
559	.send_buffer_end = h.items.len,	561	.send_buffer_end = h.items.len,
...	@@ -577,7 +579,7 @@ pub const Request = struct {	...	@@ -577,7 +579,7 @@ pub const Request = struct {
577	ctx: ?*anyopaque,	579	ctx: ?*anyopaque,
578	bw: *std.io.BufferedWriter,	580	bw: *std.io.BufferedWriter,
579	limit: std.io.Reader.Limit,	581	limit: std.io.Reader.Limit,
580	) std.io.Reader.Error!std.io.Reader.Status {	582	) std.io.Reader.Error!usize {
581	const request: *Request = @alignCast(@ptrCast(ctx));	583	const request: *Request = @alignCast(@ptrCast(ctx));
582	_ = request;	584	_ = request;
583	_ = bw;	585	_ = bw;
...	@@ -585,13 +587,20 @@ pub const Request = struct {	...	@@ -585,13 +587,20 @@ pub const Request = struct {
585	@panic("TODO");	587	@panic("TODO");
586	}	588	}
587		589
588	fn contentLengthReader_readv(ctx: ?*anyopaque, data: []const []u8) std.io.Reader.Error!usize {	590	fn contentLengthReader_readVec(ctx: ?*anyopaque, data: []const []u8) std.io.Reader.Error!usize {
589	const request: *Request = @alignCast(@ptrCast(ctx));	591	const request: *Request = @alignCast(@ptrCast(ctx));
590	_ = request;	592	_ = request;
591	_ = data;	593	_ = data;
592	@panic("TODO");	594	@panic("TODO");
593	}	595	}
594		596
		597	fn contentLengthReader_discard(ctx: ?*anyopaque, limit: std.io.Reader.Limit) std.io.Reader.Error!usize {
		598	const request: *Request = @alignCast(@ptrCast(ctx));
		599	_ = request;
		600	_ = limit;
		601	@panic("TODO");
		602	}
		603
595	fn chunkedReader_read(	604	fn chunkedReader_read(
596	ctx: ?*anyopaque,	605	ctx: ?*anyopaque,
597	bw: *std.io.BufferedWriter,	606	bw: *std.io.BufferedWriter,
...	@@ -604,13 +613,20 @@ pub const Request = struct {	...	@@ -604,13 +613,20 @@ pub const Request = struct {
604	@panic("TODO");	613	@panic("TODO");
605	}	614	}
606		615
607	fn chunkedReader_readv(ctx: ?*anyopaque, data: []const []u8) std.io.Reader.Error!usize {	616	fn chunkedReader_readVec(ctx: ?*anyopaque, data: []const []u8) std.io.Reader.Error!usize {
608	const request: *Request = @alignCast(@ptrCast(ctx));	617	const request: *Request = @alignCast(@ptrCast(ctx));
609	_ = request;	618	_ = request;
610	_ = data;	619	_ = data;
611	@panic("TODO");	620	@panic("TODO");
612	}	621	}
613		622
		623	fn chunkedReader_discard(ctx: ?*anyopaque, limit: std.io.Reader.Limit) std.io.Reader.Error!usize {
		624	const request: *Request = @alignCast(@ptrCast(ctx));
		625	_ = request;
		626	_ = limit;
		627	@panic("TODO");
		628	}
		629
614	fn read_cl(context: *const anyopaque, buffer: []u8) ReadError!usize {	630	fn read_cl(context: *const anyopaque, buffer: []u8) ReadError!usize {
615	const request: *Request = @alignCast(@ptrCast(context));	631	const request: *Request = @alignCast(@ptrCast(context));
616	const s = request.server;	632	const s = request.server;
...	@@ -751,8 +767,7 @@ pub const Request = struct {	...	@@ -751,8 +767,7 @@ pub const Request = struct {
751		767
752	if (request.head.expect) \|expect\| {	768	if (request.head.expect) \|expect\| {
753	if (mem.eql(u8, expect, "100-continue")) {	769	if (mem.eql(u8, expect, "100-continue")) {
754	var w = request.server.connection.stream.writer().unbuffered();	770	try request.server.out.writeAll("HTTP/1.1 100 Continue\r\n\r\n");
755	try w.writeAll("HTTP/1.1 100 Continue\r\n\r\n");
756	request.head.expect = null;	771	request.head.expect = null;
757	} else {	772	} else {
758	return error.HttpExpectationFailed;	773	return error.HttpExpectationFailed;
...	@@ -766,7 +781,8 @@ pub const Request = struct {	...	@@ -766,7 +781,8 @@ pub const Request = struct {
766	.context = request,	781	.context = request,
767	.vtable = &.{	782	.vtable = &.{
768	.read = &chunkedReader_read,	783	.read = &chunkedReader_read,
769	.readv = &chunkedReader_readv,	784	.readVec = &chunkedReader_readVec,
		785	.discard = &chunkedReader_discard,
770	},	786	},
771	};	787	};
772	},	788	},
...	@@ -778,7 +794,8 @@ pub const Request = struct {	...	@@ -778,7 +794,8 @@ pub const Request = struct {
778	.context = request,	794	.context = request,
779	.vtable = &.{	795	.vtable = &.{
780	.read = &contentLengthReader_read,	796	.read = &contentLengthReader_read,
781	.readv = &contentLengthReader_readv,	797	.readVec = &contentLengthReader_readVec,
		798	.discard = &contentLengthReader_discard,
782	},	799	},
783	};	800	};
784	},	801	},
...	@@ -801,7 +818,7 @@ pub const Request = struct {	...	@@ -801,7 +818,7 @@ pub const Request = struct {
801	if (keep_alive and request.head.keep_alive) switch (s.state) {	818	if (keep_alive and request.head.keep_alive) switch (s.state) {
802	.received_head => {	819	.received_head => {
803	const r = request.reader() catch return false;	820	const r = request.reader() catch return false;
804	_ = r.discardUntilEnd() catch return false;	821	_ = r.discardRemaining() catch return false;
805	assert(s.state == .ready);	822	assert(s.state == .ready);
806	return true;	823	return true;
807	},	824	},
...	@@ -819,7 +836,7 @@ pub const Request = struct {	...	@@ -819,7 +836,7 @@ pub const Request = struct {
819	};	836	};
820		837
821	pub const Response = struct {	838	pub const Response = struct {
822	stream: net.Stream,	839	out: *std.io.BufferedWriter,
823	send_buffer: []u8,	840	send_buffer: []u8,
824	/// Index of the first byte in `send_buffer`.	841	/// Index of the first byte in `send_buffer`.
825	/// This is 0 unless a short write happens in `write`.	842	/// This is 0 unless a short write happens in `write`.
...	@@ -909,7 +926,7 @@ pub const Response = struct {	...	@@ -909,7 +926,7 @@ pub const Response = struct {
909	_ = limit;	926	_ = limit;
910	_ = headers_and_trailers;	927	_ = headers_and_trailers;
911	_ = headers_len;	928	_ = headers_len;
912	return error.Unimplemented;	929	@panic("TODO");
913	}	930	}
914		931
915	fn cl_write(context: ?*anyopaque, bytes: []const u8) std.io.Writer.Error!usize {	932	fn cl_write(context: ?*anyopaque, bytes: []const u8) std.io.Writer.Error!usize {
...	@@ -932,8 +949,7 @@ pub const Response = struct {	...	@@ -932,8 +949,7 @@ pub const Response = struct {
932	r.send_buffer[r.send_buffer_start..][0..send_buffer_len],	949	r.send_buffer[r.send_buffer_start..][0..send_buffer_len],
933	bytes,	950	bytes,
934	};	951	};
935	var w = r.stream.writer().unbuffered();	952	const n = try r.out.writeVec(&iovecs);
936	const n = try w.writev(&iovecs);
937		953
938	if (n >= send_buffer_len) {	954	if (n >= send_buffer_len) {
939	// It was enough to reset the buffer.	955	// It was enough to reset the buffer.
...	@@ -976,7 +992,7 @@ pub const Response = struct {	...	@@ -976,7 +992,7 @@ pub const Response = struct {
976	_ = limit;	992	_ = limit;
977	_ = headers_and_trailers;	993	_ = headers_and_trailers;
978	_ = headers_len;	994	_ = headers_len;
979	return error.Unimplemented; // TODO lower to a call to writeFile on the output	995	@panic("TODO"); // TODO lower to a call to writeFile on the output
980	}	996	}
981		997
982	fn chunked_write(context: ?*anyopaque, bytes: []const u8) std.io.Writer.Error!usize {	998	fn chunked_write(context: ?*anyopaque, bytes: []const u8) std.io.Writer.Error!usize {
...	@@ -1001,8 +1017,7 @@ pub const Response = struct {	...	@@ -1001,8 +1017,7 @@ pub const Response = struct {
1001	};	1017	};
1002	// TODO make this writev instead of writevAll, which involves	1018	// TODO make this writev instead of writevAll, which involves
1003	// complicating the logic of this function.	1019	// complicating the logic of this function.
1004	var w = r.stream.writer().unbuffered();	1020	try r.out.writeVecAll(&iovecs);
1005	try w.writevAll(&iovecs);
1006	r.send_buffer_start = 0;	1021	r.send_buffer_start = 0;
1007	r.send_buffer_end = 0;	1022	r.send_buffer_end = 0;
1008	r.chunk_len = 0;	1023	r.chunk_len = 0;
...	@@ -1036,8 +1051,7 @@ pub const Response = struct {	...	@@ -1036,8 +1051,7 @@ pub const Response = struct {
1036	}	1051	}
1037		1052
1038	fn flush_cl(r: *Response) std.io.Writer.Error!void {	1053	fn flush_cl(r: *Response) std.io.Writer.Error!void {
1039	var w = r.stream.writer().unbuffered();	1054	try r.out.writeAll(r.send_buffer[r.send_buffer_start..r.send_buffer_end]);
1040	try w.writeAll(r.send_buffer[r.send_buffer_start..r.send_buffer_end]);
1041	r.send_buffer_start = 0;	1055	r.send_buffer_start = 0;
1042	r.send_buffer_end = 0;	1056	r.send_buffer_end = 0;
1043	}	1057	}
...	@@ -1050,8 +1064,7 @@ pub const Response = struct {	...	@@ -1050,8 +1064,7 @@ pub const Response = struct {
1050	const http_headers = r.send_buffer[r.send_buffer_start .. r.send_buffer_end - r.chunk_len];	1064	const http_headers = r.send_buffer[r.send_buffer_start .. r.send_buffer_end - r.chunk_len];
1051		1065
1052	if (r.elide_body) {	1066	if (r.elide_body) {
1053	var w = r.stream.writer().unbuffered();	1067	try r.out.writeAll(http_headers);
1054	try w.writeAll(http_headers);
1055	r.send_buffer_start = 0;	1068	r.send_buffer_start = 0;
1056	r.send_buffer_end = 0;	1069	r.send_buffer_end = 0;
1057	r.chunk_len = 0;	1070	r.chunk_len = 0;
...	@@ -1102,8 +1115,7 @@ pub const Response = struct {	...	@@ -1102,8 +1115,7 @@ pub const Response = struct {
1102	iovecs_len += 1;	1115	iovecs_len += 1;
1103	}	1116	}
1104		1117
1105	var w = r.stream.writer().unbuffered();	1118	try r.out.writeVecAll(iovecs[0..iovecs_len]);
1106	try w.writevAll(iovecs[0..iovecs_len]);
1107	r.send_buffer_start = 0;	1119	r.send_buffer_start = 0;
1108	r.send_buffer_end = 0;	1120	r.send_buffer_end = 0;
1109	r.chunk_len = 0;	1121	r.chunk_len = 0;

lib/std/http/WebSocket.zig+2-4

 @@ -194,16 +194,14 @@ fn recvReadInt(ws: *WebSocket, comptime I: type) !I {
     };
 }
-pub const WriteError = std.http.Server.Response.WriteError;
+pub fn writeMessage(ws: *WebSocket, message: []const u8, opcode: Opcode) std.io.Writer.Error!void {
-pub fn writeMessage(ws: *WebSocket, message: []const u8, opcode: Opcode) WriteError!void {
     const iovecs: [1]std.posix.iovec_const = .{
         .{ .base = message.ptr, .len = message.len },
     };
     return writeMessagev(ws, &iovecs, opcode);
 }
-pub fn writeMessagev(ws: *WebSocket, message: []const std.posix.iovec_const, opcode: Opcode) WriteError!void {
+pub fn writeMessagev(ws: *WebSocket, message: []const std.posix.iovec_const, opcode: Opcode) std.io.Writer.Error!void {
     const total_len = l: {
         var total_len: u64 = 0;
         for (message) |iovec| total_len += iovec.len;

lib/std/io/AllocatingWriter.zig+2-3

 @@ -93,9 +93,8 @@ pub fn toArrayList(aw: *AllocatingWriter) std.ArrayListUnmanaged(u8) {
 }
 pub fn toOwnedSlice(aw: *AllocatingWriter) error{OutOfMemory}![]u8 {
-    const gpa = aw.allocator;
+    var list = aw.toArrayList();
-    var list = toArrayList(aw);
+    return list.toOwnedSlice(aw.allocator);
-    return list.toOwnedSlice(gpa);
 }
 pub fn toOwnedSliceSentinel(aw: *AllocatingWriter, comptime sentinel: u8) error{OutOfMemory}![:sentinel]u8 {

lib/std/io/BufferedReader.zig+11-9

 @@ -97,19 +97,20 @@ pub fn seekForwardBy(br: *BufferedReader, seek_by: u64) !void {
     br.seek = seek;
 }
-/// Returns the next `n` bytes from `unbuffered_reader`, filling the buffer as
+/// Returns the next `len` bytes from `unbuffered_reader`, filling the buffer as
 /// necessary.
 ///
 /// Invalidates previously returned values from `peek`.
 ///
 /// Asserts that the `BufferedReader` was initialized with a buffer capacity at
-/// least as big as `n`.
+/// least as big as `len`.
 ///
-/// If there are fewer than `n` bytes left in the stream, `error.EndOfStream`
+/// If there are fewer than `len` bytes left in the stream, `error.EndOfStream`
 /// is returned instead.
 ///
 /// See also:
-/// * `peekGreedy`
+/// * `peek`
+/// * `tryPeekArray`
 /// * `toss`
 pub fn peek(br: *BufferedReader, n: usize) Reader.Error![]u8 {
     const storage = &br.storage;
 @@ -119,18 +120,19 @@ pub fn peek(br: *BufferedReader, n: usize) Reader.Error![]u8 {
 }
 /// Returns all the next buffered bytes from `unbuffered_reader`, after filling
-/// the buffer to ensure it contains at least `n` bytes.
+/// the buffer to ensure it contains at least `min_len` bytes.
 ///
 /// Invalidates previously returned values from `peek` and `peekGreedy`.
 ///
 /// Asserts that the `BufferedReader` was initialized with a buffer capacity at
-/// least as big as `n`.
+/// least as big as `min_len`.
 ///
-/// If there are fewer than `n` bytes left in the stream, `error.EndOfStream`
+/// If there are fewer than `min_len` bytes left in the stream, `error.EndOfStream`
 /// is returned instead.
 ///
 /// See also:
 /// * `peek`
+/// * `tryPeekGreedy`
 /// * `toss`
 pub fn peekGreedy(br: *BufferedReader, n: usize) Reader.Error![]u8 {
     const storage = &br.storage;
 @@ -214,7 +216,7 @@ pub fn discardShort(br: *BufferedReader, n: usize) Reader.ShortError!usize {
     storage.end = 0;
     br.seek = 0;
     while (true) {
-        const discard_len = br.unbuffered_reader.discard(remaining, .unlimited) catch |err| switch (err) {
+        const discard_len = br.unbuffered_reader.discard(.limited(remaining)) catch |err| switch (err) {
             error.EndOfStream => return n - remaining,
             error.ReadFailed => return error.ReadFailed,
         };
 @@ -564,7 +566,7 @@ pub inline fn takeStructEndian(br: *BufferedReader, comptime T: type, endian: st
 /// it. Otherwise, returns `error.InvalidEnumTag`.
 ///
 /// Asserts the buffer was initialized with a capacity at least `@sizeOf(Enum)`.
-pub fn takeEnum(br: *BufferedReader, comptime Enum: type, endian: std.builtin.Endian) Reader.Error!Enum {
+pub fn takeEnum(br: *BufferedReader, comptime Enum: type, endian: std.builtin.Endian) (Reader.Error || std.meta.IntToEnumError)!Enum {
     const Tag = @typeInfo(Enum).@"enum".tag_type;
     const int = try br.takeInt(Tag, endian);
     return std.meta.intToEnum(Enum, int);

lib/std/io/BufferedWriter.zig+5

 @@ -83,6 +83,11 @@ pub fn unusedCapacitySlice(bw: *const BufferedWriter) []u8 {
     return bw.buffer[bw.end..];
 }
+/// Asserts the provided buffer has total capacity enough for `len`.
+pub fn writableArray(bw: *BufferedWriter, comptime len: usize) anyerror!*[len]u8 {
+    return (try bw.writableSlice(len))[0..len];
+}
 /// Asserts the provided buffer has total capacity enough for `minimum_length`.
 pub fn writableSlice(bw: *BufferedWriter, minimum_length: usize) Writer.Error![]u8 {
     assert(bw.buffer.len >= minimum_length);

lib/std/io/multi_writer.zig+1-1

...	@@ -6,7 +6,7 @@ pub fn MultiWriter(comptime Writers: type) type {	...	@@ -6,7 +6,7 @@ pub fn MultiWriter(comptime Writers: type) type {
6	comptime var ErrSet = error{};	6	comptime var ErrSet = error{};
7	inline for (@typeInfo(Writers).@"struct".fields) \|field\| {	7	inline for (@typeInfo(Writers).@"struct".fields) \|field\| {
8	const StreamType = field.type;	8	const StreamType = field.type;
9	ErrSet = ErrSet \|\| StreamType.Error;	9	ErrSet = ErrSet \|\| if (@hasDecl(StreamType, "Error")) StreamType.Error else anyerror;
10	}	10	}
11		11
12	return struct {	12	return struct {

lib/std/net.zig+251-212

...	@@ -1817,7 +1817,10 @@ pub const Stream = struct {	...	@@ -1817,7 +1817,10 @@ pub const Stream = struct {
1817	/// interchangeable with a file system file descriptor.	1817	/// interchangeable with a file system file descriptor.
1818	handle: Handle,	1818	handle: Handle,
1819		1819
1820	pub const Handle = if (native_os == .windows) windows.ws2_32.SOCKET else posix.fd_t;	1820	pub const Handle = switch (native_os) {
		1821	.windows => windows.ws2_32.SOCKET,
		1822	else => posix.fd_t,
		1823	};
1821		1824
1822	pub fn close(s: Stream) void {	1825	pub fn close(s: Stream) void {
1823	switch (native_os) {	1826	switch (native_os) {
...	@@ -1826,238 +1829,274 @@ pub const Stream = struct {	...	@@ -1826,238 +1829,274 @@ pub const Stream = struct {
1826	}	1829	}
1827	}	1830	}
1828		1831
1829	pub const ReadError = posix.ReadError;	1832	pub const Reader = struct {
1830	pub const WriteError = posix.SendMsgError \|\| error{	1833	impl: switch (native_os) {
1831	ConnectionResetByPeer,	1834	.windows => Stream,
1832	SocketNotBound,	1835	else => struct {
1833	MessageTooBig,	1836	fr: std.fs.File.Reader,
1834	NetworkSubsystemFailed,	1837	err: Error!void,
1835	SystemResources,
1836	SocketNotConnected,
1837	Unexpected,
1838	};
1839
1840	pub fn reader(stream: Stream) std.io.Reader {
1841	return .{
1842	.context = handleToOpaque(stream.handle),
1843	.vtable = switch (native_os) {
1844	.windows => &.{
1845	.read = windows_read,
1846	.readv = windows_readv,
1847	},
1848	else => &.{
1849	.read = std.fs.File.streamRead,
1850	.readv = std.fs.File.streamReadVec,
1851	},
1852	},	1838	},
1853	};	1839	},
1854	}
1855		1840
1856	pub fn writer(stream: Stream) std.io.Writer {	1841	pub const Error = posix.ReadError;
1857	return .{	1842
1858	.context = handleToOpaque(stream.handle),	1843	pub fn interface(r: *Reader) std.io.Reader {
1859	.vtable = switch (native_os) {	1844	return switch (native_os) {
1860	.windows => &.{	1845	.windows => .{
1861	.writeSplat = windows_writeSplat,	1846	.context = r.impl.stream.handle,
1862	.writeFile = windows_writeFile,	1847	.vtable = &.{
		1848	.read = windows_read,
		1849	.readVec = windows_readVec,
		1850	.discard = windows_discard,
		1851	},
1863	},	1852	},
1864	else => &.{	1853	else => r.interface(),
1865	.writeSplat = posix_writeSplat,	1854	};
1866	.writeFile = std.fs.File.writeFile,	1855	}
1867	},
1868	},
1869	};
1870	}
1871		1856
1872	fn windows_read(	1857	fn windows_read(
1873	context: ?*anyopaque,	1858	context: ?*anyopaque,
1874	bw: *std.io.BufferedWriter,	1859	bw: *std.io.BufferedWriter,
1875	limit: std.io.Reader.Limit,	1860	limit: std.io.Reader.Limit,
1876	) std.io.Reader.Error!usize {	1861	) std.io.Reader.Error!usize {
1877	const buf = limit.slice(try bw.writableSlice(1));	1862	const buf = limit.slice(try bw.writableSlice(1));
1878	const status = try windows_readv(context, &.{buf});	1863	const status = try windows_readVec(context, &.{buf});
1879	bw.advance(status.len);	1864	bw.advance(status.len);
1880	return status;	1865	return status;
1881	}	1866	}
1882		1867
1883	fn windows_readv(context: ?*anyopaque, data: []const []u8) std.io.Reader.Error!usize {	1868	fn windows_readVec(context: ?*anyopaque, data: []const []u8) std.io.Reader.Error!usize {
1884	var iovecs: [max_buffers_len]windows.WSABUF = undefined;	1869	var iovecs: [max_buffers_len]windows.WSABUF = undefined;
1885	var iovecs_i: usize = 0;	1870	var iovecs_i: usize = 0;
1886	for (data) \|d\| {	1871	for (data) \|d\| {
1887	// In case Windows checks pointer address before length, we must omit	1872	// In case Windows checks pointer address before length, we must omit
1888	// length-zero vectors.	1873	// length-zero vectors.
1889	if (d.len == 0) continue;	1874	if (d.len == 0) continue;
1890	iovecs[iovecs_i] = .{ .buf = d.ptr, .len = d.len };	1875	iovecs[iovecs_i] = .{ .buf = d.ptr, .len = d.len };
1891	iovecs_i += 1;	1876	iovecs_i += 1;
1892	if (iovecs_i >= iovecs.len) break;	1877	if (iovecs_i >= iovecs.len) break;
		1878	}
		1879	const bufs = iovecs[0..iovecs_i];
		1880	if (bufs.len == 0) return .{}; // Prevent false positive end detection on empty `data`.
		1881	var n: u32 = undefined;
		1882	var flags: u32 = 0;
		1883	const rc = windows.ws2_32.WSARecvFrom(context, bufs.ptr, bufs.len, &n, &flags, null, null, null, null);
		1884	if (rc != 0) switch (windows.ws2_32.WSAGetLastError()) {
		1885	.WSAECONNRESET => return error.ConnectionResetByPeer,
		1886	.WSAEFAULT => unreachable, // a pointer is not completely contained in user address space.
		1887	.WSAEINPROGRESS, .WSAEINTR => unreachable, // deprecated and removed in WSA 2.2
		1888	.WSAEINVAL => return error.SocketNotBound,
		1889	.WSAEMSGSIZE => return error.MessageTooBig,
		1890	.WSAENETDOWN => return error.NetworkSubsystemFailed,
		1891	.WSAENETRESET => return error.ConnectionResetByPeer,
		1892	.WSAENOTCONN => return error.SocketNotConnected,
		1893	.WSAEWOULDBLOCK => return error.WouldBlock,
		1894	.WSANOTINITIALISED => unreachable, // WSAStartup must be called before this function
		1895	.WSA_IO_PENDING => unreachable, // not using overlapped I/O
		1896	.WSA_OPERATION_ABORTED => unreachable, // not using overlapped I/O
		1897	else => \|err\| return windows.unexpectedWSAError(err),
		1898	};
		1899	return .{ .len = n, .end = n == 0 };
1893	}	1900	}
1894	const bufs = iovecs[0..iovecs_i];
1895	if (bufs.len == 0) return .{}; // Prevent false positive end detection on empty `data`.
1896	const handle = opaqueToHandle(context);
1897	var n: u32 = undefined;
1898	var flags: u32 = 0;
1899	const rc = windows.ws2_32.WSARecvFrom(handle, bufs.ptr, bufs.len, &n, &flags, null, null, null, null);
1900	if (rc != 0) switch (windows.ws2_32.WSAGetLastError()) {
1901	.WSAECONNRESET => return error.ConnectionResetByPeer,
1902	.WSAEFAULT => unreachable, // a pointer is not completely contained in user address space.
1903	.WSAEINPROGRESS, .WSAEINTR => unreachable, // deprecated and removed in WSA 2.2
1904	.WSAEINVAL => return error.SocketNotBound,
1905	.WSAEMSGSIZE => return error.MessageTooBig,
1906	.WSAENETDOWN => return error.NetworkSubsystemFailed,
1907	.WSAENETRESET => return error.ConnectionResetByPeer,
1908	.WSAENOTCONN => return error.SocketNotConnected,
1909	.WSAEWOULDBLOCK => return error.WouldBlock,
1910	.WSANOTINITIALISED => unreachable, // WSAStartup must be called before this function
1911	.WSA_IO_PENDING => unreachable, // not using overlapped I/O
1912	.WSA_OPERATION_ABORTED => unreachable, // not using overlapped I/O
1913	else => \|err\| return windows.unexpectedWSAError(err),
1914	};
1915	return .{ .len = n, .end = n == 0 };
1916	}
1917		1901
1918	fn windows_writeSplat(context: *anyopaque, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {	1902	fn windows_discard(context: ?*anyopaque, limit: std.io.Reader.Limit) std.io.Reader.Error!usize {
1919	comptime assert(native_os == .windows);	1903	_ = context;
1920	if (data.len == 1 and splat == 0) return 0;	1904	_ = limit;
1921	var splat_buffer: [256]u8 = undefined;	1905	@panic("TODO");
1922	var iovecs: [max_buffers_len]windows.WSABUF = undefined;
1923	var len: u32 = @min(iovecs.len, data.len);
1924	for (iovecs[0..len], data[0..len]) \|v, d\| v. = .{
1925	.buf = if (d.len == 0) "" else d.ptr, // TODO: does Windows allow ptr=undefined len=0 ?
1926	.len = d.len,
1927	};
1928	switch (splat) {
1929	0 => len -= 1,
1930	1 => {},
1931	else => {
1932	const pattern = data[data.len - 1];
1933	if (pattern.len == 1) {
1934	const memset_len = @min(splat_buffer.len, splat);
1935	const buf = splat_buffer[0..memset_len];
1936	@memset(buf, pattern[0]);
1937	iovecs[len - 1] = .{ .base = buf.ptr, .len = buf.len };
1938	var remaining_splat = splat - buf.len;
1939	while (remaining_splat > splat_buffer.len and len < iovecs.len) {
1940	iovecs[len] = .{ .base = &splat_buffer, .len = splat_buffer.len };
1941	remaining_splat -= splat_buffer.len;
1942	len += 1;
1943	}
1944	if (remaining_splat > 0 and len < iovecs.len) {
1945	iovecs[len] = .{ .base = &splat_buffer, .len = remaining_splat };
1946	len += 1;
1947	}
1948	}
1949	},
1950	}	1906	}
1951	const handle = opaqueToHandle(context);	1907	};
1952	var n: u32 = undefined;	1908
1953	const rc = windows.ws2_32.WSASend(handle, &iovecs, len, &n, 0, null, null);	1909	pub const Writer = struct {
1954	if (rc == windows.ws2_32.SOCKET_ERROR) switch (windows.ws2_32.WSAGetLastError()) {	1910	impl: switch (native_os) {
1955	.WSAECONNABORTED => return error.ConnectionResetByPeer,	1911	.windows => Stream,
1956	.WSAECONNRESET => return error.ConnectionResetByPeer,	1912	else => PosixImpl,
1957	.WSAEFAULT => unreachable, // a pointer is not completely contained in user address space.	1913	},
1958	.WSAEINPROGRESS, .WSAEINTR => unreachable, // deprecated and removed in WSA 2.2
1959	.WSAEINVAL => return error.SocketNotBound,
1960	.WSAEMSGSIZE => return error.MessageTooBig,
1961	.WSAENETDOWN => return error.NetworkSubsystemFailed,
1962	.WSAENETRESET => return error.ConnectionResetByPeer,
1963	.WSAENOBUFS => return error.SystemResources,
1964	.WSAENOTCONN => return error.SocketNotConnected,
1965	.WSAENOTSOCK => unreachable, // not a socket
1966	.WSAEOPNOTSUPP => unreachable, // only for message-oriented sockets
1967	.WSAESHUTDOWN => unreachable, // cannot send on a socket after write shutdown
1968	.WSAEWOULDBLOCK => return error.WouldBlock,
1969	.WSANOTINITIALISED => unreachable, // WSAStartup must be called before this function
1970	.WSA_IO_PENDING => unreachable, // not using overlapped I/O
1971	.WSA_OPERATION_ABORTED => unreachable, // not using overlapped I/O
1972	else => \|err\| return windows.unexpectedWSAError(err),
1973	};
1974	return n;
1975	}
1976		1914
1977	fn posix_writeSplat(context: ?*anyopaque, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {	1915	const PosixImpl = struct {
1978	const sock_fd = opaqueToHandle(context);	1916	fw: std.fs.File.Writer,
1979	comptime assert(native_os != .windows);	1917	err: Error!void,
1980	var splat_buffer: [256]u8 = undefined;
1981	var iovecs: [max_buffers_len]std.posix.iovec_const = undefined;
1982	var len: usize = @min(iovecs.len, data.len);
1983	for (iovecs[0..len], data[0..len]) \|v, d\| v. = .{
1984	.base = if (d.len == 0) "" else d.ptr, // OS sadly checks ptr addr before length.
1985	.len = d.len,
1986	};	1918	};
1987	var msg: posix.msghdr_const = .{	1919
1988	.name = null,	1920	pub const Error = posix.SendMsgError \|\| error{
1989	.namelen = 0,	1921	ConnectionResetByPeer,
1990	.iov = &iovecs,	1922	SocketNotBound,
1991	.iovlen = len,	1923	MessageTooBig,
1992	.control = null,	1924	NetworkSubsystemFailed,
1993	.controllen = 0,	1925	SystemResources,
1994	.flags = 0,	1926	SocketNotConnected,
		1927	Unexpected,
1995	};	1928	};
1996	switch (splat) {	1929
1997	0 => msg.iovlen = len - 1,	1930	pub fn interface(w: *Writer) std.io.Writer {
1998	1 => {},	1931	return switch (native_os) {
1999	else => {	1932	.windows => .{
2000	const pattern = data[data.len - 1];	1933	.context = w.impl.stream.handle,
2001	if (pattern.len == 1) {	1934	.vtable = &.{
2002	const memset_len = @min(splat_buffer.len, splat);	1935	.writeSplat = windows_writeSplat,
2003	const buf = splat_buffer[0..memset_len];	1936	.writeFile = windows_writeFile,
2004	@memset(buf, pattern[0]);	1937	},
2005	iovecs[len - 1] = .{ .base = buf.ptr, .len = buf.len };	1938	},
2006	var remaining_splat = splat - buf.len;	1939	else => .{
2007	while (remaining_splat > splat_buffer.len and len < iovecs.len) {	1940	.context = &w.impl,
2008	iovecs[len] = .{ .base = &splat_buffer, .len = splat_buffer.len };	1941	.vtable = &.{
2009	remaining_splat -= splat_buffer.len;	1942	.writeSplat = posix_writeSplat,
2010	len += 1;	1943	.writeFile = std.fs.File.Writer.writeFile,
2011	}	1944	},
2012	if (remaining_splat > 0 and len < iovecs.len) {	1945	},
2013	iovecs[len] = .{ .base = &splat_buffer, .len = remaining_splat };	1946	};
2014	len += 1;	1947	}
		1948
		1949	fn windows_writeSplat(context: ?*anyopaque, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {
		1950	comptime assert(native_os == .windows);
		1951	if (data.len == 1 and splat == 0) return 0;
		1952	var splat_buffer: [256]u8 = undefined;
		1953	var iovecs: [max_buffers_len]windows.WSABUF = undefined;
		1954	var len: u32 = @min(iovecs.len, data.len);
		1955	for (iovecs[0..len], data[0..len]) \|v, d\| v. = .{
		1956	.buf = if (d.len == 0) "" else d.ptr, // TODO: does Windows allow ptr=undefined len=0 ?
		1957	.len = d.len,
		1958	};
		1959	switch (splat) {
		1960	0 => len -= 1,
		1961	1 => {},
		1962	else => {
		1963	const pattern = data[data.len - 1];
		1964	if (pattern.len == 1) {
		1965	const memset_len = @min(splat_buffer.len, splat);
		1966	const buf = splat_buffer[0..memset_len];
		1967	@memset(buf, pattern[0]);
		1968	iovecs[len - 1] = .{ .base = buf.ptr, .len = buf.len };
		1969	var remaining_splat = splat - buf.len;
		1970	while (remaining_splat > splat_buffer.len and len < iovecs.len) {
		1971	iovecs[len] = .{ .base = &splat_buffer, .len = splat_buffer.len };
		1972	remaining_splat -= splat_buffer.len;
		1973	len += 1;
		1974	}
		1975	if (remaining_splat > 0 and len < iovecs.len) {
		1976	iovecs[len] = .{ .base = &splat_buffer, .len = remaining_splat };
		1977	len += 1;
		1978	}
2015	}	1979	}
2016	msg.iovlen = len;	1980	},
2017	}	1981	}
2018	},	1982	var n: u32 = undefined;
		1983	const rc = windows.ws2_32.WSASend(context, &iovecs, len, &n, 0, null, null);
		1984	if (rc == windows.ws2_32.SOCKET_ERROR) switch (windows.ws2_32.WSAGetLastError()) {
		1985	.WSAECONNABORTED => return error.ConnectionResetByPeer,
		1986	.WSAECONNRESET => return error.ConnectionResetByPeer,
		1987	.WSAEFAULT => unreachable, // a pointer is not completely contained in user address space.
		1988	.WSAEINPROGRESS, .WSAEINTR => unreachable, // deprecated and removed in WSA 2.2
		1989	.WSAEINVAL => return error.SocketNotBound,
		1990	.WSAEMSGSIZE => return error.MessageTooBig,
		1991	.WSAENETDOWN => return error.NetworkSubsystemFailed,
		1992	.WSAENETRESET => return error.ConnectionResetByPeer,
		1993	.WSAENOBUFS => return error.SystemResources,
		1994	.WSAENOTCONN => return error.SocketNotConnected,
		1995	.WSAENOTSOCK => unreachable, // not a socket
		1996	.WSAEOPNOTSUPP => unreachable, // only for message-oriented sockets
		1997	.WSAESHUTDOWN => unreachable, // cannot send on a socket after write shutdown
		1998	.WSAEWOULDBLOCK => return error.WouldBlock,
		1999	.WSANOTINITIALISED => unreachable, // WSAStartup must be called before this function
		2000	.WSA_IO_PENDING => unreachable, // not using overlapped I/O
		2001	.WSA_OPERATION_ABORTED => unreachable, // not using overlapped I/O
		2002	else => \|err\| return windows.unexpectedWSAError(err),
		2003	};
		2004	return n;
2019	}	2005	}
2020	const flags = posix.MSG.NOSIGNAL;
2021	return std.posix.sendmsg(sock_fd, &msg, flags);
2022	}
2023		2006
2024	fn windows_writeFile(	2007	fn posix_writeSplat(context: ?*anyopaque, data: []const []const u8, splat: usize) std.io.Writer.Error!usize {
2025	context: *anyopaque,	2008	const fw: *std.fs.File.Writer = @alignCast(@ptrCast(context));
2026	in_file: std.fs.File,	2009	const impl: *PosixImpl = @fieldParentPtr("fw", fw);
2027	in_offset: u64,	2010	comptime assert(native_os != .windows);
2028	in_len: std.io.Writer.FileLen,	2011	var splat_buffer: [256]u8 = undefined;
2029	headers_and_trailers: []const []const u8,	2012	var iovecs: [max_buffers_len]std.posix.iovec_const = undefined;
2030	headers_len: usize,	2013	var len: usize = @min(iovecs.len, data.len);
2031	) std.io.Writer.FileError!usize {	2014	for (iovecs[0..len], data[0..len]) \|v, d\| v. = .{
2032	const len_int = switch (in_len) {	2015	.base = if (d.len == 0) "" else d.ptr, // OS sadly checks ptr addr before length.
2033	.zero => return windows_writeSplat(context, headers_and_trailers, 1),	2016	.len = d.len,
2034	.entire_file => std.math.maxInt(usize),	2017	};
2035	else => in_len.int(),	2018	var msg: posix.msghdr_const = .{
2036	};	2019	.name = null,
2037	if (headers_len > 0) return windows_writeSplat(context, headers_and_trailers[0..headers_len], 1);	2020	.namelen = 0,
2038	var file_contents_buffer: [4096]u8 = undefined;	2021	.iov = &iovecs,
2039	const read_buffer = file_contents_buffer[0..@min(file_contents_buffer.len, len_int)];	2022	.iovlen = len,
2040	const n = try windows.ReadFile(in_file.handle, read_buffer, in_offset);	2023	.control = null,
2041	return windows_writeSplat(context, &.{read_buffer[0..n]}, 1);	2024	.controllen = 0,
2042	}	2025	.flags = 0,
		2026	};
		2027	switch (splat) {
		2028	0 => msg.iovlen = len - 1,
		2029	1 => {},
		2030	else => {
		2031	const pattern = data[data.len - 1];
		2032	if (pattern.len == 1) {
		2033	const memset_len = @min(splat_buffer.len, splat);
		2034	const buf = splat_buffer[0..memset_len];
		2035	@memset(buf, pattern[0]);
		2036	iovecs[len - 1] = .{ .base = buf.ptr, .len = buf.len };
		2037	var remaining_splat = splat - buf.len;
		2038	while (remaining_splat > splat_buffer.len and len < iovecs.len) {
		2039	iovecs[len] = .{ .base = &splat_buffer, .len = splat_buffer.len };
		2040	remaining_splat -= splat_buffer.len;
		2041	len += 1;
		2042	}
		2043	if (remaining_splat > 0 and len < iovecs.len) {
		2044	iovecs[len] = .{ .base = &splat_buffer, .len = remaining_splat };
		2045	len += 1;
		2046	}
		2047	msg.iovlen = len;
		2048	}
		2049	},
		2050	}
		2051	const flags = posix.MSG.NOSIGNAL;
		2052	return std.posix.sendmsg(fw.file.handle, &msg, flags) catch \|err\| {
		2053	impl.err = err;
		2054	return error.WriteFailed;
		2055	};
		2056	}
2043		2057
2044	const max_buffers_len = 8;	2058	fn windows_writeFile(
		2059	context: *anyopaque,
		2060	in_file: std.fs.File,
		2061	in_offset: u64,
		2062	in_len: std.io.Writer.FileLen,
		2063	headers_and_trailers: []const []const u8,
		2064	headers_len: usize,
		2065	) std.io.Writer.FileError!usize {
		2066	const len_int = switch (in_len) {
		2067	.zero => return windows_writeSplat(context, headers_and_trailers, 1),
		2068	.entire_file => std.math.maxInt(usize),
		2069	else => in_len.int(),
		2070	};
		2071	if (headers_len > 0) return windows_writeSplat(context, headers_and_trailers[0..headers_len], 1);
		2072	var file_contents_buffer: [4096]u8 = undefined;
		2073	const read_buffer = file_contents_buffer[0..@min(file_contents_buffer.len, len_int)];
		2074	const n = try windows.ReadFile(in_file.handle, read_buffer, in_offset);
		2075	return windows_writeSplat(context, &.{read_buffer[0..n]}, 1);
		2076	}
		2077	};
2045		2078
2046	fn handleToOpaque(handle: Handle) ?*anyopaque {	2079	pub fn reader(stream: Stream) Reader {
2047	return switch (@typeInfo(Handle)) {	2080	return switch (native_os) {
2048	.pointer => @ptrCast(handle),	2081	.windows => .{ .impl = stream },
2049	.int => @ptrFromInt(@as(u32, @bitCast(handle))),	2082	else => .{ .impl = .{
2050	else => @compileError("unhandled"),	2083	.fr = std.fs.File.reader(.{ .handle = stream.handle }),
		2084	.err = {},
		2085	} },
2051	};	2086	};
2052	}	2087	}
2053		2088
2054	fn opaqueToHandle(userdata: ?*anyopaque) Handle {	2089	pub fn writer(stream: Stream) Writer {
2055	return switch (@typeInfo(Handle)) {	2090	return switch (native_os) {
2056	.pointer => @ptrCast(userdata),	2091	.windows => .{ .impl = stream },
2057	.int => @intCast(@intFromPtr(userdata)),	2092	else => .{ .impl = .{
2058	else => @compileError("unhandled"),	2093	.fw = std.fs.File.writer(.{ .handle = stream.handle }),
		2094	.err = {},
		2095	} },
2059	};	2096	};
2060	}	2097	}
		2098
		2099	const max_buffers_len = 8;
2061	};	2100	};
2062		2101
2063	pub const Server = struct {	2102	pub const Server = struct {

lib/std/process.zig+6-6

...	@@ -1895,7 +1895,7 @@ pub fn createEnvironFromMap(	...	@@ -1895,7 +1895,7 @@ pub fn createEnvironFromMap(
1895	var i: usize = 0;	1895	var i: usize = 0;
1896		1896
1897	if (zig_progress_action == .add) {	1897	if (zig_progress_action == .add) {
1898	envp_buf[i] = try std.fmt.allocPrintZ(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?});	1898	envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
1899	i += 1;	1899	i += 1;
1900	}	1900	}
1901		1901
...	@@ -1906,16 +1906,16 @@ pub fn createEnvironFromMap(	...	@@ -1906,16 +1906,16 @@ pub fn createEnvironFromMap(
1906	.add => unreachable,	1906	.add => unreachable,
1907	.delete => continue,	1907	.delete => continue,
1908	.edit => {	1908	.edit => {
1909	envp_buf[i] = try std.fmt.allocPrintZ(arena, "{s}={d}", .{	1909	envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "{s}={d}", .{
1910	pair.key_ptr.*, options.zig_progress_fd.?,	1910	pair.key_ptr.*, options.zig_progress_fd.?,
1911	});	1911	}, 0);
1912	i += 1;	1912	i += 1;
1913	continue;	1913	continue;
1914	},	1914	},
1915	.nothing => {},	1915	.nothing => {},
1916	};	1916	};
1917		1917
1918	envp_buf[i] = try std.fmt.allocPrintZ(arena, "{s}={s}", .{ pair.key_ptr., pair.value_ptr. });	1918	envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "{s}={s}", .{ pair.key_ptr., pair.value_ptr. }, 0);
1919	i += 1;	1919	i += 1;
1920	}	1920	}
1921	}	1921	}
...	@@ -1965,7 +1965,7 @@ pub fn createEnvironFromExisting(	...	@@ -1965,7 +1965,7 @@ pub fn createEnvironFromExisting(
1965	var existing_index: usize = 0;	1965	var existing_index: usize = 0;
1966		1966
1967	if (zig_progress_action == .add) {	1967	if (zig_progress_action == .add) {
1968	envp_buf[i] = try std.fmt.allocPrintZ(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?});	1968	envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
1969	i += 1;	1969	i += 1;
1970	}	1970	}
1971		1971
...	@@ -1974,7 +1974,7 @@ pub fn createEnvironFromExisting(	...	@@ -1974,7 +1974,7 @@ pub fn createEnvironFromExisting(
1974	.add => unreachable,	1974	.add => unreachable,
1975	.delete => continue,	1975	.delete => continue,
1976	.edit => {	1976	.edit => {
1977	envp_buf[i] = try std.fmt.allocPrintZ(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?});	1977	envp_buf[i] = try std.fmt.allocPrintSentinel(arena, "ZIG_PROGRESS={d}", .{options.zig_progress_fd.?}, 0);
1978	i += 1;	1978	i += 1;
1979	continue;	1979	continue;
1980	},	1980	},

lib/std/process/Child.zig+7-7

...	@@ -1003,18 +1003,18 @@ fn forkChildErrReport(fd: i32, err: ChildProcess.SpawnError) noreturn {	...	@@ -1003,18 +1003,18 @@ fn forkChildErrReport(fd: i32, err: ChildProcess.SpawnError) noreturn {
1003	}	1003	}
1004		1004
1005	fn writeIntFd(fd: i32, value: ErrInt) !void {	1005	fn writeIntFd(fd: i32, value: ErrInt) !void {
1006	const file: File = .{ .handle = fd };	1006	var fw = std.fs.File.writer(.{ .handle = fd });
1007	var buffer: [8]u8 = undefined;	1007	var buffer: [8]u8 = undefined;
1008	std.mem.writeInt(u64, &buffer, @intCast(value), .little);	1008	var bw = fw.interface().buffered(&buffer);
1009	file.writeAll(&buffer) catch return error.SystemResorces;	1009	bw.writeInt(u64, value, .little) catch return error.SystemResources;
1010	}	1010	}
1011		1011
1012	fn readIntFd(fd: i32) !ErrInt {	1012	fn readIntFd(fd: i32) !ErrInt {
1013	const file: File = .{ .handle = fd };	1013	var fr = std.fs.File.reader(.{ .handle = fd });
1014	var buffer: [8]u8 = undefined;	1014	var buffer: [8]u8 = undefined;
1015	const n = file.readAll(&buffer) catch return error.SystemResources;	1015	var br: std.io.BufferedReader = undefined;
1016	if (n != buffer.len) return error.SystemResources;	1016	br.init(fr.interface(), &buffer);
1017	return @intCast(std.mem.readInt(u64, &buffer, .little));	1017	return @intCast(br.takeInt(u64, .little) catch return error.SystemResources);
1018	}	1018	}
1019		1019
1020	const ErrInt = std.meta.Int(.unsigned, @sizeOf(anyerror) * 8);	1020	const ErrInt = std.meta.Int(.unsigned, @sizeOf(anyerror) * 8);

lib/std/zig/ErrorBundle.zig+2-2

...	@@ -163,7 +163,7 @@ pub fn renderToStdErr(eb: ErrorBundle, options: RenderOptions) void {	...	@@ -163,7 +163,7 @@ pub fn renderToStdErr(eb: ErrorBundle, options: RenderOptions) void {
163	renderToWriter(eb, options, bw) catch return;	163	renderToWriter(eb, options, bw) catch return;
164	}	164	}
165		165
166	pub fn renderToWriter(eb: ErrorBundle, options: RenderOptions, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {	166	pub fn renderToWriter(eb: ErrorBundle, options: RenderOptions, bw: *std.io.BufferedWriter) (std.io.Writer.Error \|\| std.posix.UnexpectedError)!void {
167	if (eb.extra.len == 0) return;	167	if (eb.extra.len == 0) return;
168	for (eb.getMessages()) \|err_msg\| {	168	for (eb.getMessages()) \|err_msg\| {
169	try renderErrorMessageToWriter(eb, options, err_msg, bw, "error", .red, 0);	169	try renderErrorMessageToWriter(eb, options, err_msg, bw, "error", .red, 0);
...	@@ -186,7 +186,7 @@ fn renderErrorMessageToWriter(	...	@@ -186,7 +186,7 @@ fn renderErrorMessageToWriter(
186	kind: []const u8,	186	kind: []const u8,
187	color: std.io.tty.Color,	187	color: std.io.tty.Color,
188	indent: usize,	188	indent: usize,
189	) std.io.Writer.Error!void {	189	) (std.io.Writer.Error \|\| std.posix.UnexpectedError)!void {
190	const ttyconf = options.ttyconf;	190	const ttyconf = options.ttyconf;
191	const err_msg = eb.getErrorMessage(err_msg_index);	191	const err_msg = eb.getErrorMessage(err_msg_index);
192	const prefix_start = bw.count;	192	const prefix_start = bw.count;

src/Package/Fetch.zig+1-4

 @@ -1367,10 +1367,7 @@ fn unpackGitPack(f: *Fetch, out_dir: fs.Dir, resource: *Resource.Git) anyerror!U
             const index_prog_node = f.prog_node.start("Index pack", 0);
             defer index_prog_node.end();
             var buffer: [4096]u8 = undefined;
-            var index_buffered_writer: std.io.BufferedWriter = .{
+            var index_buffered_writer: std.io.BufferedWriter = index_file.writer().buffered(&buffer);
-                .unbuffered_writer = index_file.writer(),
-                .buffer = &buffer,
-            };
             try git.indexPack(gpa, object_format, pack_file, &index_buffered_writer);
             try index_buffered_writer.flush();
             try index_file.sync();

src/dev.zig+4

...	@@ -78,6 +78,7 @@ pub const Env = enum {	...	@@ -78,6 +78,7 @@ pub const Env = enum {
78	.ast_gen,	78	.ast_gen,
79	.sema,	79	.sema,
80	.legalize,	80	.legalize,
		81	.c_compiler,
81	.llvm_backend,	82	.llvm_backend,
82	.c_backend,	83	.c_backend,
83	.wasm_backend,	84	.wasm_backend,
...	@@ -127,6 +128,7 @@ pub const Env = enum {	...	@@ -127,6 +128,7 @@ pub const Env = enum {
127	.clang_command,	128	.clang_command,
128	.cc_command,	129	.cc_command,
129	.translate_c_command,	130	.translate_c_command,
		131	.c_compiler,
130	=> true,	132	=> true,
131	else => false,	133	else => false,
132	},	134	},
...	@@ -248,6 +250,8 @@ pub const Feature = enum {	...	@@ -248,6 +250,8 @@ pub const Feature = enum {
248	sema,	250	sema,
249	legalize,	251	legalize,
250		252
		253	c_compiler,
		254
251	llvm_backend,	255	llvm_backend,
252	c_backend,	256	c_backend,
253	wasm_backend,	257	wasm_backend,

src/link/Elf/Atom.zig+14-17

 @@ -1388,10 +1388,7 @@ const x86_64 = struct {
                     .{ .imm = .s(-129) },
                 }, t) catch return false;
                 var buf: [std.atomic.cache_line]u8 = undefined;
-                var bw: std.io.BufferedWriter = .{
+                var bw = std.io.Writer.null.buffered(&buf);
-                    .unbuffered_writer = .null,
-                    .buffer = &buf,
-                };
                 inst.encode(&bw, .{}) catch return false;
                 return true;
             },
 @@ -1599,7 +1596,7 @@ const aarch64 = struct {
         const diags = &elf_file.base.comp.link_diags;
         const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type());
         const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow;
-        const code = (try bw.writableSlice(4))[0..4];
+        const code = try bw.writableArray(4);
         const file_ptr = atom.file(elf_file).?;
         const P, const A, const S, const GOT, const G, const TP, const DTP = args;
 @@ -1626,7 +1623,7 @@ const aarch64 = struct {
                     const S_ = th.targetAddress(target_index, elf_file);
                     break :blk math.cast(i28, S_ + A - P) orelse return error.Overflow;
                 };
-                aarch64_util.writeBranchImm(disp, (try bw.writableSlice(4))[0..4]);
+                aarch64_util.writeBranchImm(disp, code);
             },
             .PREL32 => {
 @@ -1897,26 +1894,26 @@ const riscv = struct {
             .HI20 => {
                 const value: u32 = @bitCast(math.cast(i32, S + A) orelse return error.Overflow);
-                riscv_util.writeInstU((try bw.writableSlice(4))[0..4], value);
+                riscv_util.writeInstU(try bw.writableArray(4), value);
             },
             .GOT_HI20 => {
                 assert(target.flags.has_got);
                 const disp: u32 = @bitCast(math.cast(i32, G + GOT + A - P) orelse return error.Overflow);
-                riscv_util.writeInstU((try bw.writableSlice(4))[0..4], disp);
+                riscv_util.writeInstU(try bw.writableArray(4), disp);
             },
             .CALL_PLT => {
                 // TODO: relax
                 const disp: u32 = @bitCast(math.cast(i32, S + A - P) orelse return error.Overflow);
-                const code = (try bw.writableSlice(8))[0..8];
+                const code = try bw.writableArray(8);
                 riscv_util.writeInstU(code[0..4], disp); // auipc
                 riscv_util.writeInstI(code[4..8], disp); // jalr
             },
             .PCREL_HI20 => {
                 const disp: u32 = @bitCast(math.cast(i32, S + A - P) orelse return error.Overflow);
-                riscv_util.writeInstU((try bw.writableSlice(4))[0..4], disp);
+                riscv_util.writeInstU(try bw.writableArray(4), disp);
             },
             .PCREL_LO12_I,
 @@ -1954,8 +1951,8 @@ const riscv = struct {
                 };
                 relocs_log.debug("      [{x} => {x}]", .{ P_, disp + P_ });
                 switch (r_type) {
-                    .PCREL_LO12_I => riscv_util.writeInstI((try bw.writableSlice(4))[0..4], @bitCast(disp)),
+                    .PCREL_LO12_I => riscv_util.writeInstI(try bw.writableArray(4), @bitCast(disp)),
-                    .PCREL_LO12_S => riscv_util.writeInstS((try bw.writableSlice(4))[0..4], @bitCast(disp)),
+                    .PCREL_LO12_S => riscv_util.writeInstS(try bw.writableArray(4), @bitCast(disp)),
                     else => unreachable,
                 }
             },
 @@ -1965,8 +1962,8 @@ const riscv = struct {
             => {
                 const disp: u32 = @bitCast(math.cast(i32, S + A) orelse return error.Overflow);
                 switch (r_type) {
-                    .LO12_I => riscv_util.writeInstI((try bw.writableSlice(4))[0..4], disp),
+                    .LO12_I => riscv_util.writeInstI(try bw.writableArray(4), disp),
-                    .LO12_S => riscv_util.writeInstS((try bw.writableSlice(4))[0..4], disp),
+                    .LO12_S => riscv_util.writeInstS(try bw.writableArray(4), disp),
                     else => unreachable,
                 }
             },
 @@ -1974,7 +1971,7 @@ const riscv = struct {
             .TPREL_HI20 => {
                 const target_addr: u32 = @intCast(target.address(.{}, elf_file));
                 const val: i32 = @intCast(S + A - target_addr);
-                riscv_util.writeInstU((try bw.writableSlice(4))[0..4], @bitCast(val));
+                riscv_util.writeInstU(try bw.writableArray(4), @bitCast(val));
             },
             .TPREL_LO12_I,
 @@ -1983,8 +1980,8 @@ const riscv = struct {
                 const target_addr: u32 = @intCast(target.address(.{}, elf_file));
                 const val: i32 = @intCast(S + A - target_addr);
                 switch (r_type) {
-                    .TPREL_LO12_I => riscv_util.writeInstI((try bw.writableSlice(4))[0..4], @bitCast(val)),
+                    .TPREL_LO12_I => riscv_util.writeInstI(try bw.writableArray(4), @bitCast(val)),
-                    .TPREL_LO12_S => riscv_util.writeInstS((try bw.writableSlice(4))[0..4], @bitCast(val)),
+                    .TPREL_LO12_S => riscv_util.writeInstS(try bw.writableArray(4), @bitCast(val)),
                     else => unreachable,
                 }
             },

src/link/MachO/dyld_info/Trie.zig+1-4

 @@ -185,10 +185,7 @@ const FinalizeNodeResult = struct {
 /// Updates offset of this node in the output byte stream.
 fn finalizeNode(self: *Trie, node_index: Node.Index, offset_in_trie: u32) !FinalizeNodeResult {
     var buf: [1024]u8 = undefined;
-    var bw: std.io.BufferedWriter = .{
+    var bw = std.io.Writer.null.buffered(&buf);
-        .unbuffered_writer = .null,
-        .buffer = &buf,
-    };
     const slice = self.nodes.slice();
     var node_size: u32 = 0;

src/link/riscv.zig+3-3

...	@@ -1,7 +1,7 @@	...	@@ -1,7 +1,7 @@
1	pub fn writeSetSub6(comptime op: enum { set, sub }, addend: anytype, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {	1	pub fn writeSetSub6(comptime op: enum { set, sub }, addend: anytype, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
2	const mask: u8 = 0b11_000000;	2	const mask: u8 = 0b11_000000;
3	const actual: i8 = @truncate(addend);	3	const actual: i8 = @truncate(addend);
4	const old_value = (try bw.writableSlice(1))[0];	4	const old_value = (try bw.writableArray(1))[0];
5	const new_value = (old_value & mask) \| (@as(u8, switch (op) {	5	const new_value = (old_value & mask) \| (@as(u8, switch (op) {
6	.set => @bitCast(actual),	6	.set => @bitCast(actual),
7	.sub => @bitCast(@as(i8, @bitCast(old_value)) -\| actual),	7	.sub => @bitCast(@as(i8, @bitCast(old_value)) -\| actual),
...	@@ -14,7 +14,7 @@ pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.	...	@@ -14,7 +14,7 @@ pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.
14	.set => try overwriteUleb(@intCast(addend), bw),	14	.set => try overwriteUleb(@intCast(addend), bw),
15	.sub => {	15	.sub => {
16	var br: std.io.BufferedReader = undefined;	16	var br: std.io.BufferedReader = undefined;
17	br.initFixed(try bw.writableSlice(1));	17	br.initFixed(try bw.writableArray(1));
18	const old_value = try br.takeLeb128(u64);	18	const old_value = try br.takeLeb128(u64);
19	try overwriteUleb(old_value -% @as(u64, @intCast(addend)), bw);	19	try overwriteUleb(old_value -% @as(u64, @intCast(addend)), bw);
20	},	20	},
...	@@ -24,7 +24,7 @@ pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.	...	@@ -24,7 +24,7 @@ pub fn writeSetSubUleb(comptime op: enum { set, sub }, addend: i64, bw: *std.io.
24	fn overwriteUleb(new_value: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {	24	fn overwriteUleb(new_value: u64, bw: *std.io.BufferedWriter) std.io.Writer.Error!void {
25	var value: u64 = new_value;	25	var value: u64 = new_value;
26	while (true) {	26	while (true) {
27	const byte = (try bw.writableSlice(1))[0];	27	const byte = (try bw.writableArray(1))[0];
28	try bw.writeByte((byte & 0x80) \| @as(u7, @truncate(value)));	28	try bw.writeByte((byte & 0x80) \| @as(u7, @truncate(value)));
29	if (byte & 0x80 == 0) break;	29	if (byte & 0x80 == 0) break;
30	value >>= 7;	30	value >>= 7;

src/main.zig+13-2

...	@@ -1808,6 +1808,7 @@ fn buildOutputType(	...	@@ -1808,6 +1808,7 @@ fn buildOutputType(
1808	} else manifest_file = arg;	1808	} else manifest_file = arg;
1809	},	1809	},
1810	.assembly, .assembly_with_cpp, .c, .cpp, .h, .hpp, .hm, .hmm, .ll, .bc, .m, .mm => {	1810	.assembly, .assembly_with_cpp, .c, .cpp, .h, .hpp, .hm, .hmm, .ll, .bc, .m, .mm => {
		1811	dev.check(.c_compiler);
1811	try create_module.c_source_files.append(arena, .{	1812	try create_module.c_source_files.append(arena, .{
1812	// Populated after module creation.	1813	// Populated after module creation.
1813	.owner = undefined,	1814	.owner = undefined,
...	@@ -1818,6 +1819,7 @@ fn buildOutputType(	...	@@ -1818,6 +1819,7 @@ fn buildOutputType(
1818	});	1819	});
1819	},	1820	},
1820	.rc => {	1821	.rc => {
		1822	dev.check(.win32_resource);
1821	try create_module.rc_source_files.append(arena, .{	1823	try create_module.rc_source_files.append(arena, .{
1822	// Populated after module creation.	1824	// Populated after module creation.
1823	.owner = undefined,	1825	.owner = undefined,
...	@@ -3303,6 +3305,7 @@ fn buildOutputType(	...	@@ -3303,6 +3305,7 @@ fn buildOutputType(
3303	defer thread_pool.deinit();	3305	defer thread_pool.deinit();
3304		3306
3305	for (create_module.c_source_files.items) \|*src\| {	3307	for (create_module.c_source_files.items) \|*src\| {
		3308	dev.check(.c_compiler);
3306	if (!mem.eql(u8, src.src_path, "-")) continue;	3309	if (!mem.eql(u8, src.src_path, "-")) continue;
3307		3310
3308	const ext = src.ext orelse	3311	const ext = src.ext orelse
...	@@ -5008,7 +5011,11 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {	...	@@ -5008,7 +5011,11 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
5008	var http_client: if (dev.env.supports(.fetch_command)) std.http.Client else struct {	5011	var http_client: if (dev.env.supports(.fetch_command)) std.http.Client else struct {
5009	allocator: Allocator,	5012	allocator: Allocator,
5010	fn deinit(_: @This()) void {}	5013	fn deinit(_: @This()) void {}
5011	} = .{ .allocator = gpa };	5014	} = .{
		5015	.allocator = gpa,
		5016	.read_buffer_size = 0x4000,
		5017	.write_buffer_size = 0x4000,
		5018	};
5012	defer http_client.deinit();	5019	defer http_client.deinit();
5013		5020
5014	var unlazy_set: Package.Fetch.JobQueue.UnlazySet = .{};	5021	var unlazy_set: Package.Fetch.JobQueue.UnlazySet = .{};
...	@@ -6815,7 +6822,11 @@ fn cmdFetch(	...	@@ -6815,7 +6822,11 @@ fn cmdFetch(
6815	try thread_pool.init(.{ .allocator = gpa });	6822	try thread_pool.init(.{ .allocator = gpa });
6816	defer thread_pool.deinit();	6823	defer thread_pool.deinit();
6817		6824
6818	var http_client: std.http.Client = .{ .allocator = gpa };	6825	var http_client: std.http.Client = .{
		6826	.allocator = gpa,
		6827	.read_buffer_size = 0x4000,
		6828	.write_buffer_size = 0x4000,
		6829	};
6819	defer http_client.deinit();	6830	defer http_client.deinit();
6820		6831
6821	try http_client.initDefaultProxies(arena);	6832	try http_client.initDefaultProxies(arena);

author	Jacob Young <jacobly@ziglang.org> 2025-04-17 12:29:32-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:27-07:00
log	ffb0e283d7aaaa896cd3db32ca11460ea63c8855
tree	c12b079906590b17d1edd0394b92ee4aa10c4ba7
parent	3b390e4f139220ed11918524288238c289ce0c6d

...	@@ -68,7 +68,7 @@ const PrefixedPath = struct {	...	@@ -68,7 +68,7 @@ const PrefixedPath = struct {
68		68
69	fn findPrefix(cache: *const Cache, file_path: []const u8) !PrefixedPath {	69	fn findPrefix(cache: *const Cache, file_path: []const u8) !PrefixedPath {
70	const gpa = cache.gpa;	70	const gpa = cache.gpa;
71	const resolved_path = try fs.path.resolve(gpa, &[_][]const u8{file_path});	71	const resolved_path = try fs.path.resolve(gpa, &.{file_path});
72	errdefer gpa.free(resolved_path);	72	errdefer gpa.free(resolved_path);
73	return findPrefixResolved(cache, resolved_path);	73	return findPrefixResolved(cache, resolved_path);
74	}	74	}
...	@@ -132,7 +132,7 @@ pub const Hasher = crypto.auth.siphash.SipHash128(1, 3);	...	@@ -132,7 +132,7 @@ pub const Hasher = crypto.auth.siphash.SipHash128(1, 3);
132	/// Initial state with random bytes, that can be copied.	132	/// Initial state with random bytes, that can be copied.
133	/// Refresh this with new random bytes when the manifest	133	/// Refresh this with new random bytes when the manifest
134	/// format is modified in a non-backwards-compatible way.	134	/// format is modified in a non-backwards-compatible way.
135	pub const hasher_init: Hasher = Hasher.init(&[_]u8{	135	pub const hasher_init: Hasher = Hasher.init(&.{
136	0x33, 0x52, 0xa2, 0x84,	136	0x33, 0x52, 0xa2, 0x84,
137	0xcf, 0x17, 0x56, 0x57,	137	0xcf, 0x17, 0x56, 0x57,
138	0x01, 0xbb, 0xcd, 0xe4,	138	0x01, 0xbb, 0xcd, 0xe4,
...	@@ -1143,7 +1143,8 @@ pub const Manifest = struct {	...	@@ -1143,7 +1143,8 @@ pub const Manifest = struct {
1143	}	1143	}
1144		1144
1145	try manifest_file.setEndPos(contents.items.len);	1145	try manifest_file.setEndPos(contents.items.len);
1146	try manifest_file.pwriteAll(contents.items, 0);	1146	var pos: usize = 0;
		1147	while (pos < contents.items.len) pos += try manifest_file.pwrite(contents.items[pos..], pos);
1147	}	1148	}
1148		1149
1149	if (self.want_shared_lock) {	1150	if (self.want_shared_lock) {

build_runner: fix compile errors