Commit d8e26275f29b304772bfeed9359e1ff5fe7038a8 | zig

doc/langref.html.in+2-1

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

doc/langref/bad_default_value.zig+1-1

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

doc/langref/hello.zig+1-2

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

doc/langref/hello_again.zig+1-1

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

lib/compiler/resinator/cli.zig+13-14

 @@ -125,13 +125,12 @@ pub const Diagnostics = struct {
     }
     pub fn renderToStdErr(self: *Diagnostics, args: []const []const u8, config: std.io.tty.Config) void {
-        std.debug.lockStdErr();
+        const stderr = std.debug.lockStderrWriter(&.{});
-        defer std.debug.unlockStdErr();
+        defer std.debug.unlockStderrWriter();
-        const stderr = std.fs.File.stderr().deprecatedWriter();
         self.renderToWriter(args, stderr, config) catch return;
     }
-    pub fn renderToWriter(self: *Diagnostics, args: []const []const u8, writer: anytype, config: std.io.tty.Config) !void {
+    pub fn renderToWriter(self: *Diagnostics, args: []const []const u8, writer: *std.io.Writer, config: std.io.tty.Config) !void {
         for (self.errors.items) |err_details| {
             try renderErrorMessage(writer, config, err_details, args);
         }
 @@ -1403,7 +1402,7 @@ test parsePercent {
     try std.testing.expectError(error.InvalidFormat, parsePercent("~1"));
 }
-pub fn renderErrorMessage(writer: anytype, config: std.io.tty.Config, err_details: Diagnostics.ErrorDetails, args: []const []const u8) !void {
+pub fn renderErrorMessage(writer: *std.io.Writer, config: std.io.tty.Config, err_details: Diagnostics.ErrorDetails, args: []const []const u8) !void {
     try config.setColor(writer, .dim);
     try writer.writeAll("<cli>");
     try config.setColor(writer, .reset);
 @@ -1481,27 +1480,27 @@ pub fn renderErrorMessage(writer: anytype, config: std.io.tty.Config, err_detail
     try writer.writeByte('\n');
     try config.setColor(writer, .green);
-    try writer.writeByteNTimes(' ', prefix.len);
+    try writer.splatByteAll(' ', prefix.len);
     // Special case for when the option is *only* a prefix (e.g. invalid option: -)
     if (err_details.arg_span.prefix_len == arg_with_name.len) {
-        try writer.writeByteNTimes('^', err_details.arg_span.prefix_len);
+        try writer.splatByteAll('^', err_details.arg_span.prefix_len);
     } else {
-        try writer.writeByteNTimes('~', err_details.arg_span.prefix_len);
+        try writer.splatByteAll('~', err_details.arg_span.prefix_len);
-        try writer.writeByteNTimes(' ', err_details.arg_span.name_offset - err_details.arg_span.prefix_len);
+        try writer.splatByteAll(' ', err_details.arg_span.name_offset - err_details.arg_span.prefix_len);
         if (!err_details.arg_span.point_at_next_arg and err_details.arg_span.value_offset == 0) {
             try writer.writeByte('^');
-            try writer.writeByteNTimes('~', name_slice.len - 1);
+            try writer.splatByteAll('~', name_slice.len - 1);
         } else if (err_details.arg_span.value_offset > 0) {
-            try writer.writeByteNTimes('~', err_details.arg_span.value_offset - err_details.arg_span.name_offset);
+            try writer.splatByteAll('~', err_details.arg_span.value_offset - err_details.arg_span.name_offset);
             try writer.writeByte('^');
             if (err_details.arg_span.value_offset < arg_with_name.len) {
-                try writer.writeByteNTimes('~', arg_with_name.len - err_details.arg_span.value_offset - 1);
+                try writer.splatByteAll('~', arg_with_name.len - err_details.arg_span.value_offset - 1);
             }
         } else if (err_details.arg_span.point_at_next_arg) {
-            try writer.writeByteNTimes('~', arg_with_name.len - err_details.arg_span.name_offset + 1);
+            try writer.splatByteAll('~', arg_with_name.len - err_details.arg_span.name_offset + 1);
             try writer.writeByte('^');
             if (next_arg_len > 0) {
-                try writer.writeByteNTimes('~', next_arg_len - 1);
+                try writer.splatByteAll('~', next_arg_len - 1);
             }
         }
     }

lib/compiler/resinator/errors.zig+18-19

 @@ -62,9 +62,8 @@ pub const Diagnostics = struct {
     }
     pub fn renderToStdErr(self: *Diagnostics, cwd: std.fs.Dir, source: []const u8, tty_config: std.io.tty.Config, source_mappings: ?SourceMappings) void {
-        std.debug.lockStdErr();
+        const stderr = std.debug.lockStderrWriter(&.{});
-        defer std.debug.unlockStdErr();
+        defer std.debug.unlockStderrWriter();
-        const stderr = std.fs.File.stderr().deprecatedWriter();
         for (self.errors.items) |err_details| {
             renderErrorMessage(stderr, tty_config, cwd, err_details, source, self.strings.items, source_mappings) catch return;
         }
 @@ -445,7 +444,7 @@ pub const ErrorDetails = struct {
     pub fn render(self: ErrorDetails, writer: anytype, source: []const u8, strings: []const []const u8) !void {
         switch (self.err) {
             .unfinished_string_literal => {
-                return writer.print("unfinished string literal at '{s}', expected closing '\"'", .{self.fmtToken(source)});
+                return writer.print("unfinished string literal at '{f}', expected closing '\"'", .{self.fmtToken(source)});
             },
             .string_literal_too_long => {
                 return writer.print("string literal too long (max is currently {} characters)", .{self.extra.number});
 @@ -524,26 +523,26 @@ pub const ErrorDetails = struct {
                 return writer.print("unsupported code page '{s} (id={})' in #pragma code_page", .{ @tagName(code_page), number });
             },
             .unfinished_raw_data_block => {
-                return writer.print("unfinished raw data block at '{s}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
+                return writer.print("unfinished raw data block at '{f}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
             },
             .unfinished_string_table_block => {
-                return writer.print("unfinished STRINGTABLE block at '{s}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
+                return writer.print("unfinished STRINGTABLE block at '{f}', expected closing '}}' or 'END'", .{self.fmtToken(source)});
             },
             .expected_token => {
-                return writer.print("expected '{s}', got '{s}'", .{ self.extra.expected.nameForErrorDisplay(), self.fmtToken(source) });
+                return writer.print("expected '{s}', got '{f}'", .{ self.extra.expected.nameForErrorDisplay(), self.fmtToken(source) });
             },
             .expected_something_else => {
                 try writer.writeAll("expected ");
                 try self.extra.expected_types.writeCommaSeparated(writer);
-                return writer.print("; got '{s}'", .{self.fmtToken(source)});
+                return writer.print("; got '{f}'", .{self.fmtToken(source)});
             },
             .resource_type_cant_use_raw_data => switch (self.type) {
-                .err, .warning => try writer.print("expected '<filename>', found '{s}' (resource type '{s}' can't use raw data)", .{ self.fmtToken(source), self.extra.resource.nameForErrorDisplay() }),
+                .err, .warning => try writer.print("expected '<filename>', found '{f}' (resource type '{s}' can't use raw data)", .{ self.fmtToken(source), self.extra.resource.nameForErrorDisplay() }),
-                .note => try writer.print("if '{s}' is intended to be a filename, it must be specified as a quoted string literal", .{self.fmtToken(source)}),
+                .note => try writer.print("if '{f}' is intended to be a filename, it must be specified as a quoted string literal", .{self.fmtToken(source)}),
                 .hint => return,
             },
             .id_must_be_ordinal => {
-                try writer.print("id of resource type '{s}' must be an ordinal (u16), got '{s}'", .{ self.extra.resource.nameForErrorDisplay(), self.fmtToken(source) });
+                try writer.print("id of resource type '{s}' must be an ordinal (u16), got '{f}'", .{ self.extra.resource.nameForErrorDisplay(), self.fmtToken(source) });
             },
             .name_or_id_not_allowed => {
                 try writer.print("name or id is not allowed for resource type '{s}'", .{self.extra.resource.nameForErrorDisplay()});
 @@ -559,7 +558,7 @@ pub const ErrorDetails = struct {
                 try writer.writeAll("ASCII character not equivalent to virtual key code");
             },
             .empty_menu_not_allowed => {
-                try writer.print("empty menu of type '{s}' not allowed", .{self.fmtToken(source)});
+                try writer.print("empty menu of type '{f}' not allowed", .{self.fmtToken(source)});
             },
             .rc_would_miscompile_version_value_padding => switch (self.type) {
                 .err, .warning => return writer.print("the padding before this quoted string value would be miscompiled by the Win32 RC compiler", .{}),
 @@ -624,7 +623,7 @@ pub const ErrorDetails = struct {
             .string_already_defined => switch (self.type) {
                 .err, .warning => {
                     const language = self.extra.string_and_language.language;
-                    return writer.print("string with id {d} (0x{X}) already defined for language {}", .{ self.extra.string_and_language.id, self.extra.string_and_language.id, language });
+                    return writer.print("string with id {d} (0x{X}) already defined for language {f}", .{ self.extra.string_and_language.id, self.extra.string_and_language.id, language });
                 },
                 .note => return writer.print("previous definition of string with id {d} (0x{X}) here", .{ self.extra.string_and_language.id, self.extra.string_and_language.id }),
                 .hint => return,
 @@ -639,7 +638,7 @@ pub const ErrorDetails = struct {
                 try writer.print("unable to open file '{s}': {s}", .{ strings[self.extra.file_open_error.filename_string_index], @tagName(self.extra.file_open_error.err) });
             },
             .invalid_accelerator_key => {
-                try writer.print("invalid accelerator key '{s}': {s}", .{ self.fmtToken(source), @tagName(self.extra.accelerator_error.err) });
+                try writer.print("invalid accelerator key '{f}': {s}", .{ self.fmtToken(source), @tagName(self.extra.accelerator_error.err) });
             },
             .accelerator_type_required => {
                 try writer.writeAll("accelerator type [ASCII or VIRTKEY] required when key is an integer");
 @@ -895,7 +894,7 @@ fn cellCount(code_page: SupportedCodePage, source: []const u8, start_index: usiz
 const truncated_str = "<...truncated...>";
-pub fn renderErrorMessage(writer: anytype, tty_config: std.io.tty.Config, cwd: std.fs.Dir, err_details: ErrorDetails, source: []const u8, strings: []const []const u8, source_mappings: ?SourceMappings) !void {
+pub fn renderErrorMessage(writer: *std.io.Writer, tty_config: std.io.tty.Config, cwd: std.fs.Dir, err_details: ErrorDetails, source: []const u8, strings: []const []const u8, source_mappings: ?SourceMappings) !void {
     if (err_details.type == .hint) return;
     const source_line_start = err_details.token.getLineStartForErrorDisplay(source);
 @@ -978,10 +977,10 @@ pub fn renderErrorMessage(writer: anytype, tty_config: std.io.tty.Config, cwd: s
     try tty_config.setColor(writer, .green);
     const num_spaces = truncated_visual_info.point_offset - truncated_visual_info.before_len;
-    try writer.writeByteNTimes(' ', num_spaces);
+    try writer.splatByteAll(' ', num_spaces);
-    try writer.writeByteNTimes('~', truncated_visual_info.before_len);
+    try writer.splatByteAll('~', truncated_visual_info.before_len);
     try writer.writeByte('^');
-    try writer.writeByteNTimes('~', truncated_visual_info.after_len);
+    try writer.splatByteAll('~', truncated_visual_info.after_len);
     try writer.writeByte('\n');
     try tty_config.setColor(writer, .reset);
 @@ -1082,7 +1081,7 @@ const CorrespondingLines = struct {
     buffered_reader: BufferedReaderType,
     code_page: SupportedCodePage,
-    const BufferedReaderType = std.io.BufferedReader(512, std.fs.File.Reader);
+    const BufferedReaderType = std.io.BufferedReader(512, std.fs.File.DeprecatedReader);
     pub fn init(cwd: std.fs.Dir, err_details: ErrorDetails, line_for_comparison: []const u8, corresponding_span: SourceMappings.CorrespondingSpan, corresponding_file: []const u8) !CorrespondingLines {
         // We don't do line comparison for this error, so don't print the note if the line

lib/compiler/resinator/main.zig+10-6

...	@@ -29,7 +29,7 @@ pub fn main() !void {	...	@@ -29,7 +29,7 @@ pub fn main() !void {
29	defer std.process.argsFree(allocator, args);	29	defer std.process.argsFree(allocator, args);
30		30
31	if (args.len < 2) {	31	if (args.len < 2) {
32	try renderErrorMessage(stderr.deprecatedWriter(), stderr_config, .err, "expected zig lib dir as first argument", .{});	32	try renderErrorMessage(std.debug.lockStderrWriter(&.{}), stderr_config, .err, "expected zig lib dir as first argument", .{});
33	std.process.exit(1);	33	std.process.exit(1);
34	}	34	}
35	const zig_lib_dir = args[1];	35	const zig_lib_dir = args[1];
...	@@ -343,7 +343,7 @@ pub fn main() !void {	...	@@ -343,7 +343,7 @@ pub fn main() !void {
343	switch (err) {	343	switch (err) {
344	error.DuplicateResource => {	344	error.DuplicateResource => {
345	const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];	345	const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
346	try error_handler.emitMessage(allocator, .err, "duplicate resource [id: {}, type: {}, language: {}]", .{	346	try error_handler.emitMessage(allocator, .err, "duplicate resource [id: {f}, type: {f}, language: {f}]", .{
347	duplicate_resource.name_value,	347	duplicate_resource.name_value,
348	fmtResourceType(duplicate_resource.type_value),	348	fmtResourceType(duplicate_resource.type_value),
349	duplicate_resource.language,	349	duplicate_resource.language,
...	@@ -352,7 +352,7 @@ pub fn main() !void {	...	@@ -352,7 +352,7 @@ pub fn main() !void {
352	error.ResourceDataTooLong => {	352	error.ResourceDataTooLong => {
353	const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];	353	const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
354	try error_handler.emitMessage(allocator, .err, "resource has a data length that is too large to be written into a coff section", .{});	354	try error_handler.emitMessage(allocator, .err, "resource has a data length that is too large to be written into a coff section", .{});
355	try error_handler.emitMessage(allocator, .note, "the resource with the invalid size is [id: {}, type: {}, language: {}]", .{	355	try error_handler.emitMessage(allocator, .note, "the resource with the invalid size is [id: {f}, type: {f}, language: {f}]", .{
356	overflow_resource.name_value,	356	overflow_resource.name_value,
357	fmtResourceType(overflow_resource.type_value),	357	fmtResourceType(overflow_resource.type_value),
358	overflow_resource.language,	358	overflow_resource.language,
...	@@ -361,7 +361,7 @@ pub fn main() !void {	...	@@ -361,7 +361,7 @@ pub fn main() !void {
361	error.TotalResourceDataTooLong => {	361	error.TotalResourceDataTooLong => {
362	const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];	362	const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
363	try error_handler.emitMessage(allocator, .err, "total resource data exceeds the maximum of the coff 'size of raw data' field", .{});	363	try error_handler.emitMessage(allocator, .err, "total resource data exceeds the maximum of the coff 'size of raw data' field", .{});
364	try error_handler.emitMessage(allocator, .note, "size overflow occurred when attempting to write this resource: [id: {}, type: {}, language: {}]", .{	364	try error_handler.emitMessage(allocator, .note, "size overflow occurred when attempting to write this resource: [id: {f}, type: {f}, language: {f}]", .{
365	overflow_resource.name_value,	365	overflow_resource.name_value,
366	fmtResourceType(overflow_resource.type_value),	366	fmtResourceType(overflow_resource.type_value),
367	overflow_resource.language,	367	overflow_resource.language,
...	@@ -645,7 +645,9 @@ const ErrorHandler = union(enum) {	...	@@ -645,7 +645,9 @@ const ErrorHandler = union(enum) {
645	},	645	},
646	.tty => {	646	.tty => {
647	// extra newline to separate this line from the aro errors	647	// extra newline to separate this line from the aro errors
648	try renderErrorMessage(std.fs.File.stderr().deprecatedWriter(), self.tty, .err, "{s}\n", .{fail_msg});	648	const stderr = std.debug.lockStderrWriter(&.{});
		649	defer std.debug.unlockStderrWriter();
		650	try renderErrorMessage(stderr, self.tty, .err, "{s}\n", .{fail_msg});
649	aro.Diagnostics.render(comp, self.tty);	651	aro.Diagnostics.render(comp, self.tty);
650	},	652	},
651	}	653	}
...	@@ -690,7 +692,9 @@ const ErrorHandler = union(enum) {	...	@@ -690,7 +692,9 @@ const ErrorHandler = union(enum) {
690	try server.serveErrorBundle(error_bundle);	692	try server.serveErrorBundle(error_bundle);
691	},	693	},
692	.tty => {	694	.tty => {
693	try renderErrorMessage(std.fs.File.stderr().deprecatedWriter(), self.tty, msg_type, format, args);	695	const stderr = std.debug.lockStderrWriter(&.{});
		696	defer std.debug.unlockStderrWriter();
		697	try renderErrorMessage(stderr, self.tty, msg_type, format, args);
694	},	698	},
695	}	699	}
696	}	700	}

lib/compiler/resinator/res.zig+2-2

...	@@ -442,7 +442,7 @@ pub const NameOrOrdinal = union(enum) {	...	@@ -442,7 +442,7 @@ pub const NameOrOrdinal = union(enum) {
442	pub fn format(self: NameOrOrdinal, w: *std.io.Writer) !void {	442	pub fn format(self: NameOrOrdinal, w: *std.io.Writer) !void {
443	switch (self) {	443	switch (self) {
444	.name => \|name\| {	444	.name => \|name\| {
445	try w.print("{s}", .{std.unicode.fmtUtf16Le(name)});	445	try w.print("{f}", .{std.unicode.fmtUtf16Le(name)});
446	},	446	},
447	.ordinal => \|ordinal\| {	447	.ordinal => \|ordinal\| {
448	try w.print("{d}", .{ordinal});	448	try w.print("{d}", .{ordinal});
...	@@ -453,7 +453,7 @@ pub const NameOrOrdinal = union(enum) {	...	@@ -453,7 +453,7 @@ pub const NameOrOrdinal = union(enum) {
453	fn formatResourceType(self: NameOrOrdinal, w: *std.io.Writer) std.io.Writer.Error!void {	453	fn formatResourceType(self: NameOrOrdinal, w: *std.io.Writer) std.io.Writer.Error!void {
454	switch (self) {	454	switch (self) {
455	.name => \|name\| {	455	.name => \|name\| {
456	try w.print("{s}", .{std.unicode.fmtUtf16Le(name)});	456	try w.print("{f}", .{std.unicode.fmtUtf16Le(name)});
457	},	457	},
458	.ordinal => \|ordinal\| {	458	.ordinal => \|ordinal\| {
459	if (std.enums.tagName(RT, @enumFromInt(ordinal))) \|predefined_type_name\| {	459	if (std.enums.tagName(RT, @enumFromInt(ordinal))) \|predefined_type_name\| {

lib/compiler/resinator/utils.zig+1-1

...	@@ -86,7 +86,7 @@ pub const ErrorMessageType = enum { err, warning, note };	...	@@ -86,7 +86,7 @@ pub const ErrorMessageType = enum { err, warning, note };
86		86
87	/// Used for generic colored errors/warnings/notes, more context-specific error messages	87	/// Used for generic colored errors/warnings/notes, more context-specific error messages
88	/// are handled elsewhere.	88	/// are handled elsewhere.
89	pub fn renderErrorMessage(writer: anytype, config: std.io.tty.Config, msg_type: ErrorMessageType, comptime format: []const u8, args: anytype) !void {	89	pub fn renderErrorMessage(writer: *std.io.Writer, config: std.io.tty.Config, msg_type: ErrorMessageType, comptime format: []const u8, args: anytype) !void {
90	switch (msg_type) {	90	switch (msg_type) {
91	.err => {	91	.err => {
92	try config.setColor(writer, .bold);	92	try config.setColor(writer, .bold);

lib/fuzzer.zig+12-9

 @@ -9,7 +9,8 @@ pub const std_options = std.Options{
     .logFn = logOverride,
 };
-var log_file: ?std.fs.File = null;
+var log_file_buffer: [256]u8 = undefined;
+var log_file_writer: ?std.fs.File.Writer = null;
 fn logOverride(
     comptime level: std.log.Level,
 @@ -17,15 +18,17 @@ fn logOverride(
     comptime format: []const u8,
     args: anytype,
 ) void {
-    const f = if (log_file) |f| f else f: {
+    const fw = if (log_file_writer) |*f| f else f: {
         const f = fuzzer.cache_dir.createFile("tmp/libfuzzer.log", .{}) catch
             @panic("failed to open fuzzer log file");
-        log_file = f;
+        log_file_writer = f.writer(&log_file_buffer);
-        break :f f;
+        break :f &log_file_writer.?;
     };
     const prefix1 = comptime level.asText();
     const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
-    f.writer().print(prefix1 ++ prefix2 ++ format ++ "\n", args) catch @panic("failed to write to fuzzer log");
+    fw.interface.print(prefix1 ++ prefix2 ++ format ++ "\n", args) catch
+        @panic("failed to write to fuzzer log");
+    fw.interface.flush() catch @panic("failed to flush fuzzer log");
 }
 /// Helps determine run uniqueness in the face of recursion.
 @@ -226,18 +229,18 @@ const Fuzzer = struct {
                         .read = true,
                     }) catch |e| switch (e) {
                         error.PathAlreadyExists => continue,
-                        else => fatal("unable to create '{}{d}: {s}", .{ f.corpus_directory, i, @errorName(err) }),
+                        else => fatal("unable to create '{f}{d}: {s}", .{ f.corpus_directory, i, @errorName(err) }),
                     };
                     errdefer input_file.close();
                     // Initialize the mmap for the current input.
                     f.input = MemoryMappedList.create(input_file, 0, std.heap.page_size_max) catch |e| {
-                        fatal("unable to init memory map for input at '{}{d}': {s}", .{
+                        fatal("unable to init memory map for input at '{f}{d}': {s}", .{
                             f.corpus_directory, i, @errorName(e),
                         });
                     };
                     break;
                 },
-                else => fatal("unable to read '{}{d}': {s}", .{ f.corpus_directory, i, @errorName(err) }),
+                else => fatal("unable to read '{f}{d}': {s}", .{ f.corpus_directory, i, @errorName(err) }),
             };
             errdefer gpa.free(input);
             f.corpus.append(gpa, .{
 @@ -263,7 +266,7 @@ const Fuzzer = struct {
             const sub_path = try std.fmt.allocPrint(gpa, "f/{s}", .{f.unit_test_name});
             f.corpus_directory = .{
                 .handle = f.cache_dir.makeOpenPath(sub_path, .{}) catch |err|
-                    fatal("unable to open corpus directory 'f/{s}': {s}", .{ sub_path, @errorName(err) }),
+                    fatal("unable to open corpus directory 'f/{s}': {t}", .{ sub_path, err }),
                 .path = sub_path,
             };
             initNextInput(f);

lib/std/elf.zig+5-5

lib/std/io/Writer.zig+2

...	@@ -705,6 +705,8 @@ pub fn sendFileReading(w: Writer, file_reader: File.Reader, limit: Limit) File	...	@@ -705,6 +705,8 @@ pub fn sendFileReading(w: Writer, file_reader: File.Reader, limit: Limit) File
705	return n;	705	return n;
706	}	706	}
707		707
		708	/// Number of bytes logically written is returned. This excludes bytes from
		709	/// `buffer` because they have already been logically written.
708	pub fn sendFileAll(w: Writer, file_reader: File.Reader, limit: Limit) FileAllError!usize {	710	pub fn sendFileAll(w: Writer, file_reader: File.Reader, limit: Limit) FileAllError!usize {
709	var remaining = @intFromEnum(limit);	711	var remaining = @intFromEnum(limit);
710	while (remaining > 0) {	712	while (remaining > 0) {

lib/std/os/windows.zig+2-3

 @@ -2812,9 +2812,8 @@ pub fn unexpectedError(err: Win32Error) UnexpectedError {
             buf_wstr.len,
             null,
         );
-        std.debug.print("error.Unexpected: GetLastError({}): {}\n", .{
+        std.debug.print("error.Unexpected: GetLastError({d}): {f}\n", .{
-            @intFromEnum(err),
+            err, std.unicode.fmtUtf16Le(buf_wstr[0..len]),
-            std.unicode.fmtUtf16Le(buf_wstr[0..len]),
         });
         std.debug.dumpCurrentStackTrace(@returnAddress());
     }

lib/std/zig/parser_test.zig+4-4

...	@@ -2744,11 +2744,11 @@ test "zig fmt: preserve spacing" {	...	@@ -2744,11 +2744,11 @@ test "zig fmt: preserve spacing" {
2744	\\const std = @import("std");	2744	\\const std = @import("std");
2745	\\	2745	\\
2746	\\pub fn main() !void {	2746	\\pub fn main() !void {
2747	\\ var stdout_file = std.io.getStdOut;	2747	\\ var stdout_file = std.lol.abcd;
2748	\\ var stdout_file = std.io.getStdOut;	2748	\\ var stdout_file = std.lol.abcd;
2749	\\	2749	\\
2750	\\ var stdout_file = std.io.getStdOut;	2750	\\ var stdout_file = std.lol.abcd;
2751	\\ var stdout_file = std.io.getStdOut;	2751	\\ var stdout_file = std.lol.abcd;
2752	\\}	2752	\\}
2753	\\	2753	\\
2754	);	2754	);

src/main.zig+6-6

test/compare_output.zig+3-286

...	@@ -17,15 +17,6 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -17,15 +17,6 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
17	\\}	17	\\}
18	, "Hello, world!" ++ if (@import("builtin").os.tag == .windows) "\r\n" else "\n");	18	, "Hello, world!" ++ if (@import("builtin").os.tag == .windows) "\r\n" else "\n");
19		19
20	cases.add("hello world without libc",
21	\\const io = @import("std").io;
22	\\
23	\\pub fn main() void {
24	\\ const stdout = io.getStdOut().writer();
25	\\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", .{@as(u32, 12), @as(u16, 0x12), @as(u8, 'a')}) catch unreachable;
26	\\}
27	, "Hello, world!\n 12 12 a\n");
28
29	cases.addC("number literals",	20	cases.addC("number literals",
30	\\const std = @import("std");	21	\\const std = @import("std");
31	\\const builtin = @import("builtin");	22	\\const builtin = @import("builtin");
...	@@ -158,24 +149,6 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -158,24 +149,6 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
158	\\	149	\\
159	);	150	);
160		151
161	cases.add("order-independent declarations",
162	\\const io = @import("std").io;
163	\\const z = io.stdin_fileno;
164	\\const x : @TypeOf(y) = 1234;
165	\\const y : u16 = 5678;
166	\\pub fn main() void {
167	\\ var x_local : i32 = print_ok(x);
168	\\ _ = &x_local;
169	\\}
170	\\fn print_ok(val: @TypeOf(x)) @TypeOf(foo) {
171	\\ _ = val;
172	\\ const stdout = io.getStdOut().writer();
173	\\ stdout.print("OK\n", .{}) catch unreachable;
174	\\ return 0;
175	\\}
176	\\const foo : i32 = 0;
177	, "OK\n");
178
179	cases.addC("expose function pointer to C land",	152	cases.addC("expose function pointer to C land",
180	\\const c = @cImport(@cInclude("stdlib.h"));	153	\\const c = @cImport(@cInclude("stdlib.h"));
181	\\	154	\\
...	@@ -236,267 +209,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -236,267 +209,11 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
236	\\}	209	\\}
237	, "3.25\n3\n3.00\n-0.40\n");	210	, "3.25\n3\n3.00\n-0.40\n");
238		211
239	cases.add("same named methods in incomplete struct",	212	cases.add("valid carriage return example", "const std = @import(\"std\");\r\n" ++ // Testing CRLF line endings are valid
240	\\const io = @import("std").io;
241	\\
242	\\const Foo = struct {
243	\\ field1: Bar,
244	\\
245	\\ fn method(a: *const Foo) bool {
246	\\ _ = a;
247	\\ return true;
248	\\ }
249	\\};
250	\\
251	\\const Bar = struct {
252	\\ field2: i32,
253	\\
254	\\ fn method(b: *const Bar) bool {
255	\\ _ = b;
256	\\ return true;
257	\\ }
258	\\};
259	\\
260	\\pub fn main() void {
261	\\ const bar = Bar {.field2 = 13,};
262	\\ const foo = Foo {.field1 = bar,};
263	\\ const stdout = io.getStdOut().writer();
264	\\ if (!foo.method()) {
265	\\ stdout.print("BAD\n", .{}) catch unreachable;
266	\\ }
267	\\ if (!bar.method()) {
268	\\ stdout.print("BAD\n", .{}) catch unreachable;
269	\\ }
270	\\ stdout.print("OK\n", .{}) catch unreachable;
271	\\}
272	, "OK\n");
273
274	cases.add("defer with only fallthrough",
275	\\const io = @import("std").io;
276	\\pub fn main() void {
277	\\ const stdout = io.getStdOut().writer();
278	\\ stdout.print("before\n", .{}) catch unreachable;
279	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
280	\\ defer stdout.print("defer2\n", .{}) catch unreachable;
281	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
282	\\ stdout.print("after\n", .{}) catch unreachable;
283	\\}
284	, "before\nafter\ndefer3\ndefer2\ndefer1\n");
285
286	cases.add("defer with return",
287	\\const io = @import("std").io;
288	\\const os = @import("std").os;
289	\\pub fn main() void {
290	\\ const stdout = io.getStdOut().writer();
291	\\ stdout.print("before\n", .{}) catch unreachable;
292	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
293	\\ defer stdout.print("defer2\n", .{}) catch unreachable;
294	\\ var gpa: @import("std").heap.GeneralPurposeAllocator(.{}) = .init;
295	\\ defer _ = gpa.deinit();
296	\\ var arena = @import("std").heap.ArenaAllocator.init(gpa.allocator());
297	\\ defer arena.deinit();
298	\\ var args_it = @import("std").process.argsWithAllocator(arena.allocator()) catch unreachable;
299	\\ if (args_it.skip() and !args_it.skip()) return;
300	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
301	\\ stdout.print("after\n", .{}) catch unreachable;
302	\\}
303	, "before\ndefer2\ndefer1\n");
304
305	cases.add("errdefer and it fails",
306	\\const io = @import("std").io;
307	\\pub fn main() void {
308	\\ do_test() catch return;
309	\\}
310	\\fn do_test() !void {
311	\\ const stdout = io.getStdOut().writer();
312	\\ stdout.print("before\n", .{}) catch unreachable;
313	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
314	\\ errdefer stdout.print("deferErr\n", .{}) catch unreachable;
315	\\ try its_gonna_fail();
316	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
317	\\ stdout.print("after\n", .{}) catch unreachable;
318	\\}
319	\\fn its_gonna_fail() !void {
320	\\ return error.IToldYouItWouldFail;
321	\\}
322	, "before\ndeferErr\ndefer1\n");
323
324	cases.add("errdefer and it passes",
325	\\const io = @import("std").io;
326	\\pub fn main() void {
327	\\ do_test() catch return;
328	\\}
329	\\fn do_test() !void {
330	\\ const stdout = io.getStdOut().writer();
331	\\ stdout.print("before\n", .{}) catch unreachable;
332	\\ defer stdout.print("defer1\n", .{}) catch unreachable;
333	\\ errdefer stdout.print("deferErr\n", .{}) catch unreachable;
334	\\ try its_gonna_pass();
335	\\ defer stdout.print("defer3\n", .{}) catch unreachable;
336	\\ stdout.print("after\n", .{}) catch unreachable;
337	\\}
338	\\fn its_gonna_pass() anyerror!void { }
339	, "before\nafter\ndefer3\ndefer1\n");
340
341	cases.addCase(x: {
342	var tc = cases.create("@embedFile",
343	\\const foo_txt = @embedFile("foo.txt");
344	\\const io = @import("std").io;
345	\\
346	\\pub fn main() void {
347	\\ const stdout = io.getStdOut().writer();
348	\\ stdout.print(foo_txt, .{}) catch unreachable;
349	\\}
350	, "1234\nabcd\n");
351
352	tc.addSourceFile("foo.txt", "1234\nabcd\n");
353
354	break :x tc;
355	});
356
357	cases.addCase(x: {
358	var tc = cases.create("parsing args",
359	\\const std = @import("std");
360	\\const io = std.io;
361	\\const os = std.os;
362	\\
363	\\pub fn main() !void {
364	\\ var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
365	\\ defer _ = gpa.deinit();
366	\\ var arena = std.heap.ArenaAllocator.init(gpa.allocator());
367	\\ defer arena.deinit();
368	\\ var args_it = try std.process.argsWithAllocator(arena.allocator());
369	\\ const stdout = io.getStdOut().writer();
370	\\ var index: usize = 0;
371	\\ _ = args_it.skip();
372	\\ while (args_it.next()) \|arg\| : (index += 1) {
373	\\ try stdout.print("{}: {s}\n", .{index, arg});
374	\\ }
375	\\}
376	,
377	\\0: first arg
378	\\1: 'a' 'b' \
379	\\2: bare
380	\\3: ba""re
381	\\4: "
382	\\5: last arg
383	\\
384	);
385
386	tc.setCommandLineArgs(&[_][]const u8{
387	"first arg",
388	"'a' 'b' \\",
389	"bare",
390	"ba\"\"re",
391	"\"",
392	"last arg",
393	});
394
395	break :x tc;
396	});
397
398	cases.addCase(x: {
399	var tc = cases.create("parsing args new API",
400	\\const std = @import("std");
401	\\const io = std.io;
402	\\const os = std.os;
403	\\
404	\\pub fn main() !void {
405	\\ var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
406	\\ defer _ = gpa.deinit();
407	\\ var arena = std.heap.ArenaAllocator.init(gpa.allocator());
408	\\ defer arena.deinit();
409	\\ var args_it = try std.process.argsWithAllocator(arena.allocator());
410	\\ const stdout = io.getStdOut().writer();
411	\\ var index: usize = 0;
412	\\ _ = args_it.skip();
413	\\ while (args_it.next()) \|arg\| : (index += 1) {
414	\\ try stdout.print("{}: {s}\n", .{index, arg});
415	\\ }
416	\\}
417	,
418	\\0: first arg
419	\\1: 'a' 'b' \
420	\\2: bare
421	\\3: ba""re
422	\\4: "
423	\\5: last arg
424	\\
425	);
426
427	tc.setCommandLineArgs(&[_][]const u8{
428	"first arg",
429	"'a' 'b' \\",
430	"bare",
431	"ba\"\"re",
432	"\"",
433	"last arg",
434	});
435
436	break :x tc;
437	});
438
439	// It is required to override the log function in order to print to stdout instead of stderr
440	cases.add("std.log per scope log level override",
441	\\const std = @import("std");
442	\\
443	\\pub const std_options: std.Options = .{
444	\\ .log_level = .debug,
445	\\
446	\\ .log_scope_levels = &.{
447	\\ .{ .scope = .a, .level = .warn },
448	\\ .{ .scope = .c, .level = .err },
449	\\ },
450	\\ .logFn = log,
451	\\};
452	\\
453	\\const loga = std.log.scoped(.a);
454	\\const logb = std.log.scoped(.b);
455	\\const logc = std.log.scoped(.c);
456	\\
457	\\pub fn main() !void {
458	\\ loga.debug("", .{});
459	\\ logb.debug("", .{});
460	\\ logc.debug("", .{});
461	\\
462	\\ loga.info("", .{});
463	\\ logb.info("", .{});
464	\\ logc.info("", .{});
465	\\
466	\\ loga.warn("", .{});
467	\\ logb.warn("", .{});
468	\\ logc.warn("", .{});
469	\\
470	\\ loga.err("", .{});
471	\\ logb.err("", .{});
472	\\ logc.err("", .{});
473	\\}
474	\\pub fn log(
475	\\ comptime level: std.log.Level,
476	\\ comptime scope: @TypeOf(.EnumLiteral),
477	\\ comptime format: []const u8,
478	\\ args: anytype,
479	\\) void {
480	\\ const level_txt = comptime level.asText();
481	\\ const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "):";
482	\\ const stdout = std.io.getStdOut().writer();
483	\\ nosuspend stdout.print(level_txt ++ prefix2 ++ format ++ "\n", args) catch return;
484	\\}
485	,
486	\\debug(b):
487	\\info(b):
488	\\warning(a):
489	\\warning(b):
490	\\error(a):
491	\\error(b):
492	\\error(c):
493	\\
494	);
495
496	cases.add("valid carriage return example", "const io = @import(\"std\").io;\r\n" ++ // Testing CRLF line endings are valid
497	"\r\n" ++	213	"\r\n" ++
498	"pub \r fn main() void {\r\n" ++ // Testing isolated carriage return as whitespace is valid	214	"pub \r fn main() void {\r\n" ++ // Testing isolated carriage return as whitespace is valid
499	" const stdout = io.getStdOut().writer();\r\n" ++	215	" var file_writer = std.fs.File.stdout().writerStreaming(&.{});\r\n" ++
		216	" const stdout = &file_writer.interface;\r\n" ++
500	" stdout.print(\\\\A Multiline\r\n" ++ // testing CRLF at end of multiline string line is valid and normalises to \n in the output	217	" stdout.print(\\\\A Multiline\r\n" ++ // testing CRLF at end of multiline string line is valid and normalises to \n in the output
501	" \\\\String\r\n" ++	218	" \\\\String\r\n" ++
502	" , .{}) catch unreachable;\r\n" ++	219	" , .{}) catch unreachable;\r\n" ++

test/incremental/add_decl+7-7

...	@@ -6,7 +6,7 @@	...	@@ -6,7 +6,7 @@
6	#file=main.zig	6	#file=main.zig
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	try std.io.getStdOut().writeAll(foo);	9	try std.fs.File.stdout().writeAll(foo);
10	}	10	}
11	const foo = "good morning\n";	11	const foo = "good morning\n";
12	#expect_stdout="good morning\n"	12	#expect_stdout="good morning\n"
...	@@ -15,7 +15,7 @@ const foo = "good morning\n";	...	@@ -15,7 +15,7 @@ const foo = "good morning\n";
15	#file=main.zig	15	#file=main.zig
16	const std = @import("std");	16	const std = @import("std");
17	pub fn main() !void {	17	pub fn main() !void {
18	try std.io.getStdOut().writeAll(foo);	18	try std.fs.File.stdout().writeAll(foo);
19	}	19	}
20	const foo = "good morning\n";	20	const foo = "good morning\n";
21	const bar = "good evening\n";	21	const bar = "good evening\n";
...	@@ -25,7 +25,7 @@ const bar = "good evening\n";	...	@@ -25,7 +25,7 @@ const bar = "good evening\n";
25	#file=main.zig	25	#file=main.zig
26	const std = @import("std");	26	const std = @import("std");
27	pub fn main() !void {	27	pub fn main() !void {
28	try std.io.getStdOut().writeAll(bar);	28	try std.fs.File.stdout().writeAll(bar);
29	}	29	}
30	const foo = "good morning\n";	30	const foo = "good morning\n";
31	const bar = "good evening\n";	31	const bar = "good evening\n";
...	@@ -35,17 +35,17 @@ const bar = "good evening\n";	...	@@ -35,17 +35,17 @@ const bar = "good evening\n";
35	#file=main.zig	35	#file=main.zig
36	const std = @import("std");	36	const std = @import("std");
37	pub fn main() !void {	37	pub fn main() !void {
38	try std.io.getStdOut().writeAll(qux);	38	try std.fs.File.stdout().writeAll(qux);
39	}	39	}
40	const foo = "good morning\n";	40	const foo = "good morning\n";
41	const bar = "good evening\n";	41	const bar = "good evening\n";
42	#expect_error=main.zig:3:37: error: use of undeclared identifier 'qux'	42	#expect_error=main.zig:3:39: error: use of undeclared identifier 'qux'
43		43
44	#update=add missing declaration	44	#update=add missing declaration
45	#file=main.zig	45	#file=main.zig
46	const std = @import("std");	46	const std = @import("std");
47	pub fn main() !void {	47	pub fn main() !void {
48	try std.io.getStdOut().writeAll(qux);	48	try std.fs.File.stdout().writeAll(qux);
49	}	49	}
50	const foo = "good morning\n";	50	const foo = "good morning\n";
51	const bar = "good evening\n";	51	const bar = "good evening\n";
...	@@ -56,7 +56,7 @@ const qux = "good night\n";	...	@@ -56,7 +56,7 @@ const qux = "good night\n";
56	#file=main.zig	56	#file=main.zig
57	const std = @import("std");	57	const std = @import("std");
58	pub fn main() !void {	58	pub fn main() !void {
59	try std.io.getStdOut().writeAll(qux);	59	try std.fs.File.stdout().writeAll(qux);
60	}	60	}
61	const qux = "good night\n";	61	const qux = "good night\n";
62	#expect_stdout="good night\n"	62	#expect_stdout="good night\n"

test/incremental/add_decl_namespaced+7-7

...	@@ -6,7 +6,7 @@	...	@@ -6,7 +6,7 @@
6	#file=main.zig	6	#file=main.zig
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	try std.io.getStdOut().writeAll(@This().foo);	9	try std.fs.File.stdout().writeAll(@This().foo);
10	}	10	}
11	const foo = "good morning\n";	11	const foo = "good morning\n";
12	#expect_stdout="good morning\n"	12	#expect_stdout="good morning\n"
...	@@ -15,7 +15,7 @@ const foo = "good morning\n";	...	@@ -15,7 +15,7 @@ const foo = "good morning\n";
15	#file=main.zig	15	#file=main.zig
16	const std = @import("std");	16	const std = @import("std");
17	pub fn main() !void {	17	pub fn main() !void {
18	try std.io.getStdOut().writeAll(@This().foo);	18	try std.fs.File.stdout().writeAll(@This().foo);
19	}	19	}
20	const foo = "good morning\n";	20	const foo = "good morning\n";
21	const bar = "good evening\n";	21	const bar = "good evening\n";
...	@@ -25,7 +25,7 @@ const bar = "good evening\n";	...	@@ -25,7 +25,7 @@ const bar = "good evening\n";
25	#file=main.zig	25	#file=main.zig
26	const std = @import("std");	26	const std = @import("std");
27	pub fn main() !void {	27	pub fn main() !void {
28	try std.io.getStdOut().writeAll(@This().bar);	28	try std.fs.File.stdout().writeAll(@This().bar);
29	}	29	}
30	const foo = "good morning\n";	30	const foo = "good morning\n";
31	const bar = "good evening\n";	31	const bar = "good evening\n";
...	@@ -35,18 +35,18 @@ const bar = "good evening\n";	...	@@ -35,18 +35,18 @@ const bar = "good evening\n";
35	#file=main.zig	35	#file=main.zig
36	const std = @import("std");	36	const std = @import("std");
37	pub fn main() !void {	37	pub fn main() !void {
38	try std.io.getStdOut().writeAll(@This().qux);	38	try std.fs.File.stdout().writeAll(@This().qux);
39	}	39	}
40	const foo = "good morning\n";	40	const foo = "good morning\n";
41	const bar = "good evening\n";	41	const bar = "good evening\n";
42	#expect_error=main.zig:3:44: error: root source file struct 'main' has no member named 'qux'	42	#expect_error=main.zig:3:46: error: root source file struct 'main' has no member named 'qux'
43	#expect_error=main.zig:1:1: note: struct declared here	43	#expect_error=main.zig:1:1: note: struct declared here
44		44
45	#update=add missing declaration	45	#update=add missing declaration
46	#file=main.zig	46	#file=main.zig
47	const std = @import("std");	47	const std = @import("std");
48	pub fn main() !void {	48	pub fn main() !void {
49	try std.io.getStdOut().writeAll(@This().qux);	49	try std.fs.File.stdout().writeAll(@This().qux);
50	}	50	}
51	const foo = "good morning\n";	51	const foo = "good morning\n";
52	const bar = "good evening\n";	52	const bar = "good evening\n";
...	@@ -57,7 +57,7 @@ const qux = "good night\n";	...	@@ -57,7 +57,7 @@ const qux = "good night\n";
57	#file=main.zig	57	#file=main.zig
58	const std = @import("std");	58	const std = @import("std");
59	pub fn main() !void {	59	pub fn main() !void {
60	try std.io.getStdOut().writeAll(@This().qux);	60	try std.fs.File.stdout().writeAll(@This().qux);
61	}	61	}
62	const qux = "good night\n";	62	const qux = "good night\n";
63	#expect_stdout="good night\n"	63	#expect_stdout="good night\n"

test/incremental/bad_import+2-2

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	#file=main.zig	7	#file=main.zig
8	pub fn main() !void {	8	pub fn main() !void {
9	_ = @import("foo.zig");	9	_ = @import("foo.zig");
10	try std.io.getStdOut().writeAll("success\n");	10	try std.fs.File.stdout().writeAll("success\n");
11	}	11	}
12	const std = @import("std");	12	const std = @import("std");
13	#file=foo.zig	13	#file=foo.zig
...	@@ -29,7 +29,7 @@ comptime {	...	@@ -29,7 +29,7 @@ comptime {
29	#file=main.zig	29	#file=main.zig
30	pub fn main() !void {	30	pub fn main() !void {
31	//_ = @import("foo.zig");	31	//_ = @import("foo.zig");
32	try std.io.getStdOut().writeAll("success\n");	32	try std.fs.File.stdout().writeAll("success\n");
33	}	33	}
34	const std = @import("std");	34	const std = @import("std");
35	#expect_stdout="success\n"	35	#expect_stdout="success\n"

test/incremental/change_embed_file+3-3

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	const std = @import("std");	7	const std = @import("std");
8	const string = @embedFile("string.txt");	8	const string = @embedFile("string.txt");
9	pub fn main() !void {	9	pub fn main() !void {
10	try std.io.getStdOut().writeAll(string);	10	try std.fs.File.stdout().writeAll(string);
11	}	11	}
12	#file=string.txt	12	#file=string.txt
13	Hello, World!	13	Hello, World!
...	@@ -27,7 +27,7 @@ Hello again, World!	...	@@ -27,7 +27,7 @@ Hello again, World!
27	const std = @import("std");	27	const std = @import("std");
28	const string = @embedFile("string.txt");	28	const string = @embedFile("string.txt");
29	pub fn main() !void {	29	pub fn main() !void {
30	try std.io.getStdOut().writeAll("a hardcoded string\n");	30	try std.fs.File.stdout().writeAll("a hardcoded string\n");
31	}	31	}
32	#expect_stdout="a hardcoded string\n"	32	#expect_stdout="a hardcoded string\n"
33		33
...	@@ -36,7 +36,7 @@ pub fn main() !void {	...	@@ -36,7 +36,7 @@ pub fn main() !void {
36	const std = @import("std");	36	const std = @import("std");
37	const string = @embedFile("string.txt");	37	const string = @embedFile("string.txt");
38	pub fn main() !void {	38	pub fn main() !void {
39	try std.io.getStdOut().writeAll(string);	39	try std.fs.File.stdout().writeAll(string);
40	}	40	}
41	#expect_error=main.zig:2:27: error: unable to open 'string.txt': FileNotFound	41	#expect_error=main.zig:2:27: error: unable to open 'string.txt': FileNotFound
42		42

test/incremental/change_enum_tag_type+6-3

...	@@ -14,7 +14,8 @@ const Foo = enum(Tag) {	...	@@ -14,7 +14,8 @@ const Foo = enum(Tag) {
14	pub fn main() !void {	14	pub fn main() !void {
15	var val: Foo = undefined;	15	var val: Foo = undefined;
16	val = .a;	16	val = .a;
17	try std.io.getStdOut().writer().print("{s}\n", .{@tagName(val)});	17	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		18	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
18	}	19	}
19	const std = @import("std");	20	const std = @import("std");
20	#expect_stdout="a\n"	21	#expect_stdout="a\n"
...	@@ -31,7 +32,8 @@ const Foo = enum(Tag) {	...	@@ -31,7 +32,8 @@ const Foo = enum(Tag) {
31	pub fn main() !void {	32	pub fn main() !void {
32	var val: Foo = undefined;	33	var val: Foo = undefined;
33	val = .a;	34	val = .a;
34	try std.io.getStdOut().writer().print("{s}\n", .{@tagName(val)});	35	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		36	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
35	}	37	}
36	comptime {	38	comptime {
37	// These can't be true at the same time; analysis should stop as soon as it sees `Foo`	39	// These can't be true at the same time; analysis should stop as soon as it sees `Foo`
...	@@ -53,7 +55,8 @@ const Foo = enum(Tag) {	...	@@ -53,7 +55,8 @@ const Foo = enum(Tag) {
53	pub fn main() !void {	55	pub fn main() !void {
54	var val: Foo = undefined;	56	var val: Foo = undefined;
55	val = .a;	57	val = .a;
56	try std.io.getStdOut().writer().print("{s}\n", .{@tagName(val)});	58	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		59	try stdout_writer.interface.print("{s}\n", .{@tagName(val)});
57	}	60	}
58	const std = @import("std");	61	const std = @import("std");
59	#expect_stdout="a\n"	62	#expect_stdout="a\n"

test/incremental/change_exports+12-6

...	@@ -16,7 +16,8 @@ pub fn main() !void {	...	@@ -16,7 +16,8 @@ pub fn main() !void {
16	extern const bar: u32;	16	extern const bar: u32;
17	};	17	};
18	S.foo();	18	S.foo();
19	try std.io.getStdOut().writer().print("{}\n", .{S.bar});	19	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		20	try stdout_writer.interface.print("{}\n", .{S.bar});
20	}	21	}
21	const std = @import("std");	22	const std = @import("std");
22	#expect_stdout="123\n"	23	#expect_stdout="123\n"
...	@@ -37,7 +38,8 @@ pub fn main() !void {	...	@@ -37,7 +38,8 @@ pub fn main() !void {
37	extern const other: u32;	38	extern const other: u32;
38	};	39	};
39	S.foo();	40	S.foo();
40	try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });	41	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		42	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
41	}	43	}
42	const std = @import("std");	44	const std = @import("std");
43	#expect_error=main.zig:6:5: error: exported symbol collision: foo	45	#expect_error=main.zig:6:5: error: exported symbol collision: foo
...	@@ -59,7 +61,8 @@ pub fn main() !void {	...	@@ -59,7 +61,8 @@ pub fn main() !void {
59	extern const other: u32;	61	extern const other: u32;
60	};	62	};
61	S.foo();	63	S.foo();
62	try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });	64	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		65	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
63	}	66	}
64	const std = @import("std");	67	const std = @import("std");
65	#expect_stdout="123 456\n"	68	#expect_stdout="123 456\n"
...	@@ -83,7 +86,8 @@ pub fn main() !void {	...	@@ -83,7 +86,8 @@ pub fn main() !void {
83	extern const other: u32;	86	extern const other: u32;
84	};	87	};
85	S.foo();	88	S.foo();
86	try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });	89	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		90	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
87	}	91	}
88	const std = @import("std");	92	const std = @import("std");
89	#expect_stdout="123 456\n"	93	#expect_stdout="123 456\n"
...	@@ -128,7 +132,8 @@ pub fn main() !void {	...	@@ -128,7 +132,8 @@ pub fn main() !void {
128	extern const other: u32;	132	extern const other: u32;
129	};	133	};
130	S.foo();	134	S.foo();
131	try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });	135	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		136	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
132	}	137	}
133	const std = @import("std");	138	const std = @import("std");
134	#expect_stdout="123 456\n"	139	#expect_stdout="123 456\n"
...	@@ -152,7 +157,8 @@ pub fn main() !void {	...	@@ -152,7 +157,8 @@ pub fn main() !void {
152	extern const other: u32;	157	extern const other: u32;
153	};	158	};
154	S.foo();	159	S.foo();
155	try std.io.getStdOut().writer().print("{} {}\n", .{ S.bar, S.other });	160	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		161	try stdout_writer.interface.print("{} {}\n", .{ S.bar, S.other });
156	}	162	}
157	const std = @import("std");	163	const std = @import("std");
158	#expect_error=main.zig:5:5: error: exported symbol collision: bar	164	#expect_error=main.zig:5:5: error: exported symbol collision: bar

test/incremental/change_fn_type+6-3

...	@@ -7,7 +7,8 @@ pub fn main() !void {	...	@@ -7,7 +7,8 @@ pub fn main() !void {
7	try foo(123);	7	try foo(123);
8	}	8	}
9	fn foo(x: u8) !void {	9	fn foo(x: u8) !void {
10	return std.io.getStdOut().writer().print("{d}\n", .{x});	10	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		11	return stdout_writer.interface.print("{d}\n", .{x});
11	}	12	}
12	const std = @import("std");	13	const std = @import("std");
13	#expect_stdout="123\n"	14	#expect_stdout="123\n"
...	@@ -18,7 +19,8 @@ pub fn main() !void {	...	@@ -18,7 +19,8 @@ pub fn main() !void {
18	try foo(123);	19	try foo(123);
19	}	20	}
20	fn foo(x: i64) !void {	21	fn foo(x: i64) !void {
21	return std.io.getStdOut().writer().print("{d}\n", .{x});	22	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		23	return stdout_writer.interface.print("{d}\n", .{x});
22	}	24	}
23	const std = @import("std");	25	const std = @import("std");
24	#expect_stdout="123\n"	26	#expect_stdout="123\n"
...	@@ -29,7 +31,8 @@ pub fn main() !void {	...	@@ -29,7 +31,8 @@ pub fn main() !void {
29	try foo(-42);	31	try foo(-42);
30	}	32	}
31	fn foo(x: i64) !void {	33	fn foo(x: i64) !void {
32	return std.io.getStdOut().writer().print("{d}\n", .{x});	34	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		35	return stdout_writer.interface.print("{d}\n", .{x});
33	}	36	}
34	const std = @import("std");	37	const std = @import("std");
35	#expect_stdout="-42\n"	38	#expect_stdout="-42\n"

test/incremental/change_generic_line_number+2-2

...	@@ -6,7 +6,7 @@ const std = @import("std");	...	@@ -6,7 +6,7 @@ const std = @import("std");
6	fn Printer(message: []const u8) type {	6	fn Printer(message: []const u8) type {
7	return struct {	7	return struct {
8	fn print() !void {	8	fn print() !void {
9	try std.io.getStdOut().writeAll(message);	9	try std.fs.File.stdout().writeAll(message);
10	}	10	}
11	};	11	};
12	}	12	}
...	@@ -22,7 +22,7 @@ const std = @import("std");	...	@@ -22,7 +22,7 @@ const std = @import("std");
22	fn Printer(message: []const u8) type {	22	fn Printer(message: []const u8) type {
23	return struct {	23	return struct {
24	fn print() !void {	24	fn print() !void {
25	try std.io.getStdOut().writeAll(message);	25	try std.fs.File.stdout().writeAll(message);
26	}	26	}
27	};	27	};
28	}	28	}

test/incremental/change_line_number+2-2

...	@@ -4,7 +4,7 @@	...	@@ -4,7 +4,7 @@
4	#file=main.zig	4	#file=main.zig
5	const std = @import("std");	5	const std = @import("std");
6	pub fn main() !void {	6	pub fn main() !void {
7	try std.io.getStdOut().writeAll("foo\n");	7	try std.fs.File.stdout().writeAll("foo\n");
8	}	8	}
9	#expect_stdout="foo\n"	9	#expect_stdout="foo\n"
10	#update=change line number	10	#update=change line number
...	@@ -12,6 +12,6 @@ pub fn main() !void {	...	@@ -12,6 +12,6 @@ pub fn main() !void {
12	const std = @import("std");	12	const std = @import("std");
13		13
14	pub fn main() !void {	14	pub fn main() !void {
15	try std.io.getStdOut().writeAll("foo\n");	15	try std.fs.File.stdout().writeAll("foo\n");
16	}	16	}
17	#expect_stdout="foo\n"	17	#expect_stdout="foo\n"

test/incremental/change_panic_handler+6-3

...	@@ -11,7 +11,8 @@ pub fn main() !u8 {	...	@@ -11,7 +11,8 @@ pub fn main() !u8 {
11	}	11	}
12	pub const panic = std.debug.FullPanic(myPanic);	12	pub const panic = std.debug.FullPanic(myPanic);
13	fn myPanic(msg: []const u8, _: ?usize) noreturn {	13	fn myPanic(msg: []const u8, _: ?usize) noreturn {
14	std.io.getStdOut().writer().print("panic message: {s}\n", .{msg}) catch {};	14	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		15	stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
15	std.process.exit(0);	16	std.process.exit(0);
16	}	17	}
17	const std = @import("std");	18	const std = @import("std");
...	@@ -27,7 +28,8 @@ pub fn main() !u8 {	...	@@ -27,7 +28,8 @@ pub fn main() !u8 {
27	}	28	}
28	pub const panic = std.debug.FullPanic(myPanic);	29	pub const panic = std.debug.FullPanic(myPanic);
29	fn myPanic(msg: []const u8, _: ?usize) noreturn {	30	fn myPanic(msg: []const u8, _: ?usize) noreturn {
30	std.io.getStdOut().writer().print("new panic message: {s}\n", .{msg}) catch {};	31	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		32	stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
31	std.process.exit(0);	33	std.process.exit(0);
32	}	34	}
33	const std = @import("std");	35	const std = @import("std");
...	@@ -43,7 +45,8 @@ pub fn main() !u8 {	...	@@ -43,7 +45,8 @@ pub fn main() !u8 {
43	}	45	}
44	pub const panic = std.debug.FullPanic(myPanicNew);	46	pub const panic = std.debug.FullPanic(myPanicNew);
45	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {	47	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
46	std.io.getStdOut().writer().print("third panic message: {s}\n", .{msg}) catch {};	48	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		49	stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
47	std.process.exit(0);	50	std.process.exit(0);
48	}	51	}
49	const std = @import("std");	52	const std = @import("std");

test/incremental/change_panic_handler_explicit+6-3

...	@@ -41,7 +41,8 @@ pub const panic = struct {	...	@@ -41,7 +41,8 @@ pub const panic = struct {
41	pub const noreturnReturned = no_panic.noreturnReturned;	41	pub const noreturnReturned = no_panic.noreturnReturned;
42	};	42	};
43	fn myPanic(msg: []const u8, _: ?usize) noreturn {	43	fn myPanic(msg: []const u8, _: ?usize) noreturn {
44	std.io.getStdOut().writer().print("panic message: {s}\n", .{msg}) catch {};	44	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		45	stdout_writer.interface.print("panic message: {s}\n", .{msg}) catch {};
45	std.process.exit(0);	46	std.process.exit(0);
46	}	47	}
47	const std = @import("std");	48	const std = @import("std");
...	@@ -87,7 +88,8 @@ pub const panic = struct {	...	@@ -87,7 +88,8 @@ pub const panic = struct {
87	pub const noreturnReturned = no_panic.noreturnReturned;	88	pub const noreturnReturned = no_panic.noreturnReturned;
88	};	89	};
89	fn myPanic(msg: []const u8, _: ?usize) noreturn {	90	fn myPanic(msg: []const u8, _: ?usize) noreturn {
90	std.io.getStdOut().writer().print("new panic message: {s}\n", .{msg}) catch {};	91	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		92	stdout_writer.interface.print("new panic message: {s}\n", .{msg}) catch {};
91	std.process.exit(0);	93	std.process.exit(0);
92	}	94	}
93	const std = @import("std");	95	const std = @import("std");
...	@@ -133,7 +135,8 @@ pub const panic = struct {	...	@@ -133,7 +135,8 @@ pub const panic = struct {
133	pub const noreturnReturned = no_panic.noreturnReturned;	135	pub const noreturnReturned = no_panic.noreturnReturned;
134	};	136	};
135	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {	137	fn myPanicNew(msg: []const u8, _: ?usize) noreturn {
136	std.io.getStdOut().writer().print("third panic message: {s}\n", .{msg}) catch {};	138	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		139	stdout_writer.interface.print("third panic message: {s}\n", .{msg}) catch {};
137	std.process.exit(0);	140	std.process.exit(0);
138	}	141	}
139	const std = @import("std");	142	const std = @import("std");

test/incremental/change_shift_op+4-2

...	@@ -8,7 +8,8 @@ pub fn main() !void {	...	@@ -8,7 +8,8 @@ pub fn main() !void {
8	try foo(0x1300);	8	try foo(0x1300);
9	}	9	}
10	fn foo(x: u16) !void {	10	fn foo(x: u16) !void {
11	try std.io.getStdOut().writer().print("0x{x}\n", .{x << 4});	11	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		12	try stdout_writer.interface.print("0x{x}\n", .{x << 4});
12	}	13	}
13	const std = @import("std");	14	const std = @import("std");
14	#expect_stdout="0x3000\n"	15	#expect_stdout="0x3000\n"
...	@@ -18,7 +19,8 @@ pub fn main() !void {	...	@@ -18,7 +19,8 @@ pub fn main() !void {
18	try foo(0x1300);	19	try foo(0x1300);
19	}	20	}
20	fn foo(x: u16) !void {	21	fn foo(x: u16) !void {
21	try std.io.getStdOut().writer().print("0x{x}\n", .{x >> 4});	22	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		23	try stdout_writer.interface.print("0x{x}\n", .{x >> 4});
22	}	24	}
23	const std = @import("std");	25	const std = @import("std");
24	#expect_stdout="0x130\n"	26	#expect_stdout="0x130\n"

test/incremental/change_struct_same_fields+6-3

...	@@ -10,7 +10,8 @@ pub fn main() !void {	...	@@ -10,7 +10,8 @@ pub fn main() !void {
10	try foo(&val);	10	try foo(&val);
11	}	11	}
12	fn foo(val: *const S) !void {	12	fn foo(val: *const S) !void {
13	try std.io.getStdOut().writer().print(	13	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		14	try stdout_writer.interface.print(
14	"{d} {d}\n",	15	"{d} {d}\n",
15	.{ val.x, val.y },	16	.{ val.x, val.y },
16	);	17	);
...	@@ -26,7 +27,8 @@ pub fn main() !void {	...	@@ -26,7 +27,8 @@ pub fn main() !void {
26	try foo(&val);	27	try foo(&val);
27	}	28	}
28	fn foo(val: *const S) !void {	29	fn foo(val: *const S) !void {
29	try std.io.getStdOut().writer().print(	30	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		31	try stdout_writer.interface.print(
30	"{d} {d}\n",	32	"{d} {d}\n",
31	.{ val.x, val.y },	33	.{ val.x, val.y },
32	);	34	);
...	@@ -42,7 +44,8 @@ pub fn main() !void {	...	@@ -42,7 +44,8 @@ pub fn main() !void {
42	try foo(&val);	44	try foo(&val);
43	}	45	}
44	fn foo(val: *const S) !void {	46	fn foo(val: *const S) !void {
45	try std.io.getStdOut().writer().print(	47	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		48	try stdout_writer.interface.print(
46	"{d} {d}\n",	49	"{d} {d}\n",
47	.{ val.x, val.y },	50	.{ val.x, val.y },
48	);	51	);

test/incremental/change_zon_file+3-3

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	const std = @import("std");	7	const std = @import("std");
8	const message: []const u8 = @import("message.zon");	8	const message: []const u8 = @import("message.zon");
9	pub fn main() !void {	9	pub fn main() !void {
10	try std.io.getStdOut().writeAll(message);	10	try std.fs.File.stdout().writeAll(message);
11	}	11	}
12	#file=message.zon	12	#file=message.zon
13	"Hello, World!\n"	13	"Hello, World!\n"
...	@@ -28,7 +28,7 @@ pub fn main() !void {	...	@@ -28,7 +28,7 @@ pub fn main() !void {
28	const std = @import("std");	28	const std = @import("std");
29	const message: []const u8 = @import("message.zon");	29	const message: []const u8 = @import("message.zon");
30	pub fn main() !void {	30	pub fn main() !void {
31	try std.io.getStdOut().writeAll("a hardcoded string\n");	31	try std.fs.File.stdout().writeAll("a hardcoded string\n");
32	}	32	}
33	#expect_error=message.zon:1:1: error: unable to load 'message.zon': FileNotFound	33	#expect_error=message.zon:1:1: error: unable to load 'message.zon': FileNotFound
34	#expect_error=main.zig:2:37: note: file imported here	34	#expect_error=main.zig:2:37: note: file imported here
...	@@ -43,6 +43,6 @@ pub fn main() !void {	...	@@ -43,6 +43,6 @@ pub fn main() !void {
43	const std = @import("std");	43	const std = @import("std");
44	const message: []const u8 = @import("message.zon");	44	const message: []const u8 = @import("message.zon");
45	pub fn main() !void {	45	pub fn main() !void {
46	try std.io.getStdOut().writeAll(message);	46	try std.fs.File.stdout().writeAll(message);
47	}	47	}
48	#expect_stdout="We're back, World!\n"	48	#expect_stdout="We're back, World!\n"

test/incremental/change_zon_file_no_result_type+1-1

...	@@ -6,7 +6,7 @@	...	@@ -6,7 +6,7 @@
6	#file=main.zig	6	#file=main.zig
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	try std.io.getStdOut().writeAll(@import("foo.zon").message);	9	try std.fs.File.stdout().writeAll(@import("foo.zon").message);
10	}	10	}
11	#file=foo.zon	11	#file=foo.zon
12	.{	12	.{

test/incremental/compile_log+3-3

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	#file=main.zig	7	#file=main.zig
8	const std = @import("std");	8	const std = @import("std");
9	pub fn main() !void {	9	pub fn main() !void {
10	try std.io.getStdOut().writeAll("Hello, World!\n");	10	try std.fs.File.stdout().writeAll("Hello, World!\n");
11	}	11	}
12	#expect_stdout="Hello, World!\n"	12	#expect_stdout="Hello, World!\n"
13		13
...	@@ -15,7 +15,7 @@ pub fn main() !void {	...	@@ -15,7 +15,7 @@ pub fn main() !void {
15	#file=main.zig	15	#file=main.zig
16	const std = @import("std");	16	const std = @import("std");
17	pub fn main() !void {	17	pub fn main() !void {
18	try std.io.getStdOut().writeAll("Hello, World!\n");	18	try std.fs.File.stdout().writeAll("Hello, World!\n");
19	@compileLog("this is a log");	19	@compileLog("this is a log");
20	}	20	}
21	#expect_error=main.zig:4:5: error: found compile log statement	21	#expect_error=main.zig:4:5: error: found compile log statement
...	@@ -25,6 +25,6 @@ pub fn main() !void {	...	@@ -25,6 +25,6 @@ pub fn main() !void {
25	#file=main.zig	25	#file=main.zig
26	const std = @import("std");	26	const std = @import("std");
27	pub fn main() !void {	27	pub fn main() !void {
28	try std.io.getStdOut().writeAll("Hello, World!\n");	28	try std.fs.File.stdout().writeAll("Hello, World!\n");
29	}	29	}
30	#expect_stdout="Hello, World!\n"	30	#expect_stdout="Hello, World!\n"

test/incremental/fix_astgen_failure+5-5

...	@@ -9,28 +9,28 @@ pub fn main() !void {	...	@@ -9,28 +9,28 @@ pub fn main() !void {
9	}	9	}
10	#file=foo.zig	10	#file=foo.zig
11	pub fn hello() !void {	11	pub fn hello() !void {
12	try std.io.getStdOut().writeAll("Hello, World!\n");	12	try std.fs.File.stdout().writeAll("Hello, World!\n");
13	}	13	}
14	#expect_error=foo.zig:2:9: error: use of undeclared identifier 'std'	14	#expect_error=foo.zig:2:9: error: use of undeclared identifier 'std'
15	#update=fix the error	15	#update=fix the error
16	#file=foo.zig	16	#file=foo.zig
17	const std = @import("std");	17	const std = @import("std");
18	pub fn hello() !void {	18	pub fn hello() !void {
19	try std.io.getStdOut().writeAll("Hello, World!\n");	19	try std.fs.File.stdout().writeAll("Hello, World!\n");
20	}	20	}
21	#expect_stdout="Hello, World!\n"	21	#expect_stdout="Hello, World!\n"
22	#update=add new error	22	#update=add new error
23	#file=foo.zig	23	#file=foo.zig
24	const std = @import("std");	24	const std = @import("std");
25	pub fn hello() !void {	25	pub fn hello() !void {
26	try std.io.getStdOut().writeAll(hello_str);	26	try std.fs.File.stdout().writeAll(hello_str);
27	}	27	}
28	#expect_error=foo.zig:3:37: error: use of undeclared identifier 'hello_str'	28	#expect_error=foo.zig:3:39: error: use of undeclared identifier 'hello_str'
29	#update=fix the new error	29	#update=fix the new error
30	#file=foo.zig	30	#file=foo.zig
31	const std = @import("std");	31	const std = @import("std");
32	const hello_str = "Hello, World! Again!\n";	32	const hello_str = "Hello, World! Again!\n";
33	pub fn hello() !void {	33	pub fn hello() !void {
34	try std.io.getStdOut().writeAll(hello_str);	34	try std.fs.File.stdout().writeAll(hello_str);
35	}	35	}
36	#expect_stdout="Hello, World! Again!\n"	36	#expect_stdout="Hello, World! Again!\n"

test/incremental/function_becomes_inline+3-3

...	@@ -7,7 +7,7 @@ pub fn main() !void {	...	@@ -7,7 +7,7 @@ pub fn main() !void {
7	try foo();	7	try foo();
8	}	8	}
9	fn foo() !void {	9	fn foo() !void {
10	try std.io.getStdOut().writer().writeAll("Hello, World!\n");	10	try std.fs.File.stdout().writeAll("Hello, World!\n");
11	}	11	}
12	const std = @import("std");	12	const std = @import("std");
13	#expect_stdout="Hello, World!\n"	13	#expect_stdout="Hello, World!\n"
...	@@ -18,7 +18,7 @@ pub fn main() !void {	...	@@ -18,7 +18,7 @@ pub fn main() !void {
18	try foo();	18	try foo();
19	}	19	}
20	inline fn foo() !void {	20	inline fn foo() !void {
21	try std.io.getStdOut().writer().writeAll("Hello, World!\n");	21	try std.fs.File.stdout().writeAll("Hello, World!\n");
22	}	22	}
23	const std = @import("std");	23	const std = @import("std");
24	#expect_stdout="Hello, World!\n"	24	#expect_stdout="Hello, World!\n"
...	@@ -29,7 +29,7 @@ pub fn main() !void {	...	@@ -29,7 +29,7 @@ pub fn main() !void {
29	try foo();	29	try foo();
30	}	30	}
31	inline fn foo() !void {	31	inline fn foo() !void {
32	try std.io.getStdOut().writer().writeAll("Hello, `inline` World!\n");	32	try std.fs.File.stdout().writeAll("Hello, `inline` World!\n");
33	}	33	}
34	const std = @import("std");	34	const std = @import("std");
35	#expect_stdout="Hello, `inline` World!\n"	35	#expect_stdout="Hello, `inline` World!\n"

test/incremental/hello+2-2

...	@@ -6,13 +6,13 @@	...	@@ -6,13 +6,13 @@
6	#file=main.zig	6	#file=main.zig
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	try std.io.getStdOut().writeAll("good morning\n");	9	try std.fs.File.stdout().writeAll("good morning\n");
10	}	10	}
11	#expect_stdout="good morning\n"	11	#expect_stdout="good morning\n"
12	#update=change the string	12	#update=change the string
13	#file=main.zig	13	#file=main.zig
14	const std = @import("std");	14	const std = @import("std");
15	pub fn main() !void {	15	pub fn main() !void {
16	try std.io.getStdOut().writeAll("おはようございます\n");	16	try std.fs.File.stdout().writeAll("おはようございます\n");
17	}	17	}
18	#expect_stdout="おはようございます\n"	18	#expect_stdout="おはようございます\n"

test/incremental/make_decl_pub+2-2

...	@@ -11,7 +11,7 @@ pub fn main() !void {	...	@@ -11,7 +11,7 @@ pub fn main() !void {
11	#file=foo.zig	11	#file=foo.zig
12	const std = @import("std");	12	const std = @import("std");
13	fn hello() !void {	13	fn hello() !void {
14	try std.io.getStdOut().writeAll("Hello, World!\n");	14	try std.fs.File.stdout().writeAll("Hello, World!\n");
15	}	15	}
16	#expect_error=main.zig:3:12: error: 'hello' is not marked 'pub'	16	#expect_error=main.zig:3:12: error: 'hello' is not marked 'pub'
17	#expect_error=foo.zig:2:1: note: declared here	17	#expect_error=foo.zig:2:1: note: declared here
...	@@ -20,6 +20,6 @@ fn hello() !void {	...	@@ -20,6 +20,6 @@ fn hello() !void {
20	#file=foo.zig	20	#file=foo.zig
21	const std = @import("std");	21	const std = @import("std");
22	pub fn hello() !void {	22	pub fn hello() !void {
23	try std.io.getStdOut().writeAll("Hello, World!\n");	23	try std.fs.File.stdout().writeAll("Hello, World!\n");
24	}	24	}
25	#expect_stdout="Hello, World!\n"	25	#expect_stdout="Hello, World!\n"

test/incremental/modify_inline_fn+2-2

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	const str = getStr();	9	const str = getStr();
10	try std.io.getStdOut().writeAll(str);	10	try std.fs.File.stdout().writeAll(str);
11	}	11	}
12	inline fn getStr() []const u8 {	12	inline fn getStr() []const u8 {
13	return "foo\n";	13	return "foo\n";
...	@@ -18,7 +18,7 @@ inline fn getStr() []const u8 {	...	@@ -18,7 +18,7 @@ inline fn getStr() []const u8 {
18	const std = @import("std");	18	const std = @import("std");
19	pub fn main() !void {	19	pub fn main() !void {
20	const str = getStr();	20	const str = getStr();
21	try std.io.getStdOut().writeAll(str);	21	try std.fs.File.stdout().writeAll(str);
22	}	22	}
23	inline fn getStr() []const u8 {	23	inline fn getStr() []const u8 {
24	return "bar\n";	24	return "bar\n";

test/incremental/move_src+6-4

...	@@ -6,7 +6,8 @@	...	@@ -6,7 +6,8 @@
6	#file=main.zig	6	#file=main.zig
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	try std.io.getStdOut().writer().print("{d} {d}\n", .{ foo(), bar() });	9	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		10	try stdout_writer.interface.print("{d} {d}\n", .{ foo(), bar() });
10	}	11	}
11	fn foo() u32 {	12	fn foo() u32 {
12	return @src().line;	13	return @src().line;
...	@@ -14,13 +15,14 @@ fn foo() u32 {	...	@@ -14,13 +15,14 @@ fn foo() u32 {
14	fn bar() u32 {	15	fn bar() u32 {
15	return 123;	16	return 123;
16	}	17	}
17	#expect_stdout="6 123\n"	18	#expect_stdout="7 123\n"
18		19
19	#update=add newline	20	#update=add newline
20	#file=main.zig	21	#file=main.zig
21	const std = @import("std");	22	const std = @import("std");
22	pub fn main() !void {	23	pub fn main() !void {
23	try std.io.getStdOut().writer().print("{d} {d}\n", .{ foo(), bar() });	24	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		25	try stdout_writer.interface.print("{d} {d}\n", .{ foo(), bar() });
24	}	26	}
25		27
26	fn foo() u32 {	28	fn foo() u32 {
...	@@ -29,4 +31,4 @@ fn foo() u32 {	...	@@ -29,4 +31,4 @@ fn foo() u32 {
29	fn bar() u32 {	31	fn bar() u32 {
30	return 123;	32	return 123;
31	}	33	}
32	#expect_stdout="7 123\n"	34	#expect_stdout="8 123\n"

test/incremental/no_change_preserves_tag_names+2-2

...	@@ -7,7 +7,7 @@	...	@@ -7,7 +7,7 @@
7	const std = @import("std");	7	const std = @import("std");
8	var some_enum: enum { first, second } = .first;	8	var some_enum: enum { first, second } = .first;
9	pub fn main() !void {	9	pub fn main() !void {
10	try std.io.getStdOut().writeAll(@tagName(some_enum));	10	try std.fs.File.stdout().writeAll(@tagName(some_enum));
11	}	11	}
12	#expect_stdout="first"	12	#expect_stdout="first"
13	#update=no change	13	#update=no change
...	@@ -15,6 +15,6 @@ pub fn main() !void {	...	@@ -15,6 +15,6 @@ pub fn main() !void {
15	const std = @import("std");	15	const std = @import("std");
16	var some_enum: enum { first, second } = .first;	16	var some_enum: enum { first, second } = .first;
17	pub fn main() !void {	17	pub fn main() !void {
18	try std.io.getStdOut().writeAll(@tagName(some_enum));	18	try std.fs.File.stdout().writeAll(@tagName(some_enum));
19	}	19	}
20	#expect_stdout="first"	20	#expect_stdout="first"

test/incremental/recursive_function_becomes_non_recursive+2-2

...	@@ -8,7 +8,7 @@ pub fn main() !void {	...	@@ -8,7 +8,7 @@ pub fn main() !void {
8	try foo(false);	8	try foo(false);
9	}	9	}
10	fn foo(recurse: bool) !void {	10	fn foo(recurse: bool) !void {
11	const stdout = std.io.getStdOut().writer();	11	const stdout = std.fs.File.stdout();
12	if (recurse) return foo(true);	12	if (recurse) return foo(true);
13	try stdout.writeAll("non-recursive path\n");	13	try stdout.writeAll("non-recursive path\n");
14	}	14	}
...	@@ -21,7 +21,7 @@ pub fn main() !void {	...	@@ -21,7 +21,7 @@ pub fn main() !void {
21	try foo(true);	21	try foo(true);
22	}	22	}
23	fn foo(recurse: bool) !void {	23	fn foo(recurse: bool) !void {
24	const stdout = std.io.getStdOut().writer();	24	const stdout = std.fs.File.stdout();
25	if (recurse) return stdout.writeAll("x==1\n");	25	if (recurse) return stdout.writeAll("x==1\n");
26	try stdout.writeAll("non-recursive path\n");	26	try stdout.writeAll("non-recursive path\n");
27	}	27	}

test/incremental/remove_enum_field+5-3

...	@@ -9,7 +9,8 @@ const MyEnum = enum(u8) {	...	@@ -9,7 +9,8 @@ const MyEnum = enum(u8) {
9	bar = 2,	9	bar = 2,
10	};	10	};
11	pub fn main() !void {	11	pub fn main() !void {
12	try std.io.getStdOut().writer().print("{}\n", .{@intFromEnum(MyEnum.foo)});	12	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		13	try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
13	}	14	}
14	const std = @import("std");	15	const std = @import("std");
15	#expect_stdout="1\n"	16	#expect_stdout="1\n"
...	@@ -20,8 +21,9 @@ const MyEnum = enum(u8) {	...	@@ -20,8 +21,9 @@ const MyEnum = enum(u8) {
20	bar = 2,	21	bar = 2,
21	};	22	};
22	pub fn main() !void {	23	pub fn main() !void {
23	try std.io.getStdOut().writer().print("{}\n", .{@intFromEnum(MyEnum.foo)});	24	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		25	try stdout_writer.interface.print("{}\n", .{@intFromEnum(MyEnum.foo)});
24	}	26	}
25	const std = @import("std");	27	const std = @import("std");
26	#expect_error=main.zig:6:73: error: enum 'main.MyEnum' has no member named 'foo'	28	#expect_error=main.zig:7:69: error: enum 'main.MyEnum' has no member named 'foo'
27	#expect_error=main.zig:1:16: note: enum declared here	29	#expect_error=main.zig:1:16: note: enum declared here

test/incremental/unreferenced_error+4-4

...	@@ -6,7 +6,7 @@	...	@@ -6,7 +6,7 @@
6	#file=main.zig	6	#file=main.zig
7	const std = @import("std");	7	const std = @import("std");
8	pub fn main() !void {	8	pub fn main() !void {
9	try std.io.getStdOut().writeAll(a);	9	try std.fs.File.stdout().writeAll(a);
10	}	10	}
11	const a = "Hello, World!\n";	11	const a = "Hello, World!\n";
12	#expect_stdout="Hello, World!\n"	12	#expect_stdout="Hello, World!\n"
...	@@ -15,7 +15,7 @@ const a = "Hello, World!\n";	...	@@ -15,7 +15,7 @@ const a = "Hello, World!\n";
15	#file=main.zig	15	#file=main.zig
16	const std = @import("std");	16	const std = @import("std");
17	pub fn main() !void {	17	pub fn main() !void {
18	try std.io.getStdOut().writeAll(a);	18	try std.fs.File.stdout().writeAll(a);
19	}	19	}
20	const a = @compileError("bad a");	20	const a = @compileError("bad a");
21	#expect_error=main.zig:5:11: error: bad a	21	#expect_error=main.zig:5:11: error: bad a
...	@@ -24,7 +24,7 @@ const a = @compileError("bad a");	...	@@ -24,7 +24,7 @@ const a = @compileError("bad a");
24	#file=main.zig	24	#file=main.zig
25	const std = @import("std");	25	const std = @import("std");
26	pub fn main() !void {	26	pub fn main() !void {
27	try std.io.getStdOut().writeAll(b);	27	try std.fs.File.stdout().writeAll(b);
28	}	28	}
29	const a = @compileError("bad a");	29	const a = @compileError("bad a");
30	const b = "Hi there!\n";	30	const b = "Hi there!\n";
...	@@ -34,7 +34,7 @@ const b = "Hi there!\n";	...	@@ -34,7 +34,7 @@ const b = "Hi there!\n";
34	#file=main.zig	34	#file=main.zig
35	const std = @import("std");	35	const std = @import("std");
36	pub fn main() !void {	36	pub fn main() !void {
37	try std.io.getStdOut().writeAll(a);	37	try std.fs.File.stdout().writeAll(a);
38	}	38	}
39	const a = "Back to a\n";	39	const a = "Back to a\n";
40	const b = @compileError("bad b");	40	const b = @compileError("bad b");

test/link/bss/main.zig+4-1

...	@@ -4,8 +4,11 @@ const std = @import("std");	...	@@ -4,8 +4,11 @@ const std = @import("std");
4	var buffer: [0x1000000]u64 = [1]u64{0} ** 0x1000000;	4	var buffer: [0x1000000]u64 = [1]u64{0} ** 0x1000000;
5		5
6	pub fn main() anyerror!void {	6	pub fn main() anyerror!void {
		7	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		8
7	buffer[0x10] = 1;	9	buffer[0x10] = 1;
8	try std.io.getStdOut().writer().print("{d}, {d}, {d}\n", .{	10
		11	try stdout_writer.interface.print("{d}, {d}, {d}\n", .{
9	// workaround the dreaded decl_val	12	// workaround the dreaded decl_val
10	(&buffer)[0],	13	(&buffer)[0],
11	(&buffer)[0x10],	14	(&buffer)[0x10],

test/link/elf.zig+4-4

...	@@ -1315,8 +1315,8 @@ fn testGcSectionsZig(b: Build, opts: Options) Step {	...	@@ -1315,8 +1315,8 @@ fn testGcSectionsZig(b: Build, opts: Options) Step {
1315	\\extern var live_var2: i32;	1315	\\extern var live_var2: i32;
1316	\\extern fn live_fn2() void;	1316	\\extern fn live_fn2() void;
1317	\\pub fn main() void {	1317	\\pub fn main() void {
1318	\\ const stdout = std.io.getStdOut();	1318	\\ var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
1319	\\ stdout.deprecatedWriter().print("{d} {d}\n", .{ live_var1, live_var2 }) catch unreachable;	1319	\\ stdout_writer.interface.print("{d} {d}\n", .{ live_var1, live_var2 }) catch @panic("fail");
1320	\\ live_fn2();	1320	\\ live_fn2();
1321	\\}	1321	\\}
1322	,	1322	,
...	@@ -1357,8 +1357,8 @@ fn testGcSectionsZig(b: Build, opts: Options) Step {	...	@@ -1357,8 +1357,8 @@ fn testGcSectionsZig(b: Build, opts: Options) Step {
1357	\\extern var live_var2: i32;	1357	\\extern var live_var2: i32;
1358	\\extern fn live_fn2() void;	1358	\\extern fn live_fn2() void;
1359	\\pub fn main() void {	1359	\\pub fn main() void {
1360	\\ const stdout = std.io.getStdOut();	1360	\\ var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
1361	\\ stdout.deprecatedWriter().print("{d} {d}\n", .{ live_var1, live_var2 }) catch unreachable;	1361	\\ stdout_writer.interface.print("{d} {d}\n", .{ live_var1, live_var2 }) catch @panic("fail");
1362	\\ live_fn2();	1362	\\ live_fn2();
1363	\\}	1363	\\}
1364	,	1364	,

test/link/macho.zig+4-3

 @@ -710,7 +710,7 @@ fn testHelloZig(b: *Build, opts: Options) *Step {
     const exe = addExecutable(b, opts, .{ .name = "main", .zig_source_bytes =
         \\const std = @import("std");
         \\pub fn main() void {
-        \\    std.io.getStdOut().writer().print("Hello world!\n", .{}) catch unreachable;
+        \\    std.fs.File.stdout().writeAll("Hello world!\n") catch @panic("fail");
         \\}
     });
 @@ -2365,10 +2365,11 @@ fn testTlsZig(b: *Build, opts: Options) *Step {
         \\threadlocal var x: i32 = 0;
         \\threadlocal var y: i32 = -1;
         \\pub fn main() void {
-        \\    std.io.getStdOut().writer().print("{d} {d}\n", .{x, y}) catch unreachable;
+        \\    var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
+        \\    stdout_writer.interface.print("{d} {d}\n", .{x, y}) catch unreachable;
         \\    x -= 1;
         \\    y += 1;
-        \\    std.io.getStdOut().writer().print("{d} {d}\n", .{x, y}) catch unreachable;
+        \\    stdout_writer.interface.print("{d} {d}\n", .{x, y}) catch unreachable;
         \\}
     });

test/link/wasm/extern/main.zig+2-2

...	@@ -3,6 +3,6 @@ const std = @import("std");	...	@@ -3,6 +3,6 @@ const std = @import("std");
3	extern const foo: u32;	3	extern const foo: u32;
4		4
5	pub fn main() void {	5	pub fn main() void {
6	const std_out = std.io.getStdOut();	6	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
7	std_out.writer().print("Result: {d}", .{foo}) catch {};	7	stdout_writer.interface.print("Result: {d}", .{foo}) catch {};
8	}	8	}

test/src/check-stack-trace.zig+1-1

...	@@ -84,5 +84,5 @@ pub fn main() !void {	...	@@ -84,5 +84,5 @@ pub fn main() !void {
84	break :got_result try buf.toOwnedSlice();	84	break :got_result try buf.toOwnedSlice();
85	};	85	};
86		86
87	try std.io.getStdOut().writeAll(got);	87	try std.fs.File.stdout().writeAll(got);
88	}	88	}

test/standalone/child_process/child.zig+4-3

 @@ -27,12 +27,12 @@ fn run(allocator: std.mem.Allocator) !void {
     }
     // test stdout pipe; parent verifies
-    try std.io.getStdOut().writer().writeAll("hello from stdout");
+    try std.fs.File.stdout().writeAll("hello from stdout");
     // test stdin pipe from parent
     const hello_stdin = "hello from stdin";
     var buf: [hello_stdin.len]u8 = undefined;
-    const stdin = std.io.getStdIn().reader();
+    const stdin: std.fs.File = .stdin();
     const n = try stdin.readAll(&buf);
     if (!std.mem.eql(u8, buf[0..n], hello_stdin)) {
         testError("stdin: '{s}'; want '{s}'", .{ buf[0..n], hello_stdin });
 @@ -40,7 +40,8 @@ fn run(allocator: std.mem.Allocator) !void {
 }
 fn testError(comptime fmt: []const u8, args: anytype) void {
-    const stderr = std.io.getStdErr().writer();
+    var stderr_writer = std.fs.File.stderr().writer(&.{});
+    const stderr = &stderr_writer.interface;
     stderr.print("CHILD TEST ERROR: ", .{}) catch {};
     stderr.print(fmt, args) catch {};
     if (fmt[fmt.len - 1] != '\n') {

test/standalone/child_process/main.zig+4-3

 @@ -19,13 +19,13 @@ pub fn main() !void {
     child.stderr_behavior = .Inherit;
     try child.spawn();
     const child_stdin = child.stdin.?;
-    try child_stdin.writer().writeAll("hello from stdin"); // verified in child
+    try child_stdin.writeAll("hello from stdin"); // verified in child
     child_stdin.close();
     child.stdin = null;
     const hello_stdout = "hello from stdout";
     var buf: [hello_stdout.len]u8 = undefined;
-    const n = try child.stdout.?.reader().readAll(&buf);
+    const n = try child.stdout.?.deprecatedReader().readAll(&buf);
     if (!std.mem.eql(u8, buf[0..n], hello_stdout)) {
         testError("child stdout: '{s}'; want '{s}'", .{ buf[0..n], hello_stdout });
     }
 @@ -45,7 +45,8 @@ pub fn main() !void {
 var parent_test_error = false;
 fn testError(comptime fmt: []const u8, args: anytype) void {
-    const stderr = std.io.getStdErr().writer();
+    var stderr_writer = std.fs.File.stderr().writer(&.{});
+    const stderr = &stderr_writer.interface;
     stderr.print("PARENT TEST ERROR: ", .{}) catch {};
     stderr.print(fmt, args) catch {};
     if (fmt[fmt.len - 1] != '\n') {

test/standalone/sigpipe/breakpipe.zig+1-1

...	@@ -10,7 +10,7 @@ pub fn main() !void {	...	@@ -10,7 +10,7 @@ pub fn main() !void {
10	std.posix.close(pipe[0]);	10	std.posix.close(pipe[0]);
11	_ = std.posix.write(pipe[1], "a") catch \|err\| switch (err) {	11	_ = std.posix.write(pipe[1], "a") catch \|err\| switch (err) {
12	error.BrokenPipe => {	12	error.BrokenPipe => {
13	try std.io.getStdOut().writer().writeAll("BrokenPipe\n");	13	try std.fs.File.stdout().writeAll("BrokenPipe\n");
14	std.posix.exit(123);	14	std.posix.exit(123);
15	},	15	},
16	else => \|e\| return e,	16	else => \|e\| return e,

test/standalone/simple/brace_expansion.zig deleted-292

...	@@ -1,292 +0,0 @@
1	const std = @import("std");
2	const io = std.io;
3	const mem = std.mem;
4	const debug = std.debug;
5	const assert = debug.assert;
6	const testing = std.testing;
7	const ArrayList = std.ArrayList;
8	const maxInt = std.math.maxInt;
9
10	const Token = union(enum) {
11	Word: []const u8,
12	OpenBrace,
13	CloseBrace,
14	Comma,
15	Eof,
16	};
17
18	var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
19	var global_allocator = gpa.allocator();
20
21	fn tokenize(input: []const u8) !ArrayList(Token) {
22	const State = enum {
23	Start,
24	Word,
25	};
26
27	var token_list = ArrayList(Token).init(global_allocator);
28	errdefer token_list.deinit();
29	var tok_begin: usize = undefined;
30	var state = State.Start;
31
32	for (input, 0..) \|b, i\| {
33	switch (state) {
34	.Start => switch (b) {
35	'a'...'z', 'A'...'Z' => {
36	state = State.Word;
37	tok_begin = i;
38	},
39	'{' => try token_list.append(Token.OpenBrace),
40	'}' => try token_list.append(Token.CloseBrace),
41	',' => try token_list.append(Token.Comma),
42	else => return error.InvalidInput,
43	},
44	.Word => switch (b) {
45	'a'...'z', 'A'...'Z' => {},
46	'{', '}', ',' => {
47	try token_list.append(Token{ .Word = input[tok_begin..i] });
48	switch (b) {
49	'{' => try token_list.append(Token.OpenBrace),
50	'}' => try token_list.append(Token.CloseBrace),
51	',' => try token_list.append(Token.Comma),
52	else => unreachable,
53	}
54	state = State.Start;
55	},
56	else => return error.InvalidInput,
57	},
58	}
59	}
60	switch (state) {
61	State.Start => {},
62	State.Word => try token_list.append(Token{ .Word = input[tok_begin..] }),
63	}
64	try token_list.append(Token.Eof);
65	return token_list;
66	}
67
68	const Node = union(enum) {
69	Scalar: []const u8,
70	List: ArrayList(Node),
71	Combine: []Node,
72
73	fn deinit(self: Node) void {
74	switch (self) {
75	.Scalar => {},
76	.Combine => \|pair\| {
77	pair[0].deinit();
78	pair[1].deinit();
79	global_allocator.free(pair);
80	},
81	.List => \|list\| {
82	for (list.items) \|item\| {
83	item.deinit();
84	}
85	list.deinit();
86	},
87	}
88	}
89	};
90
91	const ParseError = error{
92	InvalidInput,
93	OutOfMemory,
94	};
95
96	fn parse(tokens: const ArrayList(Token), token_index: usize) ParseError!Node {
97	const first_token = tokens.items[token_index.*];
98	token_index.* += 1;
99
100	const result_node = switch (first_token) {
101	.Word => \|word\| Node{ .Scalar = word },
102	.OpenBrace => blk: {
103	var list = ArrayList(Node).init(global_allocator);
104	errdefer {
105	for (list.items) \|node\| node.deinit();
106	list.deinit();
107	}
108	while (true) {
109	try list.append(try parse(tokens, token_index));
110
111	const token = tokens.items[token_index.*];
112	token_index.* += 1;
113
114	switch (token) {
115	.CloseBrace => break,
116	.Comma => continue,
117	else => return error.InvalidInput,
118	}
119	}
120	break :blk Node{ .List = list };
121	},
122	else => return error.InvalidInput,
123	};
124
125	switch (tokens.items[token_index.*]) {
126	.Word, .OpenBrace => {
127	const pair = try global_allocator.alloc(Node, 2);
128	errdefer global_allocator.free(pair);
129	pair[0] = result_node;
130	pair[1] = try parse(tokens, token_index);
131	return Node{ .Combine = pair };
132	},
133	else => return result_node,
134	}
135	}
136
137	fn expandString(input: []const u8, output: *ArrayList(u8)) !void {
138	const tokens = try tokenize(input);
139	defer tokens.deinit();
140	if (tokens.items.len == 1) {
141	return output.resize(0);
142	}
143
144	var token_index: usize = 0;
145	const root = try parse(&tokens, &token_index);
146	defer root.deinit();
147	const last_token = tokens.items[token_index];
148	switch (last_token) {
149	Token.Eof => {},
150	else => return error.InvalidInput,
151	}
152
153	var result_list = ArrayList(ArrayList(u8)).init(global_allocator);
154	defer {
155	for (result_list.items) \|*buf\| buf.deinit();
156	result_list.deinit();
157	}
158
159	try expandNode(root, &result_list);
160
161	try output.resize(0);
162	for (result_list.items, 0..) \|buf, i\| {
163	if (i != 0) {
164	try output.append(' ');
165	}
166	try output.appendSlice(buf.items);
167	}
168	}
169
170	const ExpandNodeError = error{OutOfMemory};
171
172	fn expandNode(node: Node, output: *ArrayList(ArrayList(u8))) ExpandNodeError!void {
173	assert(output.items.len == 0);
174	switch (node) {
175	.Scalar => \|scalar\| {
176	var list = ArrayList(u8).init(global_allocator);
177	errdefer list.deinit();
178	try list.appendSlice(scalar);
179	try output.append(list);
180	},
181	.Combine => \|pair\| {
182	const a_node = pair[0];
183	const b_node = pair[1];
184
185	var child_list_a = ArrayList(ArrayList(u8)).init(global_allocator);
186	defer {
187	for (child_list_a.items) \|*buf\| buf.deinit();
188	child_list_a.deinit();
189	}
190	try expandNode(a_node, &child_list_a);
191
192	var child_list_b = ArrayList(ArrayList(u8)).init(global_allocator);
193	defer {
194	for (child_list_b.items) \|*buf\| buf.deinit();
195	child_list_b.deinit();
196	}
197	try expandNode(b_node, &child_list_b);
198
199	for (child_list_a.items) \|buf_a\| {
200	for (child_list_b.items) \|buf_b\| {
201	var combined_buf = ArrayList(u8).init(global_allocator);
202	errdefer combined_buf.deinit();
203
204	try combined_buf.appendSlice(buf_a.items);
205	try combined_buf.appendSlice(buf_b.items);
206	try output.append(combined_buf);
207	}
208	}
209	},
210	.List => \|list\| {
211	for (list.items) \|child_node\| {
212	var child_list = ArrayList(ArrayList(u8)).init(global_allocator);
213	errdefer for (child_list.items) \|*buf\| buf.deinit();
214	defer child_list.deinit();
215
216	try expandNode(child_node, &child_list);
217
218	for (child_list.items) \|buf\| {
219	try output.append(buf);
220	}
221	}
222	},
223	}
224	}
225
226	pub fn main() !void {
227	defer _ = gpa.deinit();
228	const stdin_file = io.getStdIn();
229	const stdout_file = io.getStdOut();
230
231	const stdin = try stdin_file.deprecatedReader().readAllAlloc(global_allocator, std.math.maxInt(usize));
232	defer global_allocator.free(stdin);
233
234	var result_buf = ArrayList(u8).init(global_allocator);
235	defer result_buf.deinit();
236
237	try expandString(stdin, &result_buf);
238	try stdout_file.writeAll(result_buf.items);
239	}
240
241	test "invalid inputs" {
242	global_allocator = std.testing.allocator;
243
244	try expectError("}ABC", error.InvalidInput);
245	try expectError("{ABC", error.InvalidInput);
246	try expectError("}{", error.InvalidInput);
247	try expectError("{}", error.InvalidInput);
248	try expectError("A,B,C", error.InvalidInput);
249	try expectError("{A{B,C}", error.InvalidInput);
250	try expectError("{A,}", error.InvalidInput);
251
252	try expectError("\n", error.InvalidInput);
253	}
254
255	fn expectError(test_input: []const u8, expected_err: anyerror) !void {
256	var output_buf = ArrayList(u8).init(global_allocator);
257	defer output_buf.deinit();
258
259	try testing.expectError(expected_err, expandString(test_input, &output_buf));
260	}
261
262	test "valid inputs" {
263	global_allocator = std.testing.allocator;
264
265	try expectExpansion("{x,y,z}", "x y z");
266	try expectExpansion("{A,B}{x,y}", "Ax Ay Bx By");
267	try expectExpansion("{A,B{x,y}}", "A Bx By");
268
269	try expectExpansion("{ABC}", "ABC");
270	try expectExpansion("{A,B,C}", "A B C");
271	try expectExpansion("ABC", "ABC");
272
273	try expectExpansion("", "");
274	try expectExpansion("{A,B}{C,{x,y}}{g,h}", "ACg ACh Axg Axh Ayg Ayh BCg BCh Bxg Bxh Byg Byh");
275	try expectExpansion("{A,B}{C,C{x,y}}{g,h}", "ACg ACh ACxg ACxh ACyg ACyh BCg BCh BCxg BCxh BCyg BCyh");
276	try expectExpansion("{A,B}a", "Aa Ba");
277	try expectExpansion("{C,{x,y}}", "C x y");
278	try expectExpansion("z{C,{x,y}}", "zC zx zy");
279	try expectExpansion("a{b,c{d,e{f,g}}}", "ab acd acef aceg");
280	try expectExpansion("a{x,y}b", "axb ayb");
281	try expectExpansion("z{{a,b}}", "za zb");
282	try expectExpansion("a{b}", "ab");
283	}
284
285	fn expectExpansion(test_input: []const u8, expected_result: []const u8) !void {
286	var result = ArrayList(u8).init(global_allocator);
287	defer result.deinit();
288
289	expandString(test_input, &result) catch unreachable;
290
291	try testing.expectEqualSlices(u8, expected_result, result.items);
292	}

test/standalone/simple/build.zig-4

 @@ -109,10 +109,6 @@ const cases = [_]Case{
     //.{
     //    .src_path = "issue_9693/main.zig",
     //},
-    .{
-        .src_path = "brace_expansion.zig",
-        .is_test = true,
-    },
     .{
         .src_path = "issue_7030.zig",
         .target = .{

test/standalone/simple/cat/main.zig+10-10

 @@ -1,42 +1,42 @@
 const std = @import("std");
 const io = std.io;
-const process = std.process;
 const fs = std.fs;
 const mem = std.mem;
 const warn = std.log.warn;
+const fatal = std.process.fatal;
 pub fn main() !void {
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
-    const args = try process.argsAlloc(arena);
+    const args = try std.process.argsAlloc(arena);
     const exe = args[0];
     var catted_anything = false;
-    const stdout_file = io.getStdOut();
+    var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
+    const stdout = &stdout_writer.interface;
+    var stdin_reader = std.fs.File.stdin().reader(&.{});
     const cwd = fs.cwd();
     for (args[1..]) |arg| {
         if (mem.eql(u8, arg, "-")) {
             catted_anything = true;
-            try stdout_file.writeFileAll(io.getStdIn(), .{});
+            _ = try stdout.sendFileAll(&stdin_reader, .unlimited);
         } else if (mem.startsWith(u8, arg, "-")) {
             return usage(exe);
         } else {
-            const file = cwd.openFile(arg, .{}) catch |err| {
+            const file = cwd.openFile(arg, .{}) catch |err| fatal("unable to open file: {t}\n", .{err});
-                warn("Unable to open file: {s}\n", .{@errorName(err)});
-                return err;
-            };
             defer file.close();
             catted_anything = true;
-            try stdout_file.writeFileAll(file, .{});
+            var file_reader = file.reader(&.{});
+            _ = try stdout.sendFileAll(&file_reader, .unlimited);
         }
     }
     if (!catted_anything) {
-        try stdout_file.writeFileAll(io.getStdIn(), .{});
+        _ = try stdout.sendFileAll(&stdin_reader, .unlimited);
     }
 }

test/standalone/simple/guess_number/main.zig+11-13

 @@ -1,37 +1,35 @@
 const builtin = @import("builtin");
 const std = @import("std");
-const io = std.io;
-const fmt = std.fmt;
 pub fn main() !void {
-    const stdout = io.getStdOut().writer();
+    var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
-    const stdin = io.getStdIn();
+    const out = &stdout_writer.interface;
+    const stdin: std.fs.File = .stdin();
-    try stdout.print("Welcome to the Guess Number Game in Zig.\n", .{});
+    try out.writeAll("Welcome to the Guess Number Game in Zig.\n");
     const answer = std.crypto.random.intRangeLessThan(u8, 0, 100) + 1;
     while (true) {
-        try stdout.print("\nGuess a number between 1 and 100: ", .{});
+        try out.writeAll("\nGuess a number between 1 and 100: ");
         var line_buf: [20]u8 = undefined;
         const amt = try stdin.read(&line_buf);
         if (amt == line_buf.len) {
-            try stdout.print("Input too long.\n", .{});
+            try out.writeAll("Input too long.\n");
             continue;
         }
         const line = std.mem.trimEnd(u8, line_buf[0..amt], "\r\n");
-        const guess = fmt.parseUnsigned(u8, line, 10) catch {
+        const guess = std.fmt.parseUnsigned(u8, line, 10) catch {
-            try stdout.print("Invalid number.\n", .{});
+            try out.writeAll("Invalid number.\n");
             continue;
         };
         if (guess > answer) {
-            try stdout.print("Guess lower.\n", .{});
+            try out.writeAll("Guess lower.\n");
         } else if (guess < answer) {
-            try stdout.print("Guess higher.\n", .{});
+            try out.writeAll("Guess higher.\n");
         } else {
-            try stdout.print("You win!\n", .{});
+            try out.writeAll("You win!\n");
             return;
         }
     }

test/standalone/simple/hello_world/hello.zig+1-1

...	@@ -1,5 +1,5 @@	...	@@ -1,5 +1,5 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn main() !void {	3	pub fn main() !void {
4	try std.io.getStdOut().writeAll("Hello, World!\n");	4	try std.fs.File.stdout().writeAll("Hello, World!\n");
5	}	5	}

test/standalone/simple/std_enums_big_enums.zig+1

...	@@ -6,6 +6,7 @@ pub fn main() void {	...	@@ -6,6 +6,7 @@ pub fn main() void {
6	const Big = @Type(.{ .@"enum" = .{	6	const Big = @Type(.{ .@"enum" = .{
7	.tag_type = u16,	7	.tag_type = u16,
8	.fields = make_fields: {	8	.fields = make_fields: {
		9	@setEvalBranchQuota(500000);
9	var fields: [1001]std.builtin.Type.EnumField = undefined;	10	var fields: [1001]std.builtin.Type.EnumField = undefined;
10	for (&fields, 0..) \|*field, i\| {	11	for (&fields, 0..) \|*field, i\| {
11	field.* = .{ .name = std.fmt.comptimePrint("field_{d}", .{i}), .value = i };	12	field.* = .{ .name = std.fmt.comptimePrint("field_{d}", .{i}), .value = i };

test/standalone/windows_bat_args/echo-args.zig+2-1

...	@@ -5,7 +5,8 @@ pub fn main() !void {	...	@@ -5,7 +5,8 @@ pub fn main() !void {
5	defer arena_state.deinit();	5	defer arena_state.deinit();
6	const arena = arena_state.allocator();	6	const arena = arena_state.allocator();
7		7
8	const stdout = std.io.getStdOut().writer();	8	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		9	const stdout = &stdout_writer.interface;
9	var args = try std.process.argsAlloc(arena);	10	var args = try std.process.argsAlloc(arena);
10	for (args[1..], 1..) \|arg, i\| {	11	for (args[1..], 1..) \|arg, i\| {
11	try stdout.writeAll(arg);	12	try stdout.writeAll(arg);

test/standalone/windows_spawn/hello.zig+2-1

...	@@ -1,6 +1,7 @@	...	@@ -1,6 +1,7 @@
1	const std = @import("std");	1	const std = @import("std");
2		2
3	pub fn main() !void {	3	pub fn main() !void {
4	const stdout = std.io.getStdOut().writer();	4	var stdout_writer = std.fs.File.stdout().writerStreaming(&.{});
		5	const stdout = &stdout_writer.interface;
5	try stdout.writeAll("hello from exe\n");	6	try stdout.writeAll("hello from exe\n");
6	}	7	}

tools/docgen.zig+1-2

...	@@ -43,8 +43,7 @@ pub fn main() !void {	...	@@ -43,8 +43,7 @@ pub fn main() !void {
43	while (args_it.next()) \|arg\| {	43	while (args_it.next()) \|arg\| {
44	if (mem.startsWith(u8, arg, "-")) {	44	if (mem.startsWith(u8, arg, "-")) {
45	if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {	45	if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
46	const stdout = io.getStdOut().writer();	46	try fs.File.stdout().writeAll(usage);
47	try stdout.writeAll(usage);
48	process.exit(0);	47	process.exit(0);
49	} else if (mem.eql(u8, arg, "--code-dir")) {	48	} else if (mem.eql(u8, arg, "--code-dir")) {
50	if (args_it.next()) \|param\| {	49	if (args_it.next()) \|param\| {

tools/doctest.zig+1-1

...	@@ -44,7 +44,7 @@ pub fn main() !void {	...	@@ -44,7 +44,7 @@ pub fn main() !void {
44	while (args_it.next()) \|arg\| {	44	while (args_it.next()) \|arg\| {
45	if (mem.startsWith(u8, arg, "-")) {	45	if (mem.startsWith(u8, arg, "-")) {
46	if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {	46	if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
47	try std.io.getStdOut().writeAll(usage);	47	try std.fs.File.stdout().writeAll(usage);
48	process.exit(0);	48	process.exit(0);
49	} else if (mem.eql(u8, arg, "-i")) {	49	} else if (mem.eql(u8, arg, "-i")) {
50	opt_input = args_it.next() orelse fatal("expected parameter after -i", .{});	50	opt_input = args_it.next() orelse fatal("expected parameter after -i", .{});

tools/dump-cov.zig+4-3

...	@@ -48,8 +48,9 @@ pub fn main() !void {	...	@@ -48,8 +48,9 @@ pub fn main() !void {
48	fatal("failed to load coverage file {}: {s}", .{ cov_path, @errorName(err) });	48	fatal("failed to load coverage file {}: {s}", .{ cov_path, @errorName(err) });
49	};	49	};
50		50
51	var bw = std.io.bufferedWriter(std.io.getStdOut().writer());	51	var stdout_buffer: [4000]u8 = undefined;
52	const stdout = bw.writer();	52	var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
		53	const stdout = &stdout_writer.interface;
53		54
54	const header: *SeenPcsHeader = @ptrCast(cov_bytes);	55	const header: *SeenPcsHeader = @ptrCast(cov_bytes);
55	try stdout.print("{any}\n", .{header.*});	56	try stdout.print("{any}\n", .{header.*});
...	@@ -83,5 +84,5 @@ pub fn main() !void {	...	@@ -83,5 +84,5 @@ pub fn main() !void {
83	});	84	});
84	}	85	}
85		86
86	try bw.flush();	87	try stdout.flush();
87	}	88	}

tools/fetch_them_macos_headers.zig+2-13

...	@@ -5,6 +5,8 @@ const mem = std.mem;	...	@@ -5,6 +5,8 @@ const mem = std.mem;
5	const process = std.process;	5	const process = std.process;
6	const assert = std.debug.assert;	6	const assert = std.debug.assert;
7	const tmpDir = std.testing.tmpDir;	7	const tmpDir = std.testing.tmpDir;
		8	const fatal = std.process.fatal;
		9	const info = std.log.info;
8		10
9	const Allocator = mem.Allocator;	11	const Allocator = mem.Allocator;
10	const OsTag = std.Target.Os.Tag;	12	const OsTag = std.Target.Os.Tag;
...	@@ -245,19 +247,6 @@ const ArgsIterator = struct {	...	@@ -245,19 +247,6 @@ const ArgsIterator = struct {
245	}	247	}
246	};	248	};
247		249
248	fn info(comptime format: []const u8, args: anytype) void {
249	const msg = std.fmt.allocPrint(gpa, "info: " ++ format ++ "\n", args) catch return;
250	std.io.getStdOut().writeAll(msg) catch {};
251	}
252
253	fn fatal(comptime format: []const u8, args: anytype) noreturn {
254	ret: {
255	const msg = std.fmt.allocPrint(gpa, "fatal: " ++ format ++ "\n", args) catch break :ret;
256	std.io.getStdErr().writeAll(msg) catch {};
257	}
258	std.process.exit(1);
259	}
260
261	const Version = struct {	250	const Version = struct {
262	major: u16,	251	major: u16,
263	minor: u8,	252	minor: u8,

tools/gen_macos_headers_c.zig+9-17

 @@ -1,5 +1,7 @@
 const std = @import("std");
 const assert = std.debug.assert;
+const info = std.log.info;
+const fatal = std.process.fatal;
 const Allocator = std.mem.Allocator;
 @@ -13,19 +15,6 @@ const usage =
     \\-h, --help                    Print this help and exit
 ;
-fn info(comptime format: []const u8, args: anytype) void {
-    const msg = std.fmt.allocPrint(gpa, "info: " ++ format ++ "\n", args) catch return;
-    std.io.getStdOut().writeAll(msg) catch {};
-}
-fn fatal(comptime format: []const u8, args: anytype) noreturn {
-    ret: {
-        const msg = std.fmt.allocPrint(gpa, "fatal: " ++ format ++ "\n", args) catch break :ret;
-        std.io.getStdErr().writeAll(msg) catch {};
-    }
-    std.process.exit(1);
-}
 pub fn main() anyerror!void {
     var arena_allocator = std.heap.ArenaAllocator.init(gpa);
     defer arena_allocator.deinit();
 @@ -58,16 +47,19 @@ pub fn main() anyerror!void {
     std.mem.sort([]const u8, paths.items, {}, SortFn.lessThan);
-    const stdout = std.io.getStdOut().writer();
+    var buffer: [2000]u8 = undefined;
-    try stdout.writeAll("#define _XOPEN_SOURCE\n");
+    var stdout_writer = std.fs.File.stdout().writerStreaming(&buffer);
+    const w = &stdout_writer.interface;
+    try w.writeAll("#define _XOPEN_SOURCE\n");
     for (paths.items) |path| {
-        try stdout.print("#include <{s}>\n", .{path});
+        try w.print("#include <{s}>\n", .{path});
     }
-    try stdout.writeAll(
+    try w.writeAll(
         \\int main(int argc, char **argv) {
         \\    return 0;
         \\}
     );
+    try w.flush();
 }
 fn findHeaders(

tools/gen_outline_atomics.zig+4-3

...	@@ -17,8 +17,9 @@ pub fn main() !void {	...	@@ -17,8 +17,9 @@ pub fn main() !void {
17		17
18	//const args = try std.process.argsAlloc(arena);	18	//const args = try std.process.argsAlloc(arena);
19		19
20	var bw = std.io.bufferedWriter(std.io.getStdOut().writer());	20	var stdout_buffer: [2000]u8 = undefined;
21	const w = bw.writer();	21	var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
		22	const w = &stdout_writer.interface;
22		23
23	try w.writeAll(	24	try w.writeAll(
24	\\//! This file is generated by tools/gen_outline_atomics.zig.	25	\\//! This file is generated by tools/gen_outline_atomics.zig.
...	@@ -57,7 +58,7 @@ pub fn main() !void {	...	@@ -57,7 +58,7 @@ pub fn main() !void {
57		58
58	try w.writeAll(footer.items);	59	try w.writeAll(footer.items);
59	try w.writeAll("}\n");	60	try w.writeAll("}\n");
60	try bw.flush();	61	try w.flush();
61	}	62	}
62		63
63	fn writeFunction(	64	fn writeFunction(

tools/gen_spirv_spec.zig+9-12

 @@ -91,9 +91,10 @@ pub fn main() !void {
     try readExtRegistry(&exts, a, std.fs.cwd(), args[2]);
-    var bw = std.io.bufferedWriter(std.io.getStdOut().writer());
+    var buffer: [4000]u8 = undefined;
-    try render(bw.writer(), a, core_spec, exts.items);
+    var w = std.fs.File.stdout().writerStreaming(&buffer);
-    try bw.flush();
+    try render(&w, a, core_spec, exts.items);
+    try w.flush();
 }
 fn readExtRegistry(exts: *std.ArrayList(Extension), a: Allocator, dir: std.fs.Dir, sub_path: []const u8) !void {
 @@ -166,7 +167,7 @@ fn tagPriorityScore(tag: []const u8) usize {
     }
 }
-fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []const Extension) !void {
+fn render(writer: *std.io.Writer, a: Allocator, registry: CoreRegistry, extensions: []const Extension) !void {
     try writer.writeAll(
         \\//! This file is auto-generated by tools/gen_spirv_spec.zig.
         \\
 @@ -188,15 +189,10 @@ fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []c
         \\    none,
         \\    _,
         \\
-        \\    pub fn format(
+        \\    pub fn format(self: IdResult, writer: *std.io.Writer) std.io.Writer.Error!void {
-        \\        self: IdResult,
-        \\        comptime _: []const u8,
-        \\        _: std.fmt.FormatOptions,
-        \\        writer: anytype,
-        \\    ) @TypeOf(writer).Error!void {
         \\        switch (self) {
         \\            .none => try writer.writeAll("(none)"),
-        \\            else => try writer.print("%{}", .{@intFromEnum(self)}),
+        \\            else => try writer.print("%{d}", .{@intFromEnum(self)}),
         \\        }
         \\    }
         \\};
 @@ -899,7 +895,8 @@ fn parseHexInt(text: []const u8) !u31 {
 }
 fn usageAndExit(arg0: []const u8, code: u8) noreturn {
-    std.io.getStdErr().writer().print(
+    const stderr = std.debug.lockStderrWriter(&.{});
+    stderr.print(
         \\Usage: {s} <SPIRV-Headers repository path> <path/to/zig/src/codegen/spirv/extinst.zig.grammar.json>
         \\
         \\Generates Zig bindings for SPIR-V specifications found in the SPIRV-Headers

tools/gen_stubs.zig+5-1

...	@@ -333,7 +333,9 @@ pub fn main() !void {	...	@@ -333,7 +333,9 @@ pub fn main() !void {
333	}	333	}
334	}	334	}
335		335
336	const stdout = std.io.getStdOut().writer();	336	var stdout_buffer: [2000]u8 = undefined;
		337	var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
		338	const stdout = &stdout_writer.interface;
337	try stdout.writeAll(	339	try stdout.writeAll(
338	\\#ifdef PTR64	340	\\#ifdef PTR64
339	\\#define WEAK64 .weak	341	\\#define WEAK64 .weak
...	@@ -533,6 +535,8 @@ pub fn main() !void {	...	@@ -533,6 +535,8 @@ pub fn main() !void {
533	.all => {},	535	.all => {},
534	.single, .multi, .family, .time32 => try stdout.writeAll("#endif\n"),	536	.single, .multi, .family, .time32 => try stdout.writeAll("#endif\n"),
535	}	537	}
		538
		539	try stdout.flush();
536	}	540	}
537		541
538	fn parseElf(parse: Parse, comptime is_64: bool, comptime endian: builtin.Endian) !void {	542	fn parseElf(parse: Parse, comptime is_64: bool, comptime endian: builtin.Endian) !void {

tools/generate_JSONTestSuite.zig+5-1

...	@@ -6,7 +6,9 @@ pub fn main() !void {	...	@@ -6,7 +6,9 @@ pub fn main() !void {
6	var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;	6	var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
7	var allocator = gpa.allocator();	7	var allocator = gpa.allocator();
8		8
9	var output = std.io.getStdOut().writer();	9	var stdout_buffer: [2000]u8 = undefined;
		10	var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
		11	const output = &stdout_writer.interface;
10	try output.writeAll(	12	try output.writeAll(
11	\\// This file was generated by _generate_JSONTestSuite.zig	13	\\// This file was generated by _generate_JSONTestSuite.zig
12	\\// These test cases are sourced from: https://github.com/nst/JSONTestSuite	14	\\// These test cases are sourced from: https://github.com/nst/JSONTestSuite
...	@@ -44,6 +46,8 @@ pub fn main() !void {	...	@@ -44,6 +46,8 @@ pub fn main() !void {
44	try writeString(output, contents);	46	try writeString(output, contents);
45	try output.writeAll(");\n}\n");	47	try output.writeAll(");\n}\n");
46	}	48	}
		49
		50	try output.flush();
47	}	51	}
48		52
49	const i_structure_500_nested_arrays = "[" 500 ++ "]" 500;	53	const i_structure_500_nested_arrays = "[" 500 ++ "]" 500;

tools/generate_c_size_and_align_checks.zig+7-4

 @@ -42,20 +42,23 @@ pub fn main() !void {
     const query = try std.Target.Query.parse(.{ .arch_os_abi = args[1] });
     const target = try std.zig.system.resolveTargetQuery(query);
-    const stdout = std.io.getStdOut().writer();
+    var buffer: [2000]u8 = undefined;
+    var stdout_writer = std.fs.File.stdout().writerStreaming(&buffer);
+    const w = &stdout_writer.interface;
     inline for (@typeInfo(std.Target.CType).@"enum".fields) |field| {
         const c_type: std.Target.CType = @enumFromInt(field.value);
-        try stdout.print("_Static_assert(sizeof({0s}) == {1d}, \"sizeof({0s}) == {1d}\");\n", .{
+        try w.print("_Static_assert(sizeof({0s}) == {1d}, \"sizeof({0s}) == {1d}\");\n", .{
             cName(c_type),
             target.cTypeByteSize(c_type),
         });
-        try stdout.print("_Static_assert(_Alignof({0s}) == {1d}, \"_Alignof({0s}) == {1d}\");\n", .{
+        try w.print("_Static_assert(_Alignof({0s}) == {1d}, \"_Alignof({0s}) == {1d}\");\n", .{
             cName(c_type),
             target.cTypeAlignment(c_type),
         });
-        try stdout.print("_Static_assert(__alignof({0s}) == {1d}, \"__alignof({0s}) == {1d}\");\n\n", .{
+        try w.print("_Static_assert(__alignof({0s}) == {1d}, \"__alignof({0s}) == {1d}\");\n\n", .{
             cName(c_type),
             target.cTypePreferredAlignment(c_type),
         });
     }
+    try w.flush();
 }

tools/generate_linux_syscalls.zig+11-9

 @@ -666,13 +666,16 @@ pub fn main() !void {
     const allocator = arena.allocator();
     const args = try std.process.argsAlloc(allocator);
-    if (args.len < 3 or mem.eql(u8, args[1], "--help"))
+    if (args.len < 3 or mem.eql(u8, args[1], "--help")) {
-        usageAndExit(std.io.getStdErr(), args[0], 1);
+        usage(std.debug.lockStderrWriter(&.{}), args[0]) catch std.process.exit(2);
+        std.process.exit(1);
+    }
     const zig_exe = args[1];
     const linux_path = args[2];
-    var buf_out = std.io.bufferedWriter(std.io.getStdOut().writer());
+    var stdout_buffer: [2000]u8 = undefined;
-    const writer = buf_out.writer();
+    var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
+    const writer = &stdout_writer.interface;
     var linux_dir = try std.fs.cwd().openDir(linux_path, .{});
     defer linux_dir.close();
 @@ -714,17 +717,16 @@ pub fn main() !void {
         }
     }
-    try buf_out.flush();
+    try writer.flush();
 }
-fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
+fn usage(w: *std.io.Writer, arg0: []const u8) std.io.Writer.Error!void {
-    file.writer().print(
+    try w.print(
         \\Usage: {s} /path/to/zig /path/to/linux
         \\Alternative Usage: zig run /path/to/git/zig/tools/generate_linux_syscalls.zig -- /path/to/zig /path/to/linux
         \\
         \\Generates the list of Linux syscalls for each supported cpu arch, using the Linux development tree.
         \\Prints to stdout Zig code which you can use to replace the file lib/std/os/linux/syscalls.zig.
         \\
-    , .{arg0}) catch std.process.exit(1);
+    , .{arg0});
-    std.process.exit(code);
 }

tools/update_clang_options.zig+22-20

 @@ -634,25 +634,25 @@ pub fn main() anyerror!void {
     const allocator = arena.allocator();
     const args = try std.process.argsAlloc(allocator);
-    if (args.len <= 1) {
+    var stdout_buffer: [4000]u8 = undefined;
-        usageAndExit(std.io.getStdErr(), args[0], 1);
+    var stdout_writer = fs.stdout().writerStreaming(&stdout_buffer);
-    }
+    const stdout = &stdout_writer.interface;
+    if (args.len <= 1) printUsageAndExit(args[0]);
     if (std.mem.eql(u8, args[1], "--help")) {
-        usageAndExit(std.io.getStdOut(), args[0], 0);
+        printUsage(stdout, args[0]) catch std.process.exit(2);
-    }
+        stdout.flush() catch std.process.exit(2);
-    if (args.len < 3) {
+        std.process.exit(0);
-        usageAndExit(std.io.getStdErr(), args[0], 1);
     }
+    if (args.len < 3) printUsageAndExit(args[0]);
     const llvm_tblgen_exe = args[1];
-    if (std.mem.startsWith(u8, llvm_tblgen_exe, "-")) {
+    if (std.mem.startsWith(u8, llvm_tblgen_exe, "-")) printUsageAndExit(args[0]);
-        usageAndExit(std.io.getStdErr(), args[0], 1);
-    }
     const llvm_src_root = args[2];
-    if (std.mem.startsWith(u8, llvm_src_root, "-")) {
+    if (std.mem.startsWith(u8, llvm_src_root, "-")) printUsageAndExit(args[0]);
-        usageAndExit(std.io.getStdErr(), args[0], 1);
-    }
     var llvm_to_zig_cpu_features = std.StringHashMap([]const u8).init(allocator);
 @@ -719,8 +719,6 @@ pub fn main() anyerror!void {
     // "W" and "Wl,". So we sort this list in order of descending priority.
     std.mem.sort(*json.ObjectMap, all_objects.items, {}, objectLessThan);
-    var buffered_stdout = std.io.bufferedWriter(std.io.getStdOut().writer());
-    const stdout = buffered_stdout.writer();
     try stdout.writeAll(
         \\// This file is generated by tools/update_clang_options.zig.
         \\// zig fmt: off
 @@ -815,7 +813,7 @@ pub fn main() anyerror!void {
         \\
     );
-    try buffered_stdout.flush();
+    try stdout.flush();
 }
 // TODO we should be able to import clang_options.zig but currently this is problematic because it will
 @@ -966,13 +964,17 @@ fn objectLessThan(context: void, a: *json.ObjectMap, b: *json.ObjectMap) bool {
     return std.mem.lessThan(u8, a_key, b_key);
 }
-fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
+fn printUsageAndExit(arg0: []const u8) noreturn {
-    file.writer().print(
+    printUsage(std.debug.lockStderrWriter(&.{}), arg0) catch std.process.exit(2);
+    std.process.exit(1);
+}
+fn printUsage(w: *std.io.Writer, arg0: []const u8) std.io.Writer.Error!void {
+    try w.print(
         \\Usage: {s} /path/to/llvm-tblgen /path/to/git/llvm/llvm-project
         \\Alternative Usage: zig run /path/to/git/zig/tools/update_clang_options.zig -- /path/to/llvm-tblgen /path/to/git/llvm/llvm-project
         \\
         \\Prints to stdout Zig code which you can use to replace the file src/clang_options_data.zig.
         \\
-    , .{arg0}) catch std.process.exit(1);
+    , .{arg0});
-    std.process.exit(code);
 }

tools/update_cpu_features.zig+2-2

...	@@ -2082,8 +2082,8 @@ fn processOneTarget(job: Job) void {	...	@@ -2082,8 +2082,8 @@ fn processOneTarget(job: Job) void {
2082	}	2082	}
2083		2083
2084	fn usageAndExit(arg0: []const u8, code: u8) noreturn {	2084	fn usageAndExit(arg0: []const u8, code: u8) noreturn {
2085	const stderr = std.io.getStdErr();	2085	const stderr = std.debug.lockStderrWriter(&.{});
2086	stderr.writer().print(	2086	stderr.print(
2087	\\Usage: {s} /path/to/llvm-tblgen /path/git/llvm-project /path/git/zig [zig_name filter]	2087	\\Usage: {s} /path/to/llvm-tblgen /path/git/llvm-project /path/git/zig [zig_name filter]
2088	\\	2088	\\
2089	\\Updates lib/std/target/<target>.zig from llvm/lib/Target/<Target>/<Target>.td .	2089	\\Updates lib/std/target/<target>.zig from llvm/lib/Target/<Target>/<Target>.td .

tools/update_crc_catalog.zig+10-10

 @@ -11,14 +11,10 @@ pub fn main() anyerror!void {
     const arena = arena_state.allocator();
     const args = try std.process.argsAlloc(arena);
-    if (args.len <= 1) {
+    if (args.len <= 1) printUsageAndExit(args[0]);
-        usageAndExit(std.io.getStdErr(), args[0], 1);
-    }
     const zig_src_root = args[1];
-    if (mem.startsWith(u8, zig_src_root, "-")) {
+    if (mem.startsWith(u8, zig_src_root, "-")) printUsageAndExit(args[0]);
-        usageAndExit(std.io.getStdErr(), args[0], 1);
-    }
     var zig_src_dir = try fs.cwd().openDir(zig_src_root, .{});
     defer zig_src_dir.close();
 @@ -193,10 +189,14 @@ pub fn main() anyerror!void {
     }
 }
-fn usageAndExit(file: fs.File, arg0: []const u8, code: u8) noreturn {
+fn printUsageAndExit(arg0: []const u8) noreturn {
-    file.writer().print(
+    printUsage(std.debug.lockStderrWriter(&.{}), arg0) catch std.process.exit(2);
+    std.process.exit(1);
+}
+fn printUsage(w: *std.io.Writer, arg0: []const u8) std.io.Writer.Error!void {
+    return w.print(
         \\Usage: {s} /path/git/zig
         \\
-    , .{arg0}) catch std.process.exit(1);
+    , .{arg0});
-    std.process.exit(code);
 }

author	Andrew Kelley <andrew@ziglang.org> 2025-07-07 19:33:20-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-07 22:43:53-07:00
log	d8e26275f29b304772bfeed9359e1ff5fe7038a8
tree	b255b2a136beedb6a411ad0eae273354d9c4040c
parent	c873c2eed9f9bcd4e8d8d6937ea7c3644d382440

...	@@ -511,7 +511,7 @@ pub const Header = struct {	...	@@ -511,7 +511,7 @@ pub const Header = struct {
511	pub fn read(parse_source: anytype) !Header {	511	pub fn read(parse_source: anytype) !Header {
512	var hdr_buf: [@sizeOf(Elf64_Ehdr)]u8 align(@alignOf(Elf64_Ehdr)) = undefined;	512	var hdr_buf: [@sizeOf(Elf64_Ehdr)]u8 align(@alignOf(Elf64_Ehdr)) = undefined;
513	try parse_source.seekableStream().seekTo(0);	513	try parse_source.seekableStream().seekTo(0);
514	try parse_source.reader().readNoEof(&hdr_buf);	514	try parse_source.deprecatedReader().readNoEof(&hdr_buf);
515	return Header.parse(&hdr_buf);	515	return Header.parse(&hdr_buf);
516	}	516	}
517		517
...	@@ -586,7 +586,7 @@ pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {	...	@@ -586,7 +586,7 @@ pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
586	var phdr: Elf64_Phdr = undefined;	586	var phdr: Elf64_Phdr = undefined;
587	const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;	587	const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
588	try self.parse_source.seekableStream().seekTo(offset);	588	try self.parse_source.seekableStream().seekTo(offset);
589	try self.parse_source.reader().readNoEof(mem.asBytes(&phdr));	589	try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&phdr));
590		590
591	// ELF endianness matches native endianness.	591	// ELF endianness matches native endianness.
592	if (self.elf_header.endian == native_endian) return phdr;	592	if (self.elf_header.endian == native_endian) return phdr;
...	@@ -599,7 +599,7 @@ pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {	...	@@ -599,7 +599,7 @@ pub fn ProgramHeaderIterator(comptime ParseSource: anytype) type {
599	var phdr: Elf32_Phdr = undefined;	599	var phdr: Elf32_Phdr = undefined;
600	const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;	600	const offset = self.elf_header.phoff + @sizeOf(@TypeOf(phdr)) * self.index;
601	try self.parse_source.seekableStream().seekTo(offset);	601	try self.parse_source.seekableStream().seekTo(offset);
602	try self.parse_source.reader().readNoEof(mem.asBytes(&phdr));	602	try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&phdr));
603		603
604	// ELF endianness does NOT match native endianness.	604	// ELF endianness does NOT match native endianness.
605	if (self.elf_header.endian != native_endian) {	605	if (self.elf_header.endian != native_endian) {
...	@@ -636,7 +636,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {	...	@@ -636,7 +636,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
636	var shdr: Elf64_Shdr = undefined;	636	var shdr: Elf64_Shdr = undefined;
637	const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;	637	const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
638	try self.parse_source.seekableStream().seekTo(offset);	638	try self.parse_source.seekableStream().seekTo(offset);
639	try self.parse_source.reader().readNoEof(mem.asBytes(&shdr));	639	try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&shdr));
640		640
641	// ELF endianness matches native endianness.	641	// ELF endianness matches native endianness.
642	if (self.elf_header.endian == native_endian) return shdr;	642	if (self.elf_header.endian == native_endian) return shdr;
...	@@ -649,7 +649,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {	...	@@ -649,7 +649,7 @@ pub fn SectionHeaderIterator(comptime ParseSource: anytype) type {
649	var shdr: Elf32_Shdr = undefined;	649	var shdr: Elf32_Shdr = undefined;
650	const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;	650	const offset = self.elf_header.shoff + @sizeOf(@TypeOf(shdr)) * self.index;
651	try self.parse_source.seekableStream().seekTo(offset);	651	try self.parse_source.seekableStream().seekTo(offset);
652	try self.parse_source.reader().readNoEof(mem.asBytes(&shdr));	652	try self.parse_source.deprecatedReader().readNoEof(mem.asBytes(&shdr));
653		653
654	// ELF endianness does NOT match native endianness.	654	// ELF endianness does NOT match native endianness.
655	if (self.elf_header.endian != native_endian) {	655	if (self.elf_header.endian != native_endian) {

...	@@ -6074,7 +6074,7 @@ fn cmdAstCheck(	...	@@ -6074,7 +6074,7 @@ fn cmdAstCheck(
6074		6074
6075	const tree = try Ast.parse(arena, source, mode);	6075	const tree = try Ast.parse(arena, source, mode);
6076		6076
6077	var stdout_writer = fs.File.stdout().writer(&stdio_buffer);	6077	var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
6078	const stdout_bw = &stdout_writer.interface;	6078	const stdout_bw = &stdout_writer.interface;
6079	switch (mode) {	6079	switch (mode) {
6080	.zig => {	6080	.zig => {
...	@@ -6289,7 +6289,7 @@ fn detectNativeCpuWithLLVM(	...	@@ -6289,7 +6289,7 @@ fn detectNativeCpuWithLLVM(
6289	}	6289	}
6290		6290
6291	fn printCpu(cpu: std.Target.Cpu) !void {	6291	fn printCpu(cpu: std.Target.Cpu) !void {
6292	var stdout_writer = fs.File.stdout().writer(&stdio_buffer);	6292	var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
6293	const stdout_bw = &stdout_writer.interface;	6293	const stdout_bw = &stdout_writer.interface;
6294		6294
6295	if (cpu.model.llvm_name) \|llvm_name\| {	6295	if (cpu.model.llvm_name) \|llvm_name\| {
...	@@ -6338,7 +6338,7 @@ fn cmdDumpLlvmInts(	...	@@ -6338,7 +6338,7 @@ fn cmdDumpLlvmInts(
6338	const dl = tm.createTargetDataLayout();	6338	const dl = tm.createTargetDataLayout();
6339	const context = llvm.Context.create();	6339	const context = llvm.Context.create();
6340		6340
6341	var stdout_writer = fs.File.stdout().writer(&stdio_buffer);	6341	var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
6342	const stdout_bw = &stdout_writer.interface;	6342	const stdout_bw = &stdout_writer.interface;
6343	for ([_]u16{ 1, 8, 16, 32, 64, 128, 256 }) \|bits\| {	6343	for ([_]u16{ 1, 8, 16, 32, 64, 128, 256 }) \|bits\| {
6344	const int_type = context.intType(bits);	6344	const int_type = context.intType(bits);
...	@@ -6367,7 +6367,7 @@ fn cmdDumpZir(	...	@@ -6367,7 +6367,7 @@ fn cmdDumpZir(
6367	defer f.close();	6367	defer f.close();
6368		6368
6369	const zir = try Zcu.loadZirCache(arena, f);	6369	const zir = try Zcu.loadZirCache(arena, f);
6370	var stdout_writer = fs.File.stdout().writer(&stdio_buffer);	6370	var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
6371	const stdout_bw = &stdout_writer.interface;	6371	const stdout_bw = &stdout_writer.interface;
6372		6372
6373	{	6373	{
...	@@ -6453,7 +6453,7 @@ fn cmdChangelist(	...	@@ -6453,7 +6453,7 @@ fn cmdChangelist(
6453	var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;	6453	var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;
6454	try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);	6454	try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);
6455		6455
6456	var stdout_writer = fs.File.stdout().writer(&stdio_buffer);	6456	var stdout_writer = fs.File.stdout().writerStreaming(&stdio_buffer);
6457	const stdout_bw = &stdout_writer.interface;	6457	const stdout_bw = &stdout_writer.interface;
6458	{	6458	{
6459	try stdout_bw.print("Instruction mappings:\n", .{});	6459	try stdout_bw.print("Instruction mappings:\n", .{});
...	@@ -6913,7 +6913,7 @@ fn cmdFetch(	...	@@ -6913,7 +6913,7 @@ fn cmdFetch(
6913		6913
6914	const name = switch (save) {	6914	const name = switch (save) {
6915	.no => {	6915	.no => {
6916	var stdout = fs.File.stdout().writer(&stdio_buffer);	6916	var stdout = fs.File.stdout().writerStreaming(&stdio_buffer);
6917	try stdout.interface.print("{s}\n", .{package_hash_slice});	6917	try stdout.interface.print("{s}\n", .{package_hash_slice});
6918	try stdout.interface.flush();	6918	try stdout.interface.flush();
6919	return cleanExit();	6919	return cleanExit();

update standalone and incremental tests to new API