Commit bb1dffcf32b5f59c2eaadbb522063d6c0415d924 | zig

author	Andrew Kelley <andrew@ziglang.org> 2025-02-17 15:51:48-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:26-07:00
log	bb1dffcf32b5f59c2eaadbb522063d6c0415d924
tree	05764a0ce0a1d852eb9046085f68e3ae7d4e8410
parent	f3be721785013de85faf5d0fa454a7a8bc049c0b

much of the compiler upgraded to new API

26 files changed, 816 insertions(+), 846 deletions(-)

lib
- std
  - crypto
    tls
    Client.zig
  - io.zig
  - io
    BufferedWriter.zig
  - tar.zig
  - zig
    Ast.zig
    AstGen.zig
    ZonGen.zig
    render.zig
    string_literal.zig
src
- Air
  - print.zig
- Builtin.zig
- Package
  - Fetch.zig
  - Fetch
    git.zig
- Zcu
  - PerThread.zig
- arch
  - x86_64
    encoder.zig
- fmt.zig
- libs
  - mingw.zig
- link
  - Coff.zig
  - MachO
    dyld_info
    Trie.zig
  - Wasm
    Flush.zig
- main.zig
- print_env.zig
- print_targets.zig
- print_zir.zig
- print_zoir.zig
- translate_c.zig

lib/std/crypto/tls/Client.zig+2-2

...	@@ -125,9 +125,9 @@ pub const Options = struct {	...	@@ -125,9 +125,9 @@ pub const Options = struct {
125	/// Verify that the server certificate is authorized by a given ca bundle.	125	/// Verify that the server certificate is authorized by a given ca bundle.
126	bundle: Certificate.Bundle,	126	bundle: Certificate.Bundle,
127	},	127	},
128	/// If non-null, ssl secrets are logged to this file. Creating such a log file allows	128	/// If non-null, ssl secrets are logged to this stream. Creating such a log file allows
129	/// other programs with access to that file to decrypt all traffic over this connection.	129	/// other programs with access to that file to decrypt all traffic over this connection.
130	ssl_key_log_file: ?std.fs.File = null,	130	ssl_key_log_file: ?*std.io.BufferedWriter = null,
131	};	131	};
132		132
133	pub fn InitError(comptime Stream: type) type {	133	pub fn InitError(comptime Stream: type) type {

lib/std/io.zig-2

...	@@ -282,8 +282,6 @@ pub const Reader = GenericReader;	...	@@ -282,8 +282,6 @@ pub const Reader = GenericReader;
282	pub const Writer = @import("io/Writer.zig");	282	pub const Writer = @import("io/Writer.zig");
283		283
284	pub const AnyReader = @import("io/Reader.zig");	284	pub const AnyReader = @import("io/Reader.zig");
285	/// Deprecated; to be removed after 0.14.0 is tagged.
286	pub const AnyWriter = Writer;
287		285
288	pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;	286	pub const SeekableStream = @import("io/seekable_stream.zig").SeekableStream;
289		287

lib/std/io/BufferedWriter.zig+8-3

 @@ -663,9 +663,14 @@ pub fn printValue(
             }
         },
         .error_set => {
-            if (actual_fmt.len != 0) invalidFmtError(fmt, value);
+            if (actual_fmt.len > 0 and actual_fmt.len[0] == 's') {
-            try bw.writeAll("error.");
+                return bw.writeAll(@errorName(value));
-            return bw.writeAll(@errorName(value));
+            } else if (actual_fmt.len != 0) {
+                invalidFmtError(fmt, value);
+            } else {
+                try bw.writeAll("error.");
+                return bw.writeAll(@errorName(value));
+            }
         },
         .@"enum" => |enumInfo| {
             try bw.writeAll(@typeName(T));

lib/std/tar.zig+4-3

 @@ -603,9 +603,10 @@ fn PaxIterator(comptime ReaderType: type) type {
             return null;
         }
-        fn readUntil(self: *Self, delimiter: u8) ![]const u8 {
+        fn readUntil(self: *Self, delimiter: u8) anyerror![]const u8 {
-            var fbs: std.io.FixedBufferStream = .{ .buffer = &self.scratch };
+            var fbs: std.io.BufferedWriter = undefined;
-            try self.reader.streamUntilDelimiter(fbs.writer(), delimiter, null);
+            fbs.initFixed(&self.scratch);
+            try self.reader.streamUntilDelimiter(&fbs, delimiter, null);
             return fbs.getWritten();
         }

lib/std/zig/Ast.zig+77-80

 @@ -199,27 +199,24 @@ pub fn parse(gpa: Allocator, source: [:0]const u8, mode: Mode) Allocator.Error!A
 /// `gpa` is used for allocating the resulting formatted source code.
 /// Caller owns the returned slice of bytes, allocated with `gpa`.
-pub fn render(tree: Ast, gpa: Allocator) RenderError![]u8 {
+pub fn renderAlloc(tree: Ast, gpa: Allocator) RenderError![]u8 {
-    var buffer = std.ArrayList(u8).init(gpa);
+    var aw: std.io.AllocatingWriter = undefined;
-    defer buffer.deinit();
+    const bw = aw.init(gpa);
+    errdefer aw.deinit();
+    render(tree, gpa, bw, .{}) catch |err| return @errorCast(err); // TODO try @errorCast(...)
+    return aw.toOwnedSlice();
+}
-    try tree.renderToArrayList(&buffer, .{});
+pub fn render(tree: Ast, gpa: Allocator, bw: *std.io.BufferedWriter, fixups: Fixups) anyerror!void {
-    return buffer.toOwnedSlice();
+    return @import("./render.zig").renderTree(gpa, bw, tree, fixups);
 }
 pub const Fixups = private_render.Fixups;
-pub fn renderToArrayList(tree: Ast, buffer: *std.ArrayList(u8), fixups: Fixups) RenderError!void {
-    return @import("./render.zig").renderTree(buffer, tree, fixups);
-}
 /// Returns an extra offset for column and byte offset of errors that
 /// should point after the token in the error message.
 pub fn errorOffset(tree: Ast, parse_error: Error) u32 {
-    return if (parse_error.token_is_prev)
+    return if (parse_error.token_is_prev) @intCast(tree.tokenSlice(parse_error.token).len) else 0;
-        @as(u32, @intCast(tree.tokenSlice(parse_error.token).len))
-    else
-        0;
 }
 pub fn tokenLocation(self: Ast, start_offset: ByteOffset, token_index: TokenIndex) Location {
 @@ -318,254 +315,254 @@ pub fn rootDecls(tree: Ast) []const Node.Index {
     }
 }
-pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
+pub fn renderError(tree: Ast, parse_error: Error, bw: *std.io.BufferedWriter) anyerror!void {
     switch (parse_error.tag) {
         .asterisk_after_ptr_deref => {
             // Note that the token will point at the `.*` but ideally the source
             // location would point to the `*` after the `.*`.
-            return stream.writeAll("'.*' cannot be followed by '*'; are you missing a space?");
+            return bw.writeAll("'.*' cannot be followed by '*'; are you missing a space?");
         },
         .chained_comparison_operators => {
-            return stream.writeAll("comparison operators cannot be chained");
+            return bw.writeAll("comparison operators cannot be chained");
         },
         .decl_between_fields => {
-            return stream.writeAll("declarations are not allowed between container fields");
+            return bw.writeAll("declarations are not allowed between container fields");
         },
         .expected_block => {
-            return stream.print("expected block, found '{s}'", .{
+            return bw.print("expected block, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_block_or_assignment => {
-            return stream.print("expected block or assignment, found '{s}'", .{
+            return bw.print("expected block or assignment, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_block_or_expr => {
-            return stream.print("expected block or expression, found '{s}'", .{
+            return bw.print("expected block or expression, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_block_or_field => {
-            return stream.print("expected block or field, found '{s}'", .{
+            return bw.print("expected block or field, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_container_members => {
-            return stream.print("expected test, comptime, var decl, or container field, found '{s}'", .{
+            return bw.print("expected test, comptime, var decl, or container field, found '{s}'", .{
                 tree.tokenTag(parse_error.token).symbol(),
             });
         },
         .expected_expr => {
-            return stream.print("expected expression, found '{s}'", .{
+            return bw.print("expected expression, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_expr_or_assignment => {
-            return stream.print("expected expression or assignment, found '{s}'", .{
+            return bw.print("expected expression or assignment, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_expr_or_var_decl => {
-            return stream.print("expected expression or var decl, found '{s}'", .{
+            return bw.print("expected expression or var decl, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_fn => {
-            return stream.print("expected function, found '{s}'", .{
+            return bw.print("expected function, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_inlinable => {
-            return stream.print("expected 'while' or 'for', found '{s}'", .{
+            return bw.print("expected 'while' or 'for', found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_labelable => {
-            return stream.print("expected 'while', 'for', 'inline', or '{{', found '{s}'", .{
+            return bw.print("expected 'while', 'for', 'inline', or '{{', found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_param_list => {
-            return stream.print("expected parameter list, found '{s}'", .{
+            return bw.print("expected parameter list, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_prefix_expr => {
-            return stream.print("expected prefix expression, found '{s}'", .{
+            return bw.print("expected prefix expression, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_primary_type_expr => {
-            return stream.print("expected primary type expression, found '{s}'", .{
+            return bw.print("expected primary type expression, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_pub_item => {
-            return stream.writeAll("expected function or variable declaration after pub");
+            return bw.writeAll("expected function or variable declaration after pub");
         },
         .expected_return_type => {
-            return stream.print("expected return type expression, found '{s}'", .{
+            return bw.print("expected return type expression, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_semi_or_else => {
-            return stream.writeAll("expected ';' or 'else' after statement");
+            return bw.writeAll("expected ';' or 'else' after statement");
         },
         .expected_semi_or_lbrace => {
-            return stream.writeAll("expected ';' or block after function prototype");
+            return bw.writeAll("expected ';' or block after function prototype");
         },
         .expected_statement => {
-            return stream.print("expected statement, found '{s}'", .{
+            return bw.print("expected statement, found '{s}'", .{
                 tree.tokenTag(parse_error.token).symbol(),
             });
         },
         .expected_suffix_op => {
-            return stream.print("expected pointer dereference, optional unwrap, or field access, found '{s}'", .{
+            return bw.print("expected pointer dereference, optional unwrap, or field access, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_type_expr => {
-            return stream.print("expected type expression, found '{s}'", .{
+            return bw.print("expected type expression, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_var_decl => {
-            return stream.print("expected variable declaration, found '{s}'", .{
+            return bw.print("expected variable declaration, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_var_decl_or_fn => {
-            return stream.print("expected variable declaration or function, found '{s}'", .{
+            return bw.print("expected variable declaration or function, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_loop_payload => {
-            return stream.print("expected loop payload, found '{s}'", .{
+            return bw.print("expected loop payload, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .expected_container => {
-            return stream.print("expected a struct, enum or union, found '{s}'", .{
+            return bw.print("expected a struct, enum or union, found '{s}'", .{
                 tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev)).symbol(),
             });
         },
         .extern_fn_body => {
-            return stream.writeAll("extern functions have no body");
+            return bw.writeAll("extern functions have no body");
         },
         .extra_addrspace_qualifier => {
-            return stream.writeAll("extra addrspace qualifier");
+            return bw.writeAll("extra addrspace qualifier");
         },
         .extra_align_qualifier => {
-            return stream.writeAll("extra align qualifier");
+            return bw.writeAll("extra align qualifier");
         },
         .extra_allowzero_qualifier => {
-            return stream.writeAll("extra allowzero qualifier");
+            return bw.writeAll("extra allowzero qualifier");
         },
         .extra_const_qualifier => {
-            return stream.writeAll("extra const qualifier");
+            return bw.writeAll("extra const qualifier");
         },
         .extra_volatile_qualifier => {
-            return stream.writeAll("extra volatile qualifier");
+            return bw.writeAll("extra volatile qualifier");
         },
         .ptr_mod_on_array_child_type => {
-            return stream.print("pointer modifier '{s}' not allowed on array child type", .{
+            return bw.print("pointer modifier '{s}' not allowed on array child type", .{
                 tree.tokenTag(parse_error.token).symbol(),
             });
         },
         .invalid_bit_range => {
-            return stream.writeAll("bit range not allowed on slices and arrays");
+            return bw.writeAll("bit range not allowed on slices and arrays");
         },
         .same_line_doc_comment => {
-            return stream.writeAll("same line documentation comment");
+            return bw.writeAll("same line documentation comment");
         },
         .unattached_doc_comment => {
-            return stream.writeAll("unattached documentation comment");
+            return bw.writeAll("unattached documentation comment");
         },
         .test_doc_comment => {
-            return stream.writeAll("documentation comments cannot be attached to tests");
+            return bw.writeAll("documentation comments cannot be attached to tests");
         },
         .comptime_doc_comment => {
-            return stream.writeAll("documentation comments cannot be attached to comptime blocks");
+            return bw.writeAll("documentation comments cannot be attached to comptime blocks");
         },
         .varargs_nonfinal => {
-            return stream.writeAll("function prototype has parameter after varargs");
+            return bw.writeAll("function prototype has parameter after varargs");
         },
         .expected_continue_expr => {
-            return stream.writeAll("expected ':' before while continue expression");
+            return bw.writeAll("expected ':' before while continue expression");
         },
         .expected_semi_after_decl => {
-            return stream.writeAll("expected ';' after declaration");
+            return bw.writeAll("expected ';' after declaration");
         },
         .expected_semi_after_stmt => {
-            return stream.writeAll("expected ';' after statement");
+            return bw.writeAll("expected ';' after statement");
         },
         .expected_comma_after_field => {
-            return stream.writeAll("expected ',' after field");
+            return bw.writeAll("expected ',' after field");
         },
         .expected_comma_after_arg => {
-            return stream.writeAll("expected ',' after argument");
+            return bw.writeAll("expected ',' after argument");
         },
         .expected_comma_after_param => {
-            return stream.writeAll("expected ',' after parameter");
+            return bw.writeAll("expected ',' after parameter");
         },
         .expected_comma_after_initializer => {
-            return stream.writeAll("expected ',' after initializer");
+            return bw.writeAll("expected ',' after initializer");
         },
         .expected_comma_after_switch_prong => {
-            return stream.writeAll("expected ',' after switch prong");
+            return bw.writeAll("expected ',' after switch prong");
         },
         .expected_comma_after_for_operand => {
-            return stream.writeAll("expected ',' after for operand");
+            return bw.writeAll("expected ',' after for operand");
         },
         .expected_comma_after_capture => {
-            return stream.writeAll("expected ',' after for capture");
+            return bw.writeAll("expected ',' after for capture");
         },
         .expected_initializer => {
-            return stream.writeAll("expected field initializer");
+            return bw.writeAll("expected field initializer");
         },
         .mismatched_binary_op_whitespace => {
-            return stream.print("binary operator '{s}' has whitespace on one side, but not the other", .{tree.tokenTag(parse_error.token).lexeme().?});
+            return bw.print("binary operator '{s}' has whitespace on one side, but not the other", .{tree.tokenTag(parse_error.token).lexeme().?});
         },
         .invalid_ampersand_ampersand => {
-            return stream.writeAll("ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND");
+            return bw.writeAll("ambiguous use of '&&'; use 'and' for logical AND, or change whitespace to ' & &' for bitwise AND");
         },
         .c_style_container => {
-            return stream.print("'{s} {s}' is invalid", .{
+            return bw.print("'{s} {s}' is invalid", .{
                 parse_error.extra.expected_tag.symbol(), tree.tokenSlice(parse_error.token),
             });
         },
         .zig_style_container => {
-            return stream.print("to declare a container do 'const {s} = {s}'", .{
+            return bw.print("to declare a container do 'const {s} = {s}'", .{
                 tree.tokenSlice(parse_error.token), parse_error.extra.expected_tag.symbol(),
             });
         },
         .previous_field => {
-            return stream.writeAll("field before declarations here");
+            return bw.writeAll("field before declarations here");
         },
         .next_field => {
-            return stream.writeAll("field after declarations here");
+            return bw.writeAll("field after declarations here");
         },
         .expected_var_const => {
-            return stream.writeAll("expected 'var' or 'const' before variable declaration");
+            return bw.writeAll("expected 'var' or 'const' before variable declaration");
         },
         .wrong_equal_var_decl => {
-            return stream.writeAll("variable initialized with '==' instead of '='");
+            return bw.writeAll("variable initialized with '==' instead of '='");
         },
         .var_const_decl => {
-            return stream.writeAll("use 'var' or 'const' to declare variable");
+            return bw.writeAll("use 'var' or 'const' to declare variable");
         },
         .extra_for_capture => {
-            return stream.writeAll("extra capture in for loop");
+            return bw.writeAll("extra capture in for loop");
         },
         .for_input_not_captured => {
-            return stream.writeAll("for input is not captured");
+            return bw.writeAll("for input is not captured");
         },
         .invalid_byte => {
             const tok_slice = tree.source[tree.tokens.items(.start)[parse_error.token]..];
-            return stream.print("{s} contains invalid byte: '{'}'", .{
+            return bw.print("{s} contains invalid byte: '{'}'", .{
                 switch (tok_slice[0]) {
                     '\'' => "character literal",
                     '"', '\\' => "string literal",
 @@ -580,10 +577,10 @@ pub fn renderError(tree: Ast, parse_error: Error, stream: anytype) !void {
             const found_tag = tree.tokenTag(parse_error.token + @intFromBool(parse_error.token_is_prev));
             const expected_symbol = parse_error.extra.expected_tag.symbol();
             switch (found_tag) {
-                .invalid => return stream.print("expected '{s}', found invalid bytes", .{
+                .invalid => return bw.print("expected '{s}', found invalid bytes", .{
                     expected_symbol,
                 }),
-                else => return stream.print("expected '{s}', found '{s}'", .{
+                else => return bw.print("expected '{s}', found '{s}'", .{
                     expected_symbol, found_tag.symbol(),
                 }),
             }

lib/std/zig/AstGen.zig+26-21

 @@ -11441,10 +11441,13 @@ fn parseStrLit(
     offset: u32,
 ) InnerError!void {
     const raw_string = bytes[offset..];
-    var buf_managed = buf.toManaged(astgen.gpa);
+    const result = r: {
-    const result = std.zig.string_literal.parseWrite(buf_managed.writer(), raw_string);
+        var aw: std.io.AllocatingWriter = undefined;
-    buf.* = buf_managed.moveToUnmanaged();
+        const bw = aw.fromArrayList(astgen.gpa, buf);
-    switch (try result) {
+        defer buf.* = aw.toArrayList();
+        break :r std.zig.string_literal.parseWrite(bw, raw_string) catch |err| return @errorCast(err);
+    };
+    switch (result) {
         .success => return,
         .failure => |err| return astgen.failWithStrLitError(err, token, bytes, offset),
     }
 @@ -11493,17 +11496,18 @@ fn appendErrorNodeNotes(
     notes: []const u32,
 ) Allocator.Error!void {
     @branchHint(.cold);
+    const gpa = astgen.gpa;
     const string_bytes = &astgen.string_bytes;
     const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
-    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
+    try string_bytes.print(gpa, format ++ "\x00", args);
     const notes_index: u32 = if (notes.len != 0) blk: {
         const notes_start = astgen.extra.items.len;
-        try astgen.extra.ensureTotalCapacity(astgen.gpa, notes_start + 1 + notes.len);
+        try astgen.extra.ensureTotalCapacity(gpa, notes_start + 1 + notes.len);
         astgen.extra.appendAssumeCapacity(@intCast(notes.len));
         astgen.extra.appendSliceAssumeCapacity(notes);
         break :blk @intCast(notes_start);
     } else 0;
-    try astgen.compile_errors.append(astgen.gpa, .{
+    try astgen.compile_errors.append(gpa, .{
         .msg = msg,
         .node = node.toOptional(),
         .token = .none,
 @@ -11587,7 +11591,7 @@ fn appendErrorTokNotesOff(
     const gpa = astgen.gpa;
     const string_bytes = &astgen.string_bytes;
     const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
-    try string_bytes.writer(gpa).print(format ++ "\x00", args);
+    try string_bytes.print(gpa, format ++ "\x00", args);
     const notes_index: u32 = if (notes.len != 0) blk: {
         const notes_start = astgen.extra.items.len;
         try astgen.extra.ensureTotalCapacity(gpa, notes_start + 1 + notes.len);
 @@ -11623,7 +11627,7 @@ fn errNoteTokOff(
     @branchHint(.cold);
     const string_bytes = &astgen.string_bytes;
     const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
-    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
+    try string_bytes.print(astgen.gpa, format ++ "\x00", args);
     return astgen.addExtra(Zir.Inst.CompileErrors.Item{
         .msg = msg,
         .node = .none,
 @@ -11642,7 +11646,7 @@ fn errNoteNode(
     @branchHint(.cold);
     const string_bytes = &astgen.string_bytes;
     const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
-    try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);
+    try string_bytes.print(astgen.gpa, format ++ "\x00", args);
     return astgen.addExtra(Zir.Inst.CompileErrors.Item{
         .msg = msg,
         .node = node.toOptional(),
 @@ -13888,13 +13892,14 @@ fn emitDbgStmtForceCurrentIndex(gz: *GenZir, lc: LineColumn) !void {
     } });
 }
-fn lowerAstErrors(astgen: *AstGen) !void {
+fn lowerAstErrors(astgen: *AstGen) error{OutOfMemory}!void {
     const gpa = astgen.gpa;
     const tree = astgen.tree;
     assert(tree.errors.len > 0);
-    var msg: std.ArrayListUnmanaged(u8) = .empty;
+    var msg: std.io.AllocatingWriter = undefined;
-    defer msg.deinit(gpa);
+    const msg_writer = msg.init(gpa);
+    defer msg.deinit();
     var notes: std.ArrayListUnmanaged(u32) = .empty;
     defer notes.deinit(gpa);
 @@ -13928,20 +13933,20 @@ fn lowerAstErrors(astgen: *AstGen) !void {
             .extra = .{ .offset = bad_off },
         };
         msg.clearRetainingCapacity();
-        try tree.renderError(err, msg.writer(gpa));
+        tree.renderError(err, msg_writer) catch |e| return @errorCast(e); // TODO try @errorCast(...)
-        return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.items}, notes.items);
+        return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.getWritten()}, notes.items);
     }
     var cur_err = tree.errors[0];
     for (tree.errors[1..]) |err| {
         if (err.is_note) {
-            try tree.renderError(err, msg.writer(gpa));
+            tree.renderError(err, msg_writer) catch |e| return @errorCast(e); // TODO try @errorCast(...)
-            try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.items}));
+            try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.getWritten()}));
         } else {
             // Flush error
             const extra_offset = tree.errorOffset(cur_err);
-            try tree.renderError(cur_err, msg.writer(gpa));
+            tree.renderError(cur_err, msg_writer) catch |e| return @errorCast(e); // TODO try @errorCast(...)
-            try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);
+            try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
             notes.clearRetainingCapacity();
             cur_err = err;
 @@ -13954,8 +13959,8 @@ fn lowerAstErrors(astgen: *AstGen) !void {
     // Flush error
     const extra_offset = tree.errorOffset(cur_err);
-    try tree.renderError(cur_err, msg.writer(gpa));
+    tree.renderError(cur_err, msg_writer) catch |e| return @errorCast(e); // TODO try @errorCast(...)
-    try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);
+    try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
 }
 const DeclarationName = union(enum) {

lib/std/zig/ZonGen.zig+56-49

...	@@ -452,37 +452,43 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator	...	@@ -452,37 +452,43 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator
452	}	452	}
453	}	453	}
454		454
455	fn appendIdentStr(zg: *ZonGen, ident_token: Ast.TokenIndex) !u32 {	455	fn appendIdentStr(zg: *ZonGen, ident_token: Ast.TokenIndex) error{ OutOfMemory, BadString }!u32 {
		456	const gpa = zg.gpa;
456	const tree = zg.tree;	457	const tree = zg.tree;
457	assert(tree.tokenTag(ident_token) == .identifier);	458	assert(tree.tokenTag(ident_token) == .identifier);
458	const ident_name = tree.tokenSlice(ident_token);	459	const ident_name = tree.tokenSlice(ident_token);
459	if (!mem.startsWith(u8, ident_name, "@")) {	460	if (!mem.startsWith(u8, ident_name, "@")) {
460	const start = zg.string_bytes.items.len;	461	const start = zg.string_bytes.items.len;
461	try zg.string_bytes.appendSlice(zg.gpa, ident_name);	462	try zg.string_bytes.appendSlice(gpa, ident_name);
462	return @intCast(start);	463	return @intCast(start);
463	} else {	464	}
464	const offset = 1;	465	const offset = 1;
465	const start: u32 = @intCast(zg.string_bytes.items.len);	466	const start: u32 = @intCast(zg.string_bytes.items.len);
466	const raw_string = zg.tree.tokenSlice(ident_token)[offset..];	467	const raw_string = zg.tree.tokenSlice(ident_token)[offset..];
467	try zg.string_bytes.ensureUnusedCapacity(zg.gpa, raw_string.len);	468	try zg.string_bytes.ensureUnusedCapacity(gpa, raw_string.len);
468	switch (try std.zig.string_literal.parseWrite(zg.string_bytes.writer(zg.gpa), raw_string)) {	469	const result = r: {
469	.success => {},	470	var aw: std.io.AllocatingWriter = undefined;
470	.failure => \|err\| {	471	const bw = aw.fromArrayList(gpa, &zg.string_bytes);
471	try zg.lowerStrLitError(err, ident_token, raw_string, offset);	472	defer zg.string_bytes = aw.toArrayList();
472	return error.BadString;	473	break :r std.zig.string_literal.parseWrite(bw, raw_string) catch \|err\| return @errorCast(err);
473	},	474	};
474	}	475	switch (result) {
475		476	.success => {},
476	const slice = zg.string_bytes.items[start..];	477	.failure => \|err\| {
477	if (mem.indexOfScalar(u8, slice, 0) != null) {	478	try zg.lowerStrLitError(err, ident_token, raw_string, offset);
478	try zg.addErrorTok(ident_token, "identifier cannot contain null bytes", .{});
479	return error.BadString;
480	} else if (slice.len == 0) {
481	try zg.addErrorTok(ident_token, "identifier cannot be empty", .{});
482	return error.BadString;	479	return error.BadString;
483	}	480	},
484	return start;	481	}
		482
		483	const slice = zg.string_bytes.items[start..];
		484	if (mem.indexOfScalar(u8, slice, 0) != null) {
		485	try zg.addErrorTok(ident_token, "identifier cannot contain null bytes", .{});
		486	return error.BadString;
		487	} else if (slice.len == 0) {
		488	try zg.addErrorTok(ident_token, "identifier cannot be empty", .{});
		489	return error.BadString;
485	}	490	}
		491	return start;
486	}	492	}
487		493
488	/// Estimates the size of a string node without parsing it.	494	/// Estimates the size of a string node without parsing it.
...	@@ -513,8 +519,8 @@ pub fn strLitSizeHint(tree: Ast, node: Ast.Node.Index) usize {	...	@@ -513,8 +519,8 @@ pub fn strLitSizeHint(tree: Ast, node: Ast.Node.Index) usize {
513	pub fn parseStrLit(	519	pub fn parseStrLit(
514	tree: Ast,	520	tree: Ast,
515	node: Ast.Node.Index,	521	node: Ast.Node.Index,
516	writer: anytype,	522	writer: *std.io.BufferedWriter,
517	) error{OutOfMemory}!std.zig.string_literal.Result {	523	) anyerror!std.zig.string_literal.Result {
518	switch (tree.nodeTag(node)) {	524	switch (tree.nodeTag(node)) {
519	.string_literal => {	525	.string_literal => {
520	const token = tree.nodeMainToken(node);	526	const token = tree.nodeMainToken(node);
...	@@ -549,15 +555,21 @@ const StringLiteralResult = union(enum) {	...	@@ -549,15 +555,21 @@ const StringLiteralResult = union(enum) {
549	slice: struct { start: u32, len: u32 },	555	slice: struct { start: u32, len: u32 },
550	};	556	};
551		557
552	fn strLitAsString(zg: *ZonGen, str_node: Ast.Node.Index) !StringLiteralResult {	558	fn strLitAsString(zg: *ZonGen, str_node: Ast.Node.Index) error{ OutOfMemory, BadString }!StringLiteralResult {
553	if (!zg.options.parse_str_lits) return .{ .slice = .{ .start = 0, .len = 0 } };	559	if (!zg.options.parse_str_lits) return .{ .slice = .{ .start = 0, .len = 0 } };
554		560
555	const gpa = zg.gpa;	561	const gpa = zg.gpa;
556	const string_bytes = &zg.string_bytes;	562	const string_bytes = &zg.string_bytes;
557	const str_index: u32 = @intCast(zg.string_bytes.items.len);	563	const str_index: u32 = @intCast(zg.string_bytes.items.len);
558	const size_hint = strLitSizeHint(zg.tree, str_node);	564	const size_hint = strLitSizeHint(zg.tree, str_node);
559	try string_bytes.ensureUnusedCapacity(zg.gpa, size_hint);	565	try string_bytes.ensureUnusedCapacity(gpa, size_hint);
560	switch (try parseStrLit(zg.tree, str_node, zg.string_bytes.writer(zg.gpa))) {	566	const result = r: {
		567	var aw: std.io.AllocatingWriter = undefined;
		568	const bw = aw.fromArrayList(gpa, &zg.string_bytes);
		569	defer zg.string_bytes = aw.toArrayList();
		570	break :r parseStrLit(zg.tree, str_node, bw) catch \|err\| return @errorCast(err);
		571	};
		572	switch (result) {
561	.success => {},	573	.success => {},
562	.failure => \|err\| {	574	.failure => \|err\| {
563	const token = zg.tree.nodeMainToken(str_node);	575	const token = zg.tree.nodeMainToken(str_node);
...	@@ -805,10 +817,7 @@ fn lowerNumberError(zg: *ZonGen, err: std.zig.number_literal.Error, token: Ast.T	...	@@ -805,10 +817,7 @@ fn lowerNumberError(zg: *ZonGen, err: std.zig.number_literal.Error, token: Ast.T
805		817
806	fn errNoteNode(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, args: anytype) Allocator.Error!Zoir.CompileError.Note {	818	fn errNoteNode(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, args: anytype) Allocator.Error!Zoir.CompileError.Note {
807	const message_idx: u32 = @intCast(zg.string_bytes.items.len);	819	const message_idx: u32 = @intCast(zg.string_bytes.items.len);
808	const writer = zg.string_bytes.writer(zg.gpa);	820	try zg.string_bytes.print(zg.gpa, format ++ "\x00", args);
809	try writer.print(format, args);
810	try writer.writeByte(0);
811
812	return .{	821	return .{
813	.msg = @enumFromInt(message_idx),	822	.msg = @enumFromInt(message_idx),
814	.token = .none,	823	.token = .none,
...	@@ -818,10 +827,7 @@ fn errNoteNode(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, a	...	@@ -818,10 +827,7 @@ fn errNoteNode(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, a
818		827
819	fn errNoteTok(zg: *ZonGen, tok: Ast.TokenIndex, comptime format: []const u8, args: anytype) Allocator.Error!Zoir.CompileError.Note {	828	fn errNoteTok(zg: *ZonGen, tok: Ast.TokenIndex, comptime format: []const u8, args: anytype) Allocator.Error!Zoir.CompileError.Note {
820	const message_idx: u32 = @intCast(zg.string_bytes.items.len);	829	const message_idx: u32 = @intCast(zg.string_bytes.items.len);
821	const writer = zg.string_bytes.writer(zg.gpa);	830	try zg.string_bytes.print(zg.gpa, format ++ "\x00", args);
822	try writer.print(format, args);
823	try writer.writeByte(0);
824
825	return .{	831	return .{
826	.msg = @enumFromInt(message_idx),	832	.msg = @enumFromInt(message_idx),
827	.token = .fromToken(tok),	833	.token = .fromToken(tok),
...	@@ -862,9 +868,7 @@ fn addErrorInner(	...	@@ -862,9 +868,7 @@ fn addErrorInner(
862	try zg.error_notes.appendSlice(gpa, notes);	868	try zg.error_notes.appendSlice(gpa, notes);
863		869
864	const message_idx: u32 = @intCast(zg.string_bytes.items.len);	870	const message_idx: u32 = @intCast(zg.string_bytes.items.len);
865	const writer = zg.string_bytes.writer(zg.gpa);	871	try zg.string_bytes.print(gpa, format ++ "\x00", args);
866	try writer.print(format, args);
867	try writer.writeByte(0);
868		872
869	try zg.compile_errors.append(gpa, .{	873	try zg.compile_errors.append(gpa, .{
870	.msg = @enumFromInt(message_idx),	874	.msg = @enumFromInt(message_idx),
...	@@ -880,8 +884,9 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {	...	@@ -880,8 +884,9 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {
880	const tree = zg.tree;	884	const tree = zg.tree;
881	assert(tree.errors.len > 0);	885	assert(tree.errors.len > 0);
882		886
883	var msg: std.ArrayListUnmanaged(u8) = .empty;	887	var msg: std.io.AllocatingWriter = undefined;
884	defer msg.deinit(gpa);	888	const msg_bw = msg.init(gpa);
		889	defer msg.deinit();
885		890
886	var notes: std.ArrayListUnmanaged(Zoir.CompileError.Note) = .empty;	891	var notes: std.ArrayListUnmanaged(Zoir.CompileError.Note) = .empty;
887	defer notes.deinit(gpa);	892	defer notes.deinit(gpa);
...	@@ -889,18 +894,20 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {	...	@@ -889,18 +894,20 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {
889	var cur_err = tree.errors[0];	894	var cur_err = tree.errors[0];
890	for (tree.errors[1..]) \|err\| {	895	for (tree.errors[1..]) \|err\| {
891	if (err.is_note) {	896	if (err.is_note) {
892	try tree.renderError(err, msg.writer(gpa));	897	tree.renderError(err, msg_bw) catch \|e\| return @errorCast(e); // TODO: try @errorCast(...)
893	try notes.append(gpa, try zg.errNoteTok(err.token, "{s}", .{msg.items}));	898	try notes.append(gpa, try zg.errNoteTok(err.token, "{s}", .{msg.getWritten()}));
894	} else {	899	} else {
895	// Flush error	900	// Flush error
896	try tree.renderError(cur_err, msg.writer(gpa));	901	tree.renderError(cur_err, msg_bw) catch \|e\| return @errorCast(e); // TODO try @errorCast(...)
897	const extra_offset = tree.errorOffset(cur_err);	902	const extra_offset = tree.errorOffset(cur_err);
898	try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);	903	try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
899	notes.clearRetainingCapacity();	904	notes.clearRetainingCapacity();
900	cur_err = err;	905	cur_err = err;
901		906
902	// TODO: `Parse` currently does not have good error recovery mechanisms, so the remaining errors could be bogus.	907	// TODO: `Parse` currently does not have good error recovery
903	// As such, we'll ignore all remaining errors for now. We should improve `Parse` so that we can report all the errors.	908	// mechanisms, so the remaining errors could be bogus. As such,
		909	// we'll ignore all remaining errors for now. We should improve
		910	// `Parse` so that we can report all the errors.
904	return;	911	return;
905	}	912	}
906	msg.clearRetainingCapacity();	913	msg.clearRetainingCapacity();
...	@@ -908,8 +915,8 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {	...	@@ -908,8 +915,8 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {
908		915
909	// Flush error	916	// Flush error
910	const extra_offset = tree.errorOffset(cur_err);	917	const extra_offset = tree.errorOffset(cur_err);
911	try tree.renderError(cur_err, msg.writer(gpa));	918	tree.renderError(cur_err, msg_bw) catch \|e\| return @errorCast(e); // TODO try @errorCast(...)
912	try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);	919	try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
913	}	920	}
914		921
915	const std = @import("std");	922	const std = @import("std");

lib/std/zig/render.zig+297-291

...	@@ -10,10 +10,6 @@ const primitives = std.zig.primitives;	...	@@ -10,10 +10,6 @@ const primitives = std.zig.primitives;
10	const indent_delta = 4;	10	const indent_delta = 4;
11	const asm_indent_delta = 2;	11	const asm_indent_delta = 2;
12		12
13	pub const Error = Ast.RenderError;
14
15	const Ais = AutoIndentingStream(std.ArrayList(u8).Writer);
16
17	pub const Fixups = struct {	13	pub const Fixups = struct {
18	/// The key is the mut token (`var`/`const`) of the variable declaration	14	/// The key is the mut token (`var`/`const`) of the variable declaration
19	/// that should have a `_ = foo;` inserted afterwards.	15	/// that should have a `_ = foo;` inserted afterwards.
...	@@ -74,17 +70,17 @@ pub const Fixups = struct {	...	@@ -74,17 +70,17 @@ pub const Fixups = struct {
74		70
75	const Render = struct {	71	const Render = struct {
76	gpa: Allocator,	72	gpa: Allocator,
77	ais: *Ais,	73	ais: *AutoIndentingStream,
78	tree: Ast,	74	tree: Ast,
79	fixups: Fixups,	75	fixups: Fixups,
80	};	76	};
81		77
82	pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast, fixups: Fixups) Error!void {	78	pub fn renderTree(gpa: Allocator, bw: *std.io.BufferedWriter, tree: Ast, fixups: Fixups) anyerror!void {
83	assert(tree.errors.len == 0); // Cannot render an invalid tree.	79	assert(tree.errors.len == 0); // Cannot render an invalid tree.
84	var auto_indenting_stream = Ais.init(buffer, indent_delta);	80	var auto_indenting_stream: AutoIndentingStream = .init(bw, indent_delta);
85	defer auto_indenting_stream.deinit();	81	defer auto_indenting_stream.deinit();
86	var r: Render = .{	82	var r: Render = .{
87	.gpa = buffer.allocator,	83	.gpa = gpa,
88	.ais = &auto_indenting_stream,	84	.ais = &auto_indenting_stream,
89	.tree = tree,	85	.tree = tree,
90	.fixups = fixups,	86	.fixups = fixups,
...	@@ -115,7 +111,7 @@ pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast, fixups: Fixups) Error!v	...	@@ -115,7 +111,7 @@ pub fn renderTree(buffer: *std.ArrayList(u8), tree: Ast, fixups: Fixups) Error!v
115	}	111	}
116		112
117	/// Render all members in the given slice, keeping empty lines where appropriate	113	/// Render all members in the given slice, keeping empty lines where appropriate
118	fn renderMembers(r: *Render, members: []const Ast.Node.Index) Error!void {	114	fn renderMembers(r: *Render, members: []const Ast.Node.Index) anyerror!void {
119	const tree = r.tree;	115	const tree = r.tree;
120	if (members.len == 0) return;	116	if (members.len == 0) return;
121	const container: Container = for (members) \|member\| {	117	const container: Container = for (members) \|member\| {
...	@@ -139,7 +135,7 @@ fn renderMember(	...	@@ -139,7 +135,7 @@ fn renderMember(
139	container: Container,	135	container: Container,
140	decl: Ast.Node.Index,	136	decl: Ast.Node.Index,
141	space: Space,	137	space: Space,
142	) Error!void {	138	) anyerror!void {
143	const tree = r.tree;	139	const tree = r.tree;
144	const ais = r.ais;	140	const ais = r.ais;
145	if (r.fixups.omit_nodes.contains(decl)) return;	141	if (r.fixups.omit_nodes.contains(decl)) return;
...	@@ -186,7 +182,7 @@ fn renderMember(	...	@@ -186,7 +182,7 @@ fn renderMember(
186	if (opt_callconv_expr.unwrap()) \|callconv_expr\| {	182	if (opt_callconv_expr.unwrap()) \|callconv_expr\| {
187	if (tree.nodeTag(callconv_expr) == .enum_literal) {	183	if (tree.nodeTag(callconv_expr) == .enum_literal) {
188	if (mem.eql(u8, "@\"inline\"", tree.tokenSlice(tree.nodeMainToken(callconv_expr)))) {	184	if (mem.eql(u8, "@\"inline\"", tree.tokenSlice(tree.nodeMainToken(callconv_expr)))) {
189	try ais.writer().writeAll("inline ");	185	try ais.underlying_writer.writeAll("inline ");
190	}	186	}
191	}	187	}
192	}	188	}
...	@@ -200,7 +196,7 @@ fn renderMember(	...	@@ -200,7 +196,7 @@ fn renderMember(
200	const lbrace = tree.nodeMainToken(body_node);	196	const lbrace = tree.nodeMainToken(body_node);
201	try renderToken(r, lbrace, .newline);	197	try renderToken(r, lbrace, .newline);
202	try discardAllParams(r, fn_proto);	198	try discardAllParams(r, fn_proto);
203	try ais.writer().writeAll("@trap();");	199	try ais.writeAll("@trap();");
204	ais.popIndent();	200	ais.popIndent();
205	try ais.insertNewline();	201	try ais.insertNewline();
206	try renderToken(r, tree.lastToken(body_node), space); // rbrace	202	try renderToken(r, tree.lastToken(body_node), space); // rbrace
...	@@ -216,10 +212,9 @@ fn renderMember(	...	@@ -216,10 +212,9 @@ fn renderMember(
216	const name_ident = param.name_token.?;	212	const name_ident = param.name_token.?;
217	assert(tree.tokenTag(name_ident) == .identifier);	213	assert(tree.tokenTag(name_ident) == .identifier);
218	if (r.fixups.unused_var_decls.contains(name_ident)) {	214	if (r.fixups.unused_var_decls.contains(name_ident)) {
219	const w = ais.writer();	215	try ais.writeAll("_ = ");
220	try w.writeAll("_ = ");	216	try ais.writeAll(tokenSliceForRender(r.tree, name_ident));
221	try w.writeAll(tokenSliceForRender(r.tree, name_ident));	217	try ais.writeAll(";\n");
222	try w.writeAll(";\n");
223	}	218	}
224	}	219	}
225	var statements_buf: [2]Ast.Node.Index = undefined;	220	var statements_buf: [2]Ast.Node.Index = undefined;
...	@@ -310,7 +305,7 @@ fn renderMember(	...	@@ -310,7 +305,7 @@ fn renderMember(
310	}	305	}
311		306
312	/// Render all expressions in the slice, keeping empty lines where appropriate	307	/// Render all expressions in the slice, keeping empty lines where appropriate
313	fn renderExpressions(r: *Render, expressions: []const Ast.Node.Index, space: Space) Error!void {	308	fn renderExpressions(r: *Render, expressions: []const Ast.Node.Index, space: Space) anyerror!void {
314	if (expressions.len == 0) return;	309	if (expressions.len == 0) return;
315	try renderExpression(r, expressions[0], space);	310	try renderExpression(r, expressions[0], space);
316	for (expressions[1..]) \|expression\| {	311	for (expressions[1..]) \|expression\| {
...	@@ -319,11 +314,11 @@ fn renderExpressions(r: *Render, expressions: []const Ast.Node.Index, space: Spa	...	@@ -319,11 +314,11 @@ fn renderExpressions(r: *Render, expressions: []const Ast.Node.Index, space: Spa
319	}	314	}
320	}	315	}
321		316
322	fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {	317	fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) anyerror!void {
323	const tree = r.tree;	318	const tree = r.tree;
324	const ais = r.ais;	319	const ais = r.ais;
325	if (r.fixups.replace_nodes_with_string.get(node)) \|replacement\| {	320	if (r.fixups.replace_nodes_with_string.get(node)) \|replacement\| {
326	try ais.writer().writeAll(replacement);	321	try ais.writeAll(replacement);
327	try renderOnlySpace(r, space);	322	try renderOnlySpace(r, space);
328	return;	323	return;
329	} else if (r.fixups.replace_nodes_with_node.get(node)) \|replacement\| {	324	} else if (r.fixups.replace_nodes_with_node.get(node)) \|replacement\| {
...	@@ -891,11 +886,11 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {	...	@@ -891,11 +886,11 @@ fn renderExpression(r: *Render, node: Ast.Node.Index, space: Space) Error!void {
891		886
892	/// Same as `renderExpression`, but afterwards looks for any	887	/// Same as `renderExpression`, but afterwards looks for any
893	/// append_string_after_node fixups to apply	888	/// append_string_after_node fixups to apply
894	fn renderExpressionFixup(r: *Render, node: Ast.Node.Index, space: Space) Error!void {	889	fn renderExpressionFixup(r: *Render, node: Ast.Node.Index, space: Space) anyerror!void {
895	const ais = r.ais;	890	const ais = r.ais;
896	try renderExpression(r, node, space);	891	try renderExpression(r, node, space);
897	if (r.fixups.append_string_after_node.get(node)) \|bytes\| {	892	if (r.fixups.append_string_after_node.get(node)) \|bytes\| {
898	try ais.writer().writeAll(bytes);	893	try ais.writeAll(bytes);
899	}	894	}
900	}	895	}
901		896
...	@@ -903,7 +898,7 @@ fn renderArrayType(	...	@@ -903,7 +898,7 @@ fn renderArrayType(
903	r: *Render,	898	r: *Render,
904	array_type: Ast.full.ArrayType,	899	array_type: Ast.full.ArrayType,
905	space: Space,	900	space: Space,
906	) Error!void {	901	) anyerror!void {
907	const tree = r.tree;	902	const tree = r.tree;
908	const ais = r.ais;	903	const ais = r.ais;
909	const rbracket = tree.firstToken(array_type.ast.elem_type) - 1;	904	const rbracket = tree.firstToken(array_type.ast.elem_type) - 1;
...	@@ -921,7 +916,7 @@ fn renderArrayType(	...	@@ -921,7 +916,7 @@ fn renderArrayType(
921	return renderExpression(r, array_type.ast.elem_type, space);	916	return renderExpression(r, array_type.ast.elem_type, space);
922	}	917	}
923		918
924	fn renderPtrType(r: *Render, ptr_type: Ast.full.PtrType, space: Space) Error!void {	919	fn renderPtrType(r: *Render, ptr_type: Ast.full.PtrType, space: Space) anyerror!void {
925	const tree = r.tree;	920	const tree = r.tree;
926	const main_token = ptr_type.ast.main_token;	921	const main_token = ptr_type.ast.main_token;
927	switch (ptr_type.size) {	922	switch (ptr_type.size) {
...	@@ -1015,7 +1010,7 @@ fn renderSlice(	...	@@ -1015,7 +1010,7 @@ fn renderSlice(
1015	slice_node: Ast.Node.Index,	1010	slice_node: Ast.Node.Index,
1016	slice: Ast.full.Slice,	1011	slice: Ast.full.Slice,
1017	space: Space,	1012	space: Space,
1018	) Error!void {	1013	) anyerror!void {
1019	const tree = r.tree;	1014	const tree = r.tree;
1020	const after_start_space_bool = nodeCausesSliceOpSpace(tree.nodeTag(slice.ast.start)) or	1015	const after_start_space_bool = nodeCausesSliceOpSpace(tree.nodeTag(slice.ast.start)) or
1021	if (slice.ast.end.unwrap()) \|end\| nodeCausesSliceOpSpace(tree.nodeTag(end)) else false;	1016	if (slice.ast.end.unwrap()) \|end\| nodeCausesSliceOpSpace(tree.nodeTag(end)) else false;
...	@@ -1048,7 +1043,7 @@ fn renderAsmOutput(	...	@@ -1048,7 +1043,7 @@ fn renderAsmOutput(
1048	r: *Render,	1043	r: *Render,
1049	asm_output: Ast.Node.Index,	1044	asm_output: Ast.Node.Index,
1050	space: Space,	1045	space: Space,
1051	) Error!void {	1046	) anyerror!void {
1052	const tree = r.tree;	1047	const tree = r.tree;
1053	assert(tree.nodeTag(asm_output) == .asm_output);	1048	assert(tree.nodeTag(asm_output) == .asm_output);
1054	const symbolic_name = tree.nodeMainToken(asm_output);	1049	const symbolic_name = tree.nodeMainToken(asm_output);
...	@@ -1074,7 +1069,7 @@ fn renderAsmInput(	...	@@ -1074,7 +1069,7 @@ fn renderAsmInput(
1074	r: *Render,	1069	r: *Render,
1075	asm_input: Ast.Node.Index,	1070	asm_input: Ast.Node.Index,
1076	space: Space,	1071	space: Space,
1077	) Error!void {	1072	) anyerror!void {
1078	const tree = r.tree;	1073	const tree = r.tree;
1079	assert(tree.nodeTag(asm_input) == .asm_input);	1074	assert(tree.nodeTag(asm_input) == .asm_input);
1080	const symbolic_name = tree.nodeMainToken(asm_input);	1075	const symbolic_name = tree.nodeMainToken(asm_input);
...	@@ -1096,14 +1091,14 @@ fn renderVarDecl(	...	@@ -1096,14 +1091,14 @@ fn renderVarDecl(
1096	ignore_comptime_token: bool,	1091	ignore_comptime_token: bool,
1097	/// `comma_space` and `space` are used for destructure LHS decls.	1092	/// `comma_space` and `space` are used for destructure LHS decls.
1098	space: Space,	1093	space: Space,
1099	) Error!void {	1094	) anyerror!void {
1100	try renderVarDeclWithoutFixups(r, var_decl, ignore_comptime_token, space);	1095	try renderVarDeclWithoutFixups(r, var_decl, ignore_comptime_token, space);
1101	if (r.fixups.unused_var_decls.contains(var_decl.ast.mut_token + 1)) {	1096	if (r.fixups.unused_var_decls.contains(var_decl.ast.mut_token + 1)) {
1102	// Discard the variable like this: `_ = foo;`	1097	// Discard the variable like this: `_ = foo;`
1103	const w = r.ais.writer();	1098	const ais = r.ais;
1104	try w.writeAll("_ = ");	1099	try ais.writeAll("_ = ");
1105	try w.writeAll(tokenSliceForRender(r.tree, var_decl.ast.mut_token + 1));	1100	try ais.writeAll(tokenSliceForRender(r.tree, var_decl.ast.mut_token + 1));
1106	try w.writeAll(";\n");	1101	try ais.writeAll(";\n");
1107	}	1102	}
1108	}	1103	}
1109		1104
...	@@ -1114,7 +1109,7 @@ fn renderVarDeclWithoutFixups(	...	@@ -1114,7 +1109,7 @@ fn renderVarDeclWithoutFixups(
1114	ignore_comptime_token: bool,	1109	ignore_comptime_token: bool,
1115	/// `comma_space` and `space` are used for destructure LHS decls.	1110	/// `comma_space` and `space` are used for destructure LHS decls.
1116	space: Space,	1111	space: Space,
1117	) Error!void {	1112	) anyerror!void {
1118	const tree = r.tree;	1113	const tree = r.tree;
1119	const ais = r.ais;	1114	const ais = r.ais;
1120		1115
...	@@ -1226,7 +1221,7 @@ fn renderVarDeclWithoutFixups(	...	@@ -1226,7 +1221,7 @@ fn renderVarDeclWithoutFixups(
1226	ais.popIndent();	1221	ais.popIndent();
1227	}	1222	}
1228		1223
1229	fn renderIf(r: *Render, if_node: Ast.full.If, space: Space) Error!void {	1224	fn renderIf(r: *Render, if_node: Ast.full.If, space: Space) anyerror!void {
1230	return renderWhile(r, .{	1225	return renderWhile(r, .{
1231	.ast = .{	1226	.ast = .{
1232	.while_token = if_node.ast.if_token,	1227	.while_token = if_node.ast.if_token,
...	@@ -1245,7 +1240,7 @@ fn renderIf(r: *Render, if_node: Ast.full.If, space: Space) Error!void {	...	@@ -1245,7 +1240,7 @@ fn renderIf(r: *Render, if_node: Ast.full.If, space: Space) Error!void {
1245		1240
1246	/// Note that this function is additionally used to render if expressions, with	1241	/// Note that this function is additionally used to render if expressions, with
1247	/// respective values set to null.	1242	/// respective values set to null.
1248	fn renderWhile(r: *Render, while_node: Ast.full.While, space: Space) Error!void {	1243	fn renderWhile(r: *Render, while_node: Ast.full.While, space: Space) anyerror!void {
1249	const tree = r.tree;	1244	const tree = r.tree;
1250		1245
1251	if (while_node.label_token) \|label\| {	1246	if (while_node.label_token) \|label\| {
...	@@ -1315,7 +1310,7 @@ fn renderThenElse(	...	@@ -1315,7 +1310,7 @@ fn renderThenElse(
1315	maybe_error_token: ?Ast.TokenIndex,	1310	maybe_error_token: ?Ast.TokenIndex,
1316	opt_else_expr: Ast.Node.OptionalIndex,	1311	opt_else_expr: Ast.Node.OptionalIndex,
1317	space: Space,	1312	space: Space,
1318	) Error!void {	1313	) anyerror!void {
1319	const tree = r.tree;	1314	const tree = r.tree;
1320	const ais = r.ais;	1315	const ais = r.ais;
1321	const then_expr_is_block = nodeIsBlock(tree.nodeTag(then_expr));	1316	const then_expr_is_block = nodeIsBlock(tree.nodeTag(then_expr));
...	@@ -1370,7 +1365,7 @@ fn renderThenElse(	...	@@ -1370,7 +1365,7 @@ fn renderThenElse(
1370	}	1365	}
1371	}	1366	}
1372		1367
1373	fn renderFor(r: *Render, for_node: Ast.full.For, space: Space) Error!void {	1368	fn renderFor(r: *Render, for_node: Ast.full.For, space: Space) anyerror!void {
1374	const tree = r.tree;	1369	const tree = r.tree;
1375	const ais = r.ais;	1370	const ais = r.ais;
1376	const token_tags = tree.tokens.items(.tag);	1371	const token_tags = tree.tokens.items(.tag);
...	@@ -1445,7 +1440,7 @@ fn renderContainerField(	...	@@ -1445,7 +1440,7 @@ fn renderContainerField(
1445	container: Container,	1440	container: Container,
1446	field_param: Ast.full.ContainerField,	1441	field_param: Ast.full.ContainerField,
1447	space: Space,	1442	space: Space,
1448	) Error!void {	1443	) anyerror!void {
1449	const tree = r.tree;	1444	const tree = r.tree;
1450	const ais = r.ais;	1445	const ais = r.ais;
1451	var field = field_param;	1446	var field = field_param;
...	@@ -1554,7 +1549,7 @@ fn renderBuiltinCall(	...	@@ -1554,7 +1549,7 @@ fn renderBuiltinCall(
1554	builtin_token: Ast.TokenIndex,	1549	builtin_token: Ast.TokenIndex,
1555	params: []const Ast.Node.Index,	1550	params: []const Ast.Node.Index,
1556	space: Space,	1551	space: Space,
1557	) Error!void {	1552	) anyerror!void {
1558	const tree = r.tree;	1553	const tree = r.tree;
1559	const ais = r.ais;	1554	const ais = r.ais;
1560		1555
...	@@ -1581,7 +1576,7 @@ fn renderBuiltinCall(	...	@@ -1581,7 +1576,7 @@ fn renderBuiltinCall(
1581	defer r.gpa.free(new_string);	1576	defer r.gpa.free(new_string);
1582		1577
1583	try renderToken(r, builtin_token + 1, .none); // (	1578	try renderToken(r, builtin_token + 1, .none); // (
1584	try ais.writer().print("\"{}\"", .{std.zig.fmtEscapes(new_string)});	1579	try ais.print("\"{}\"", .{std.zig.fmtEscapes(new_string)});
1585	return renderToken(r, str_lit_token + 1, space); // )	1580	return renderToken(r, str_lit_token + 1, space); // )
1586	}	1581	}
1587	}	1582	}
...	@@ -1627,7 +1622,7 @@ fn renderBuiltinCall(	...	@@ -1627,7 +1622,7 @@ fn renderBuiltinCall(
1627	}	1622	}
1628	}	1623	}
1629		1624
1630	fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) Error!void {	1625	fn renderFnProto(r: *Render, fn_proto: Ast.full.FnProto, space: Space) anyerror!void {
1631	const tree = r.tree;	1626	const tree = r.tree;
1632	const ais = r.ais;	1627	const ais = r.ais;
1633		1628
...	@@ -1852,7 +1847,7 @@ fn renderSwitchCase(	...	@@ -1852,7 +1847,7 @@ fn renderSwitchCase(
1852	r: *Render,	1847	r: *Render,
1853	switch_case: Ast.full.SwitchCase,	1848	switch_case: Ast.full.SwitchCase,
1854	space: Space,	1849	space: Space,
1855	) Error!void {	1850	) anyerror!void {
1856	const ais = r.ais;	1851	const ais = r.ais;
1857	const tree = r.tree;	1852	const tree = r.tree;
1858	const trailing_comma = tree.tokenTag(switch_case.ast.arrow_token - 1) == .comma;	1853	const trailing_comma = tree.tokenTag(switch_case.ast.arrow_token - 1) == .comma;
...	@@ -1914,7 +1909,7 @@ fn renderBlock(	...	@@ -1914,7 +1909,7 @@ fn renderBlock(
1914	block_node: Ast.Node.Index,	1909	block_node: Ast.Node.Index,
1915	statements: []const Ast.Node.Index,	1910	statements: []const Ast.Node.Index,
1916	space: Space,	1911	space: Space,
1917	) Error!void {	1912	) anyerror!void {
1918	const tree = r.tree;	1913	const tree = r.tree;
1919	const ais = r.ais;	1914	const ais = r.ais;
1920	const lbrace = tree.nodeMainToken(block_node);	1915	const lbrace = tree.nodeMainToken(block_node);
...	@@ -1939,7 +1934,7 @@ fn finishRenderBlock(	...	@@ -1939,7 +1934,7 @@ fn finishRenderBlock(
1939	block_node: Ast.Node.Index,	1934	block_node: Ast.Node.Index,
1940	statements: []const Ast.Node.Index,	1935	statements: []const Ast.Node.Index,
1941	space: Space,	1936	space: Space,
1942	) Error!void {	1937	) anyerror!void {
1943	const tree = r.tree;	1938	const tree = r.tree;
1944	const ais = r.ais;	1939	const ais = r.ais;
1945	for (statements, 0..) \|stmt, i\| {	1940	for (statements, 0..) \|stmt, i\| {
...	@@ -1967,7 +1962,7 @@ fn renderStructInit(	...	@@ -1967,7 +1962,7 @@ fn renderStructInit(
1967	struct_node: Ast.Node.Index,	1962	struct_node: Ast.Node.Index,
1968	struct_init: Ast.full.StructInit,	1963	struct_init: Ast.full.StructInit,
1969	space: Space,	1964	space: Space,
1970	) Error!void {	1965	) anyerror!void {
1971	const tree = r.tree;	1966	const tree = r.tree;
1972	const ais = r.ais;	1967	const ais = r.ais;
1973		1968
...	@@ -2038,7 +2033,7 @@ fn renderArrayInit(	...	@@ -2038,7 +2033,7 @@ fn renderArrayInit(
2038	r: *Render,	2033	r: *Render,
2039	array_init: Ast.full.ArrayInit,	2034	array_init: Ast.full.ArrayInit,
2040	space: Space,	2035	space: Space,
2041	) Error!void {	2036	) anyerror!void {
2042	const tree = r.tree;	2037	const tree = r.tree;
2043	const ais = r.ais;	2038	const ais = r.ais;
2044	const gpa = r.gpa;	2039	const gpa = r.gpa;
...	@@ -2139,13 +2134,14 @@ fn renderArrayInit(	...	@@ -2139,13 +2134,14 @@ fn renderArrayInit(
2139		2134
2140	const section_exprs = row_exprs[0..section_end];	2135	const section_exprs = row_exprs[0..section_end];
2141		2136
2142	var sub_expr_buffer = std.ArrayList(u8).init(gpa);	2137	var sub_expr_buffer: std.io.AllocatingWriter = undefined;
		2138	const sub_expr_buffer_writer = sub_expr_buffer.init(gpa);
2143	defer sub_expr_buffer.deinit();	2139	defer sub_expr_buffer.deinit();
2144		2140
2145	const sub_expr_buffer_starts = try gpa.alloc(usize, section_exprs.len + 1);	2141	const sub_expr_buffer_starts = try gpa.alloc(usize, section_exprs.len + 1);
2146	defer gpa.free(sub_expr_buffer_starts);	2142	defer gpa.free(sub_expr_buffer_starts);
2147		2143
2148	var auto_indenting_stream = Ais.init(&sub_expr_buffer, indent_delta);	2144	var auto_indenting_stream: AutoIndentingStream = .init(sub_expr_buffer_writer, indent_delta);
2149	defer auto_indenting_stream.deinit();	2145	defer auto_indenting_stream.deinit();
2150	var sub_render: Render = .{	2146	var sub_render: Render = .{
2151	.gpa = r.gpa,	2147	.gpa = r.gpa,
...	@@ -2159,13 +2155,13 @@ fn renderArrayInit(	...	@@ -2159,13 +2155,13 @@ fn renderArrayInit(
2159	var single_line = true;	2155	var single_line = true;
2160	var contains_newline = false;	2156	var contains_newline = false;
2161	for (section_exprs, 0..) \|expr, i\| {	2157	for (section_exprs, 0..) \|expr, i\| {
2162	const start = sub_expr_buffer.items.len;	2158	const start = sub_expr_buffer.getWritten().len;
2163	sub_expr_buffer_starts[i] = start;	2159	sub_expr_buffer_starts[i] = start;
2164		2160
2165	if (i + 1 < section_exprs.len) {	2161	if (i + 1 < section_exprs.len) {
2166	try renderExpression(&sub_render, expr, .none);	2162	try renderExpression(&sub_render, expr, .none);
2167	const width = sub_expr_buffer.items.len - start;	2163	const width = sub_expr_buffer.getWritten().len - start;
2168	const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.items[start..], '\n') != null;	2164	const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.getWritten()[start..], '\n') != null;
2169	contains_newline = contains_newline or this_contains_newline;	2165	contains_newline = contains_newline or this_contains_newline;
2170	expr_widths[i] = width;	2166	expr_widths[i] = width;
2171	expr_newlines[i] = this_contains_newline;	2167	expr_newlines[i] = this_contains_newline;
...	@@ -2188,7 +2184,7 @@ fn renderArrayInit(	...	@@ -2188,7 +2184,7 @@ fn renderArrayInit(
2188	ais.popSpace();	2184	ais.popSpace();
2189		2185
2190	const width = sub_expr_buffer.items.len - start - 2;	2186	const width = sub_expr_buffer.items.len - start - 2;
2191	const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.items[start .. sub_expr_buffer.items.len - 1], '\n') != null;	2187	const this_contains_newline = mem.indexOfScalar(u8, sub_expr_buffer.getWritten()[start .. sub_expr_buffer.items.len - 1], '\n') != null;
2192	contains_newline = contains_newline or this_contains_newline;	2188	contains_newline = contains_newline or this_contains_newline;
2193	expr_widths[i] = width;	2189	expr_widths[i] = width;
2194	expr_newlines[i] = contains_newline;	2190	expr_newlines[i] = contains_newline;
...	@@ -2199,20 +2195,20 @@ fn renderArrayInit(	...	@@ -2199,20 +2195,20 @@ fn renderArrayInit(
2199	}	2195	}
2200	}	2196	}
2201	}	2197	}
2202	sub_expr_buffer_starts[section_exprs.len] = sub_expr_buffer.items.len;	2198	sub_expr_buffer_starts[section_exprs.len] = sub_expr_buffer.getWritten().len;
2203		2199
2204	// Render exprs in current section.	2200	// Render exprs in current section.
2205	column_counter = 0;	2201	column_counter = 0;
2206	for (section_exprs, 0..) \|expr, i\| {	2202	for (section_exprs, 0..) \|expr, i\| {
2207	const start = sub_expr_buffer_starts[i];	2203	const start = sub_expr_buffer_starts[i];
2208	const end = sub_expr_buffer_starts[i + 1];	2204	const end = sub_expr_buffer_starts[i + 1];
2209	const expr_text = sub_expr_buffer.items[start..end];	2205	const expr_text = sub_expr_buffer.getWritten()[start..end];
2210	if (!expr_newlines[i]) {	2206	if (!expr_newlines[i]) {
2211	try ais.writer().writeAll(expr_text);	2207	try ais.writeAll(expr_text);
2212	} else {	2208	} else {
2213	var by_line = std.mem.splitScalar(u8, expr_text, '\n');	2209	var by_line = std.mem.splitScalar(u8, expr_text, '\n');
2214	var last_line_was_empty = false;	2210	var last_line_was_empty = false;
2215	try ais.writer().writeAll(by_line.first());	2211	try ais.writeAll(by_line.first());
2216	while (by_line.next()) \|line\| {	2212	while (by_line.next()) \|line\| {
2217	if (std.mem.startsWith(u8, line, "//") and last_line_was_empty) {	2213	if (std.mem.startsWith(u8, line, "//") and last_line_was_empty) {
2218	try ais.insertNewline();	2214	try ais.insertNewline();
...	@@ -2220,7 +2216,7 @@ fn renderArrayInit(	...	@@ -2220,7 +2216,7 @@ fn renderArrayInit(
2220	try ais.maybeInsertNewline();	2216	try ais.maybeInsertNewline();
2221	}	2217	}
2222	last_line_was_empty = (line.len == 0);	2218	last_line_was_empty = (line.len == 0);
2223	try ais.writer().writeAll(line);	2219	try ais.writeAll(line);
2224	}	2220	}
2225	}	2221	}
2226		2222
...	@@ -2234,7 +2230,7 @@ fn renderArrayInit(	...	@@ -2234,7 +2230,7 @@ fn renderArrayInit(
2234	try renderToken(r, comma, .space); // ,	2230	try renderToken(r, comma, .space); // ,
2235	assert(column_widths[column_counter % row_size] >= expr_widths[i]);	2231	assert(column_widths[column_counter % row_size] >= expr_widths[i]);
2236	const padding = column_widths[column_counter % row_size] - expr_widths[i];	2232	const padding = column_widths[column_counter % row_size] - expr_widths[i];
2237	try ais.writer().writeByteNTimes(' ', padding);	2233	try ais.splatByteAll(' ', padding);
2238		2234
2239	column_counter += 1;	2235	column_counter += 1;
2240	continue;	2236	continue;
...	@@ -2265,7 +2261,7 @@ fn renderContainerDecl(	...	@@ -2265,7 +2261,7 @@ fn renderContainerDecl(
2265	container_decl_node: Ast.Node.Index,	2261	container_decl_node: Ast.Node.Index,
2266	container_decl: Ast.full.ContainerDecl,	2262	container_decl: Ast.full.ContainerDecl,
2267	space: Space,	2263	space: Space,
2268	) Error!void {	2264	) anyerror!void {
2269	const tree = r.tree;	2265	const tree = r.tree;
2270	const ais = r.ais;	2266	const ais = r.ais;
2271		2267
...	@@ -2384,7 +2380,7 @@ fn renderAsm(	...	@@ -2384,7 +2380,7 @@ fn renderAsm(
2384	r: *Render,	2380	r: *Render,
2385	asm_node: Ast.full.Asm,	2381	asm_node: Ast.full.Asm,
2386	space: Space,	2382	space: Space,
2387	) Error!void {	2383	) anyerror!void {
2388	const tree = r.tree;	2384	const tree = r.tree;
2389	const ais = r.ais;	2385	const ais = r.ais;
2390		2386
...	@@ -2550,7 +2546,7 @@ fn renderCall(	...	@@ -2550,7 +2546,7 @@ fn renderCall(
2550	r: *Render,	2546	r: *Render,
2551	call: Ast.full.Call,	2547	call: Ast.full.Call,
2552	space: Space,	2548	space: Space,
2553	) Error!void {	2549	) anyerror!void {
2554	if (call.async_token) \|async_token\| {	2550	if (call.async_token) \|async_token\| {
2555	try renderToken(r, async_token, .space);	2551	try renderToken(r, async_token, .space);
2556	}	2552	}
...	@@ -2563,7 +2559,7 @@ fn renderParamList(	...	@@ -2563,7 +2559,7 @@ fn renderParamList(
2563	lparen: Ast.TokenIndex,	2559	lparen: Ast.TokenIndex,
2564	params: []const Ast.Node.Index,	2560	params: []const Ast.Node.Index,
2565	space: Space,	2561	space: Space,
2566	) Error!void {	2562	) anyerror!void {
2567	const tree = r.tree;	2563	const tree = r.tree;
2568	const ais = r.ais;	2564	const ais = r.ais;
2569		2565
...	@@ -2616,7 +2612,7 @@ fn renderParamList(	...	@@ -2616,7 +2612,7 @@ fn renderParamList(
2616		2612
2617	/// Render an expression, and the comma that follows it, if it is present in the source.	2613	/// Render an expression, and the comma that follows it, if it is present in the source.
2618	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.	2614	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.
2619	fn renderExpressionComma(r: *Render, node: Ast.Node.Index, space: Space) Error!void {	2615	fn renderExpressionComma(r: *Render, node: Ast.Node.Index, space: Space) anyerror!void {
2620	const tree = r.tree;	2616	const tree = r.tree;
2621	const maybe_comma = tree.lastToken(node) + 1;	2617	const maybe_comma = tree.lastToken(node) + 1;
2622	if (tree.tokenTag(maybe_comma) == .comma and space != .comma) {	2618	if (tree.tokenTag(maybe_comma) == .comma and space != .comma) {
...	@@ -2629,7 +2625,7 @@ fn renderExpressionComma(r: *Render, node: Ast.Node.Index, space: Space) Error!v	...	@@ -2629,7 +2625,7 @@ fn renderExpressionComma(r: *Render, node: Ast.Node.Index, space: Space) Error!v
2629		2625
2630	/// Render a token, and the comma that follows it, if it is present in the source.	2626	/// Render a token, and the comma that follows it, if it is present in the source.
2631	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.	2627	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.
2632	fn renderTokenComma(r: *Render, token: Ast.TokenIndex, space: Space) Error!void {	2628	fn renderTokenComma(r: *Render, token: Ast.TokenIndex, space: Space) anyerror!void {
2633	const tree = r.tree;	2629	const tree = r.tree;
2634	const maybe_comma = token + 1;	2630	const maybe_comma = token + 1;
2635	if (tree.tokenTag(maybe_comma) == .comma and space != .comma) {	2631	if (tree.tokenTag(maybe_comma) == .comma and space != .comma) {
...	@@ -2642,7 +2638,7 @@ fn renderTokenComma(r: *Render, token: Ast.TokenIndex, space: Space) Error!void	...	@@ -2642,7 +2638,7 @@ fn renderTokenComma(r: *Render, token: Ast.TokenIndex, space: Space) Error!void
2642		2638
2643	/// Render an identifier, and the comma that follows it, if it is present in the source.	2639	/// Render an identifier, and the comma that follows it, if it is present in the source.
2644	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.	2640	/// If a comma is present, and `space` is `Space.comma`, render only a single comma.
2645	fn renderIdentifierComma(r: *Render, token: Ast.TokenIndex, space: Space, quote: QuoteBehavior) Error!void {	2641	fn renderIdentifierComma(r: *Render, token: Ast.TokenIndex, space: Space, quote: QuoteBehavior) anyerror!void {
2646	const tree = r.tree;	2642	const tree = r.tree;
2647	const maybe_comma = token + 1;	2643	const maybe_comma = token + 1;
2648	if (tree.tokenTag(maybe_comma) == .comma and space != .comma) {	2644	if (tree.tokenTag(maybe_comma) == .comma and space != .comma) {
...	@@ -2674,15 +2670,15 @@ const Space = enum {	...	@@ -2674,15 +2670,15 @@ const Space = enum {
2674	skip,	2670	skip,
2675	};	2671	};
2676		2672
2677	fn renderToken(r: *Render, token_index: Ast.TokenIndex, space: Space) Error!void {	2673	fn renderToken(r: *Render, token_index: Ast.TokenIndex, space: Space) anyerror!void {
2678	const tree = r.tree;	2674	const tree = r.tree;
2679	const ais = r.ais;	2675	const ais = r.ais;
2680	const lexeme = tokenSliceForRender(tree, token_index);	2676	const lexeme = tokenSliceForRender(tree, token_index);
2681	try ais.writer().writeAll(lexeme);	2677	try ais.writeAll(lexeme);
2682	try renderSpace(r, token_index, lexeme.len, space);	2678	try renderSpace(r, token_index, lexeme.len, space);
2683	}	2679	}
2684		2680
2685	fn renderTokenOverrideSpaceMode(r: *Render, token_index: Ast.TokenIndex, space: Space, override_space: Space) Error!void {	2681	fn renderTokenOverrideSpaceMode(r: *Render, token_index: Ast.TokenIndex, space: Space, override_space: Space) anyerror!void {
2686	const tree = r.tree;	2682	const tree = r.tree;
2687	const ais = r.ais;	2683	const ais = r.ais;
2688	const lexeme = tokenSliceForRender(tree, token_index);	2684	const lexeme = tokenSliceForRender(tree, token_index);
...	@@ -2692,7 +2688,7 @@ fn renderTokenOverrideSpaceMode(r: *Render, token_index: Ast.TokenIndex, space:	...	@@ -2692,7 +2688,7 @@ fn renderTokenOverrideSpaceMode(r: *Render, token_index: Ast.TokenIndex, space:
2692	try renderSpace(r, token_index, lexeme.len, space);	2688	try renderSpace(r, token_index, lexeme.len, space);
2693	}	2689	}
2694		2690
2695	fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space: Space) Error!void {	2691	fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space: Space) anyerror!void {
2696	const tree = r.tree;	2692	const tree = r.tree;
2697	const ais = r.ais;	2693	const ais = r.ais;
2698		2694
...	@@ -2701,7 +2697,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space	...	@@ -2701,7 +2697,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space
2701	if (space == .skip) return;	2697	if (space == .skip) return;
2702		2698
2703	if (space == .comma and next_token_tag != .comma) {	2699	if (space == .comma and next_token_tag != .comma) {
2704	try ais.writer().writeByte(',');	2700	try ais.underlying_writer.writeByte(',');
2705	}	2701	}
2706	if (space == .semicolon or space == .comma) ais.enableSpaceMode(space);	2702	if (space == .semicolon or space == .comma) ais.enableSpaceMode(space);
2707	defer ais.disableSpaceMode();	2703	defer ais.disableSpaceMode();
...	@@ -2712,7 +2708,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space	...	@@ -2712,7 +2708,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space
2712	);	2708	);
2713	switch (space) {	2709	switch (space) {
2714	.none => {},	2710	.none => {},
2715	.space => if (!comment) try ais.writer().writeByte(' '),	2711	.space => if (!comment) try ais.writeByte(' '),
2716	.newline => if (!comment) try ais.insertNewline(),	2712	.newline => if (!comment) try ais.insertNewline(),
2717		2713
2718	.comma => if (next_token_tag == .comma) {	2714	.comma => if (next_token_tag == .comma) {
...	@@ -2724,7 +2720,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space	...	@@ -2724,7 +2720,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space
2724	.comma_space => if (next_token_tag == .comma) {	2720	.comma_space => if (next_token_tag == .comma) {
2725	try renderToken(r, token_index + 1, .space);	2721	try renderToken(r, token_index + 1, .space);
2726	} else if (!comment) {	2722	} else if (!comment) {
2727	try ais.writer().writeByte(' ');	2723	try ais.writeByte(' ');
2728	},	2724	},
2729		2725
2730	.semicolon => if (next_token_tag == .semicolon) {	2726	.semicolon => if (next_token_tag == .semicolon) {
...	@@ -2737,15 +2733,15 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space	...	@@ -2737,15 +2733,15 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space
2737	}	2733	}
2738	}	2734	}
2739		2735
2740	fn renderOnlySpace(r: *Render, space: Space) Error!void {	2736	fn renderOnlySpace(r: *Render, space: Space) anyerror!void {
2741	const ais = r.ais;	2737	const ais = r.ais;
2742	switch (space) {	2738	switch (space) {
2743	.none => {},	2739	.none => {},
2744	.space => try ais.writer().writeByte(' '),	2740	.space => try ais.writeByte(' '),
2745	.newline => try ais.insertNewline(),	2741	.newline => try ais.insertNewline(),
2746	.comma => try ais.writer().writeAll(",\n"),	2742	.comma => try ais.writeAll(",\n"),
2747	.comma_space => try ais.writer().writeAll(", "),	2743	.comma_space => try ais.writeAll(", "),
2748	.semicolon => try ais.writer().writeAll(";\n"),	2744	.semicolon => try ais.writeAll(";\n"),
2749	.skip => unreachable,	2745	.skip => unreachable,
2750	}	2746	}
2751	}	2747	}
...	@@ -2756,13 +2752,13 @@ const QuoteBehavior = enum {	...	@@ -2756,13 +2752,13 @@ const QuoteBehavior = enum {
2756	eagerly_unquote_except_underscore,	2752	eagerly_unquote_except_underscore,
2757	};	2753	};
2758		2754
2759	fn renderIdentifier(r: *Render, token_index: Ast.TokenIndex, space: Space, quote: QuoteBehavior) Error!void {	2755	fn renderIdentifier(r: *Render, token_index: Ast.TokenIndex, space: Space, quote: QuoteBehavior) anyerror!void {
2760	const tree = r.tree;	2756	const tree = r.tree;
2761	assert(tree.tokenTag(token_index) == .identifier);	2757	assert(tree.tokenTag(token_index) == .identifier);
2762	const lexeme = tokenSliceForRender(tree, token_index);	2758	const lexeme = tokenSliceForRender(tree, token_index);
2763		2759
2764	if (r.fixups.rename_identifiers.get(lexeme)) \|mangled\| {	2760	if (r.fixups.rename_identifiers.get(lexeme)) \|mangled\| {
2765	try r.ais.writer().writeAll(mangled);	2761	try r.ais.writeAll(mangled);
2766	try renderSpace(r, token_index, lexeme.len, space);	2762	try renderSpace(r, token_index, lexeme.len, space);
2767	return;	2763	return;
2768	}	2764	}
...	@@ -2871,15 +2867,15 @@ fn renderQuotedIdentifier(r: *Render, token_index: Ast.TokenIndex, space: Space,	...	@@ -2871,15 +2867,15 @@ fn renderQuotedIdentifier(r: *Render, token_index: Ast.TokenIndex, space: Space,
2871	const lexeme = tokenSliceForRender(tree, token_index);	2867	const lexeme = tokenSliceForRender(tree, token_index);
2872	assert(lexeme.len >= 3 and lexeme[0] == '@');	2868	assert(lexeme.len >= 3 and lexeme[0] == '@');
2873		2869
2874	if (!unquote) try ais.writer().writeAll("@\"");	2870	if (!unquote) try ais.writeAll("@\"");
2875	const contents = lexeme[2 .. lexeme.len - 1];	2871	const contents = lexeme[2 .. lexeme.len - 1];
2876	try renderIdentifierContents(ais.writer(), contents);	2872	try renderIdentifierContents(ais, contents);
2877	if (!unquote) try ais.writer().writeByte('\"');	2873	if (!unquote) try ais.writeByte('\"');
2878		2874
2879	try renderSpace(r, token_index, lexeme.len, space);	2875	try renderSpace(r, token_index, lexeme.len, space);
2880	}	2876	}
2881		2877
2882	fn renderIdentifierContents(writer: anytype, bytes: []const u8) !void {	2878	fn renderIdentifierContents(ais: *AutoIndentingStream, bytes: []const u8) !void {
2883	var pos: usize = 0;	2879	var pos: usize = 0;
2884	while (pos < bytes.len) {	2880	while (pos < bytes.len) {
2885	const byte = bytes[pos];	2881	const byte = bytes[pos];
...	@@ -2892,23 +2888,23 @@ fn renderIdentifierContents(writer: anytype, bytes: []const u8) !void {	...	@@ -2892,23 +2888,23 @@ fn renderIdentifierContents(writer: anytype, bytes: []const u8) !void {
2892	.success => \|codepoint\| {	2888	.success => \|codepoint\| {
2893	if (codepoint <= 0x7f) {	2889	if (codepoint <= 0x7f) {
2894	const buf = [1]u8{@as(u8, @intCast(codepoint))};	2890	const buf = [1]u8{@as(u8, @intCast(codepoint))};
2895	try std.fmt.format(writer, "{}", .{std.zig.fmtEscapes(&buf)});	2891	try ais.print("{}", .{std.zig.fmtEscapes(&buf)});
2896	} else {	2892	} else {
2897	try writer.writeAll(escape_sequence);	2893	try ais.writeAll(escape_sequence);
2898	}	2894	}
2899	},	2895	},
2900	.failure => {	2896	.failure => {
2901	try writer.writeAll(escape_sequence);	2897	try ais.writeAll(escape_sequence);
2902	},	2898	},
2903	}	2899	}
2904	},	2900	},
2905	0x00...('\\' - 1), ('\\' + 1)...0x7f => {	2901	0x00...('\\' - 1), ('\\' + 1)...0x7f => {
2906	const buf = [1]u8{byte};	2902	const buf = [1]u8{byte};
2907	try std.fmt.format(writer, "{}", .{std.zig.fmtEscapes(&buf)});	2903	try ais.print("{}", .{std.zig.fmtEscapes(&buf)});
2908	pos += 1;	2904	pos += 1;
2909	},	2905	},
2910	0x80...0xff => {	2906	0x80...0xff => {
2911	try writer.writeByte(byte);	2907	try ais.writeByte(byte);
2912	pos += 1;	2908	pos += 1;
2913	},	2909	},
2914	}	2910	}
...	@@ -2942,7 +2938,7 @@ fn hasMultilineString(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.Tok	...	@@ -2942,7 +2938,7 @@ fn hasMultilineString(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.Tok
2942		2938
2943	/// Assumes that start is the first byte past the previous token and	2939	/// Assumes that start is the first byte past the previous token and
2944	/// that end is the last byte before the next token.	2940	/// that end is the last byte before the next token.
2945	fn renderComments(r: *Render, start: usize, end: usize) Error!bool {	2941	fn renderComments(r: *Render, start: usize, end: usize) anyerror!bool {
2946	const tree = r.tree;	2942	const tree = r.tree;
2947	const ais = r.ais;	2943	const ais = r.ais;
2948		2944
...	@@ -2970,7 +2966,7 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {	...	@@ -2970,7 +2966,7 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {
2970	} else if (index == start) {	2966	} else if (index == start) {
2971	// Otherwise if the first comment is on the same line as	2967	// Otherwise if the first comment is on the same line as
2972	// the token before it, prefix it with a single space.	2968	// the token before it, prefix it with a single space.
2973	try ais.writer().writeByte(' ');	2969	try ais.writeByte(' ');
2974	}	2970	}
2975	}	2971	}
2976		2972
...	@@ -2987,11 +2983,11 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {	...	@@ -2987,11 +2983,11 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {
2987	ais.disabled_offset = null;	2983	ais.disabled_offset = null;
2988	} else if (ais.disabled_offset == null and mem.eql(u8, comment_content, "zig fmt: off")) {	2984	} else if (ais.disabled_offset == null and mem.eql(u8, comment_content, "zig fmt: off")) {
2989	// Write with the canonical single space.	2985	// Write with the canonical single space.
2990	try ais.writer().writeAll("// zig fmt: off\n");	2986	try ais.writeAll("// zig fmt: off\n");
2991	ais.disabled_offset = index;	2987	ais.disabled_offset = index;
2992	} else {	2988	} else {
2993	// Write the comment minus trailing whitespace.	2989	// Write the comment minus trailing whitespace.
2994	try ais.writer().print("{s}\n", .{trimmed_comment});	2990	try ais.print("{s}\n", .{trimmed_comment});
2995	}	2991	}
2996	}	2992	}
2997		2993
...	@@ -3005,12 +3001,12 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {	...	@@ -3005,12 +3001,12 @@ fn renderComments(r: *Render, start: usize, end: usize) Error!bool {
3005	return index != start;	3001	return index != start;
3006	}	3002	}
3007		3003
3008	fn renderExtraNewline(r: *Render, node: Ast.Node.Index) Error!void {	3004	fn renderExtraNewline(r: *Render, node: Ast.Node.Index) anyerror!void {
3009	return renderExtraNewlineToken(r, r.tree.firstToken(node));	3005	return renderExtraNewlineToken(r, r.tree.firstToken(node));
3010	}	3006	}
3011		3007
3012	/// Check if there is an empty line immediately before the given token. If so, render it.	3008	/// Check if there is an empty line immediately before the given token. If so, render it.
3013	fn renderExtraNewlineToken(r: *Render, token_index: Ast.TokenIndex) Error!void {	3009	fn renderExtraNewlineToken(r: *Render, token_index: Ast.TokenIndex) anyerror!void {
3014	const tree = r.tree;	3010	const tree = r.tree;
3015	const ais = r.ais;	3011	const ais = r.ais;
3016	const token_start = tree.tokenStart(token_index);	3012	const token_start = tree.tokenStart(token_index);
...	@@ -3038,7 +3034,7 @@ fn renderExtraNewlineToken(r: *Render, token_index: Ast.TokenIndex) Error!void {	...	@@ -3038,7 +3034,7 @@ fn renderExtraNewlineToken(r: *Render, token_index: Ast.TokenIndex) Error!void {
3038		3034
3039	/// end_token is the token one past the last doc comment token. This function	3035	/// end_token is the token one past the last doc comment token. This function
3040	/// searches backwards from there.	3036	/// searches backwards from there.
3041	fn renderDocComments(r: *Render, end_token: Ast.TokenIndex) Error!void {	3037	fn renderDocComments(r: *Render, end_token: Ast.TokenIndex) anyerror!void {
3042	const tree = r.tree;	3038	const tree = r.tree;
3043	// Search backwards for the first doc comment.	3039	// Search backwards for the first doc comment.
3044	if (end_token == 0) return;	3040	if (end_token == 0) return;
...	@@ -3069,7 +3065,7 @@ fn renderDocComments(r: *Render, end_token: Ast.TokenIndex) Error!void {	...	@@ -3069,7 +3065,7 @@ fn renderDocComments(r: *Render, end_token: Ast.TokenIndex) Error!void {
3069	}	3065	}
3070		3066
3071	/// start_token is first container doc comment token.	3067	/// start_token is first container doc comment token.
3072	fn renderContainerDocComments(r: *Render, start_token: Ast.TokenIndex) Error!void {	3068	fn renderContainerDocComments(r: *Render, start_token: Ast.TokenIndex) anyerror!void {
3073	const tree = r.tree;	3069	const tree = r.tree;
3074	var tok = start_token;	3070	var tok = start_token;
3075	while (tree.tokenTag(tok) == .container_doc_comment) : (tok += 1) {	3071	while (tree.tokenTag(tok) == .container_doc_comment) : (tok += 1) {
...	@@ -3083,7 +3079,7 @@ fn renderContainerDocComments(r: *Render, start_token: Ast.TokenIndex) Error!voi	...	@@ -3083,7 +3079,7 @@ fn renderContainerDocComments(r: *Render, start_token: Ast.TokenIndex) Error!voi
3083	}	3079	}
3084	}	3080	}
3085		3081
3086	fn discardAllParams(r: *Render, fn_proto_node: Ast.Node.Index) Error!void {	3082	fn discardAllParams(r: *Render, fn_proto_node: Ast.Node.Index) anyerror!void {
3087	const tree = &r.tree;	3083	const tree = &r.tree;
3088	const ais = r.ais;	3084	const ais = r.ais;
3089	var buf: [1]Ast.Node.Index = undefined;	3085	var buf: [1]Ast.Node.Index = undefined;
...	@@ -3092,10 +3088,9 @@ fn discardAllParams(r: *Render, fn_proto_node: Ast.Node.Index) Error!void {	...	@@ -3092,10 +3088,9 @@ fn discardAllParams(r: *Render, fn_proto_node: Ast.Node.Index) Error!void {
3092	while (it.next()) \|param\| {	3088	while (it.next()) \|param\| {
3093	const name_ident = param.name_token.?;	3089	const name_ident = param.name_token.?;
3094	assert(tree.tokenTag(name_ident) == .identifier);	3090	assert(tree.tokenTag(name_ident) == .identifier);
3095	const w = ais.writer();	3091	try ais.writeAll("_ = ");
3096	try w.writeAll("_ = ");	3092	try ais.writeAll(tokenSliceForRender(r.tree, name_ident));
3097	try w.writeAll(tokenSliceForRender(r.tree, name_ident));	3093	try ais.writeAll(";\n");
3098	try w.writeAll(";\n");
3099	}	3094	}
3100	}	3095	}
3101		3096
...	@@ -3132,11 +3127,11 @@ fn anythingBetween(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenI	...	@@ -3132,11 +3127,11 @@ fn anythingBetween(tree: Ast, start_token: Ast.TokenIndex, end_token: Ast.TokenI
3132	return false;	3127	return false;
3133	}	3128	}
3134		3129
3135	fn writeFixingWhitespace(writer: std.ArrayList(u8).Writer, slice: []const u8) Error!void {	3130	fn writeFixingWhitespace(bw: *std.io.BufferedWriter, slice: []const u8) anyerror!void {
3136	for (slice) \|byte\| switch (byte) {	3131	for (slice) \|byte\| switch (byte) {
3137	'\t' => try writer.writeAll(" " ** indent_delta),	3132	'\t' => try bw.splatByteAll(' ', indent_delta),
3138	'\r' => {},	3133	'\r' => {},
3139	else => try writer.writeByte(byte),	3134	else => try bw.writeByte(byte),
3140	};	3135	};
3141	}	3136	}
3142		3137
...	@@ -3261,224 +3256,235 @@ fn rowSize(tree: Ast, exprs: []const Ast.Node.Index, rtoken: Ast.TokenIndex) usi	...	@@ -3261,224 +3256,235 @@ fn rowSize(tree: Ast, exprs: []const Ast.Node.Index, rtoken: Ast.TokenIndex) usi
3261	/// of the appropriate indentation level for them with pushSpace/popSpace.	3256	/// of the appropriate indentation level for them with pushSpace/popSpace.
3262	/// This should be done whenever a scope that ends in a .semicolon or a	3257	/// This should be done whenever a scope that ends in a .semicolon or a
3263	/// .comma is introduced.	3258	/// .comma is introduced.
3264	fn AutoIndentingStream(comptime UnderlyingWriter: type) type {	3259	const AutoIndentingStream = struct {
3265	return struct {	3260	underlying_writer: *std.io.BufferedWriter,
3266	const Self = @This();	3261
3267	pub const WriteError = UnderlyingWriter.Error;	3262	indent_count: usize = 0,
3268	pub const Writer = std.io.Writer(*Self, WriteError, write);	3263	indent_delta: usize,
3269		3264	indent_stack: std.ArrayList(StackElem),
3270	pub const IndentType = enum {	3265	space_stack: std.ArrayList(SpaceElem),
3271	normal,	3266	space_mode: ?usize = null,
3272	after_equals,	3267	disable_indent_committing: usize = 0,
3273	binop,	3268	current_line_empty: bool = true,
3274	field_access,	3269	/// the most recently applied indent
3275	};	3270	applied_indent: usize = 0,
3276	const StackElem = struct {	3271
3277	indent_type: IndentType,	3272	pub const IndentType = enum {
3278	realized: bool,	3273	normal,
3279	};	3274	after_equals,
3280	const SpaceElem = struct {	3275	binop,
3281	space: Space,	3276	field_access,
3282	indent_count: usize,	3277	};
		3278	const StackElem = struct {
		3279	indent_type: IndentType,
		3280	realized: bool,
		3281	};
		3282	const SpaceElem = struct {
		3283	space: Space,
		3284	indent_count: usize,
		3285	};
		3286
		3287	pub fn init(buffer: *std.ArrayList(u8), indent_delta_: usize) AutoIndentingStream {
		3288	return .{
		3289	.underlying_writer = buffer.writer(),
		3290	.indent_delta = indent_delta_,
		3291	.indent_stack = std.ArrayList(StackElem).init(buffer.allocator),
		3292	.space_stack = std.ArrayList(SpaceElem).init(buffer.allocator),
3283	};	3293	};
		3294	}
3284		3295
3285	underlying_writer: UnderlyingWriter,	3296	pub fn deinit(self: *AutoIndentingStream) void {
3286		3297	self.indent_stack.deinit();
3287	/// Offset into the source at which formatting has been disabled with	3298	self.space_stack.deinit();
3288	/// a `zig fmt: off` comment.	3299	}
3289	///
3290	/// If non-null, the AutoIndentingStream will not write any bytes
3291	/// to the underlying writer. It will however continue to track the
3292	/// indentation level.
3293	disabled_offset: ?usize = null,
3294
3295	indent_count: usize = 0,
3296	indent_delta: usize,
3297	indent_stack: std.ArrayList(StackElem),
3298	space_stack: std.ArrayList(SpaceElem),
3299	space_mode: ?usize = null,
3300	disable_indent_committing: usize = 0,
3301	current_line_empty: bool = true,
3302	/// the most recently applied indent
3303	applied_indent: usize = 0,
3304
3305	pub fn init(buffer: *std.ArrayList(u8), indent_delta_: usize) Self {
3306	return .{
3307	.underlying_writer = buffer.writer(),
3308	.indent_delta = indent_delta_,
3309	.indent_stack = std.ArrayList(StackElem).init(buffer.allocator),
3310	.space_stack = std.ArrayList(SpaceElem).init(buffer.allocator),
3311	};
3312	}
3313		3300
3314	pub fn deinit(self: *Self) void {	3301	pub fn writeAll(ais: *AutoIndentingStream, bytes: []const u8) anyerror!void {
3315	self.indent_stack.deinit();	3302	if (bytes.len == 0) return;
3316	self.space_stack.deinit();	3303	try ais.applyIndent();
3317	}	3304	if (ais.disabled_offset == null) try ais.underlying_writer.writeAll(bytes);
		3305	if (bytes[bytes.len - 1] == '\n') ais.resetLine();
		3306	}
3318		3307
3319	pub fn writer(self: *Self) Writer {	3308	pub fn print(ais: *AutoIndentingStream, comptime format: []const u8, args: anytype) anyerror!void {
3320	return .{ .context = self };	3309	comptime assert(format[format.len - 1] != '}');
3321	}	3310	try ais.applyIndent();
		3311	if (ais.disabled_offset == null) try ais.underlying_writer.print(format, args);
		3312	if (format[format.len - 1] == '\n') ais.resetLine();
		3313	}
3322		3314
3323	pub fn write(self: *Self, bytes: []const u8) WriteError!usize {	3315	pub fn writeByte(ais: *AutoIndentingStream, byte: u8) anyerror!void {
3324	if (bytes.len == 0)	3316	try ais.applyIndent();
3325	return @as(usize, 0);	3317	if (ais.disabled_offset == null) try ais.underlying_writer.writeByte(byte);
		3318	assert(byte != '\n');
		3319	}
3326		3320
3327	try self.applyIndent();	3321	pub fn splatByteAll(ais: *AutoIndentingStream, byte: u8, n: usize) anyerror!void {
3328	return self.writeNoIndent(bytes);	3322	assert(byte != '\n');
3329	}	3323	try ais.applyIndent();
		3324	if (ais.disabled_offset == null) try ais.underlying_writer.splatByteAll(byte, n);
		3325	}
3330		3326
3331	// Change the indent delta without changing the final indentation level	3327	// Change the indent delta without changing the final indentation level
3332	pub fn setIndentDelta(self: *Self, new_indent_delta: usize) void {	3328	pub fn setIndentDelta(ais: *AutoIndentingStream, new_indent_delta: usize) void {
3333	if (self.indent_delta == new_indent_delta) {	3329	if (ais.indent_delta == new_indent_delta) {
3334	return;	3330	return;
3335	} else if (self.indent_delta > new_indent_delta) {	3331	} else if (ais.indent_delta > new_indent_delta) {
3336	assert(self.indent_delta % new_indent_delta == 0);	3332	assert(ais.indent_delta % new_indent_delta == 0);
3337	self.indent_count = self.indent_count * (self.indent_delta / new_indent_delta);	3333	ais.indent_count = ais.indent_count * (ais.indent_delta / new_indent_delta);
3338	} else {	3334	} else {
3339	// assert that the current indentation (in spaces) in a multiple of the new delta	3335	// assert that the current indentation (in spaces) in a multiple of the new delta
3340	assert((self.indent_count * self.indent_delta) % new_indent_delta == 0);	3336	assert((ais.indent_count * ais.indent_delta) % new_indent_delta == 0);
3341	self.indent_count = self.indent_count / (new_indent_delta / self.indent_delta);	3337	ais.indent_count = ais.indent_count / (new_indent_delta / ais.indent_delta);
3342	}
3343	self.indent_delta = new_indent_delta;
3344	}	3338	}
		3339	ais.indent_delta = new_indent_delta;
		3340	}
3345		3341
3346	fn writeNoIndent(self: *Self, bytes: []const u8) WriteError!usize {	3342	pub fn insertNewline(ais: *AutoIndentingStream) anyerror!void {
3347	if (bytes.len == 0)	3343	if (ais.disabled_offset == null) try ais.underlying_writer.writeByte('\n');
3348	return @as(usize, 0);	3344	ais.resetLine();
		3345	}
3349		3346
3350	if (self.disabled_offset == null) try self.underlying_writer.writeAll(bytes);	3347	/// Insert a newline unless the current line is blank
3351	if (bytes[bytes.len - 1] == '\n')	3348	pub fn maybeInsertNewline(ais: *AutoIndentingStream) anyerror!void {
3352	self.resetLine();	3349	if (!ais.current_line_empty)
3353	return bytes.len;	3350	try ais.insertNewline();
3354	}	3351	}
3355		3352
3356	pub fn insertNewline(self: *Self) WriteError!void {	3353	/// Push an indent that is automatically popped after being applied
3357	_ = try self.writeNoIndent("\n");	3354	pub fn pushIndentOneShot(ais: *AutoIndentingStream) void {
3358	}	3355	ais.indent_one_shot_count += 1;
		3356	ais.pushIndent();
		3357	}
3359		3358
3360	fn resetLine(self: *Self) void {	3359	/// Turns all one-shot indents into regular indents
3361	self.current_line_empty = true;	3360	/// Returns number of indents that must now be manually popped
3362		3361	pub fn lockOneShotIndent(ais: *AutoIndentingStream) usize {
3363	if (self.disable_indent_committing > 0) return;	3362	const locked_count = ais.indent_one_shot_count;
3364		3363	ais.indent_one_shot_count = 0;
3365	if (self.indent_stack.items.len > 0) {	3364	return locked_count;
3366	// By default, we realize the most recent indentation scope.	3365	}
3367	var to_realize = self.indent_stack.items.len - 1;
3368
3369	if (self.indent_stack.items.len >= 2 and
3370	self.indent_stack.items[to_realize - 1].indent_type == .after_equals and
3371	self.indent_stack.items[to_realize - 1].realized and
3372	self.indent_stack.items[to_realize].indent_type == .binop)
3373	{
3374	// If we are in a .binop scope and our direct parent is .after_equals, don't indent.
3375	// This ensures correct indentation in the below example:
3376	//
3377	// const foo =
3378	// (x >= 'a' and x <= 'z') or //<-- we are here
3379	// (x >= 'A' and x <= 'Z');
3380	//
3381	return;
3382	}
3383		3366
3384	if (self.indent_stack.items[to_realize].indent_type == .field_access) {	3367	/// Push an indent that should not take effect until the next line
3385	// Only realize the top-most field_access in a chain.	3368	pub fn pushIndentNextLine(ais: *AutoIndentingStream) void {
3386	while (to_realize > 0 and self.indent_stack.items[to_realize - 1].indent_type == .field_access)	3369	ais.indent_next_line += 1;
3387	to_realize -= 1;	3370	ais.pushIndent();
3388	}	3371	}
		3372
		3373	/// Checks to see if the most recent indentation exceeds the currently pushed indents
		3374	pub fn isLineOverIndented(ais: *AutoIndentingStream) bool {
		3375	if (ais.current_line_empty) return false;
		3376	return ais.applied_indent > ais.currentIndent();
		3377	}
		3378
		3379	fn resetLine(ais: *AutoIndentingStream) void {
		3380	ais.current_line_empty = true;
		3381
		3382	if (ais.disable_indent_committing > 0) return;
3389		3383
3390	if (self.indent_stack.items[to_realize].realized) return;	3384	if (ais.indent_stack.items.len > 0) {
3391	self.indent_stack.items[to_realize].realized = true;	3385	// By default, we realize the most recent indentation scope.
3392	self.indent_count += 1;	3386	var to_realize = ais.indent_stack.items.len - 1;
		3387
		3388	if (ais.indent_stack.items.len >= 2 and
		3389	ais.indent_stack.items[to_realize - 1].indent_type == .after_equals and
		3390	ais.indent_stack.items[to_realize - 1].realized and
		3391	ais.indent_stack.items[to_realize].indent_type == .binop)
		3392	{
		3393	// If we are in a .binop scope and our direct parent is .after_equals, don't indent.
		3394	// This ensures correct indentation in the below example:
		3395	//
		3396	// const foo =
		3397	// (x >= 'a' and x <= 'z') or //<-- we are here
		3398	// (x >= 'A' and x <= 'Z');
		3399	//
		3400	return;
3393	}	3401	}
3394	}
3395		3402
3396	/// Disables indentation level changes during the next newlines until re-enabled.	3403	if (ais.indent_stack.items[to_realize].indent_type == .field_access) {
3397	pub fn disableIndentCommitting(self: *Self) void {	3404	// Only realize the top-most field_access in a chain.
3398	self.disable_indent_committing += 1;	3405	while (to_realize > 0 and ais.indent_stack.items[to_realize - 1].indent_type == .field_access)
3399	}	3406	to_realize -= 1;
		3407	}
3400		3408
3401	pub fn enableIndentCommitting(self: *Self) void {	3409	if (ais.indent_stack.items[to_realize].realized) return;
3402	assert(self.disable_indent_committing > 0);	3410	ais.indent_stack.items[to_realize].realized = true;
3403	self.disable_indent_committing -= 1;	3411	ais.indent_count += 1;
3404	}	3412	}
		3413	}
3405		3414
3406	pub fn pushSpace(self: *Self, space: Space) !void {	3415	/// Disables indentation level changes during the next newlines until re-enabled.
3407	try self.space_stack.append(.{ .space = space, .indent_count = self.indent_count });	3416	pub fn disableIndentCommitting(ais: *AutoIndentingStream) void {
3408	}	3417	ais.disable_indent_committing += 1;
		3418	}
3409		3419
3410	pub fn popSpace(self: *Self) void {	3420	pub fn enableIndentCommitting(ais: *AutoIndentingStream) void {
3411	_ = self.space_stack.pop();	3421	assert(ais.disable_indent_committing > 0);
3412	}	3422	ais.disable_indent_committing -= 1;
		3423	}
3413		3424
3414	/// Sets current indentation level to be the same as that of the last pushSpace.	3425	pub fn pushSpace(ais: *AutoIndentingStream, space: Space) !void {
3415	pub fn enableSpaceMode(self: *Self, space: Space) void {	3426	try ais.space_stack.append(.{ .space = space, .indent_count = ais.indent_count });
3416	if (self.space_stack.items.len == 0) return;	3427	}
3417	const curr = self.space_stack.getLast();
3418	if (curr.space != space) return;
3419	self.space_mode = curr.indent_count;
3420	}
3421		3428
3422	pub fn disableSpaceMode(self: *Self) void {	3429	pub fn popSpace(ais: *AutoIndentingStream) void {
3423	self.space_mode = null;	3430	_ = ais.space_stack.pop();
3424	}	3431	}
3425		3432
3426	pub fn lastSpaceModeIndent(self: *Self) usize {	3433	/// Sets current indentation level to be the same as that of the last pushSpace.
3427	if (self.space_stack.items.len == 0) return 0;	3434	pub fn enableSpaceMode(ais: *AutoIndentingStream, space: Space) void {
3428	return self.space_stack.getLast().indent_count * self.indent_delta;	3435	if (ais.space_stack.items.len == 0) return;
3429	}	3436	const curr = ais.space_stack.getLast();
		3437	if (curr.space != space) return;
		3438	ais.space_mode = curr.indent_count;
		3439	}
3430		3440
3431	/// Insert a newline unless the current line is blank	3441	pub fn disableSpaceMode(ais: *AutoIndentingStream) void {
3432	pub fn maybeInsertNewline(self: *Self) WriteError!void {	3442	ais.space_mode = null;
3433	if (!self.current_line_empty)	3443	}
3434	try self.insertNewline();
3435	}
3436		3444
3437	/// Push default indentation	3445	pub fn lastSpaceModeIndent(ais: *AutoIndentingStream) usize {
3438	/// Doesn't actually write any indentation.	3446	if (ais.space_stack.items.len == 0) return 0;
3439	/// Just primes the stream to be able to write the correct indentation if it needs to.	3447	return ais.space_stack.getLast().indent_count * ais.indent_delta;
3440	pub fn pushIndent(self: *Self, indent_type: IndentType) !void {	3448	}
3441	try self.indent_stack.append(.{ .indent_type = indent_type, .realized = false });
3442	}
3443		3449
3444	/// Forces an indentation level to be realized.	3450	/// Push default indentation
3445	pub fn forcePushIndent(self: *Self, indent_type: IndentType) !void {	3451	/// Doesn't actually write any indentation.
3446	try self.indent_stack.append(.{ .indent_type = indent_type, .realized = true });	3452	/// Just primes the stream to be able to write the correct indentation if it needs to.
3447	self.indent_count += 1;	3453	pub fn pushIndent(ais: *AutoIndentingStream, indent_type: IndentType) !void {
3448	}	3454	try ais.indent_stack.append(.{ .indent_type = indent_type, .realized = false });
		3455	}
3449		3456
3450	pub fn popIndent(self: *Self) void {	3457	/// Forces an indentation level to be realized.
3451	if (self.indent_stack.pop().?.realized) {	3458	pub fn forcePushIndent(ais: *AutoIndentingStream, indent_type: IndentType) !void {
3452	assert(self.indent_count > 0);	3459	try ais.indent_stack.append(.{ .indent_type = indent_type, .realized = true });
3453	self.indent_count -= 1;	3460	ais.indent_count += 1;
3454	}	3461	}
3455	}
3456		3462
3457	pub fn indentStackEmpty(self: *Self) bool {	3463	pub fn popIndent(ais: *AutoIndentingStream) void {
3458	return self.indent_stack.items.len == 0;	3464	if (ais.indent_stack.pop().?.realized) {
		3465	assert(ais.indent_count > 0);
		3466	ais.indent_count -= 1;
3459	}	3467	}
		3468	}
3460		3469
3461	/// Writes ' ' bytes if the current line is empty	3470	pub fn indentStackEmpty(ais: *AutoIndentingStream) bool {
3462	fn applyIndent(self: *Self) WriteError!void {	3471	return ais.indent_stack.items.len == 0;
3463	const current_indent = self.currentIndent();	3472	}
3464	if (self.current_line_empty and current_indent > 0) {
3465	if (self.disabled_offset == null) {
3466	try self.underlying_writer.writeByteNTimes(' ', current_indent);
3467	}
3468	self.applied_indent = current_indent;
3469	}
3470	self.current_line_empty = false;
3471	}
3472		3473
3473	/// Checks to see if the most recent indentation exceeds the currently pushed indents	3474	/// Writes ' ' bytes if the current line is empty
3474	pub fn isLineOverIndented(self: *Self) bool {	3475	fn applyIndent(ais: *AutoIndentingStream) anyerror!void {
3475	if (self.current_line_empty) return false;	3476	const current_indent = ais.currentIndent();
3476	return self.applied_indent > self.currentIndent();	3477	if (ais.current_line_empty and current_indent > 0) {
		3478	if (ais.disabled_offset == null) {
		3479	try ais.underlying_writer.writeByteNTimes(' ', current_indent);
		3480	}
		3481	ais.applied_indent = current_indent;
3477	}	3482	}
		3483	ais.current_line_empty = false;
		3484	}
3478		3485
3479	fn currentIndent(self: *Self) usize {	3486	fn currentIndent(ais: *AutoIndentingStream) usize {
3480	const indent_count = self.space_mode orelse self.indent_count;	3487	const indent_count = ais.space_mode orelse ais.indent_count;
3481	return indent_count * self.indent_delta;	3488	return indent_count * ais.indent_delta;
3482	}	3489	}
3483	};	3490	};
3484	}

lib/std/zig/string_literal.zig+11-9

...	@@ -322,9 +322,9 @@ test parseCharLiteral {	...	@@ -322,9 +322,9 @@ test parseCharLiteral {
322	);	322	);
323	}	323	}
324		324
325	/// Parses `bytes` as a Zig string literal and writes the result to the std.io.Writer type.	325	/// Parses `bytes` as a Zig string literal and writes the result to the `std.io.Writer` type.
326	/// Asserts `bytes` has '"' at beginning and end.	326	/// Asserts `bytes` has '"' at beginning and end.
327	pub fn parseWrite(writer: anytype, bytes: []const u8) error{OutOfMemory}!Result {	327	pub fn parseWrite(writer: *std.io.BufferedWriter, bytes: []const u8) anyerror!Result {
328	assert(bytes.len >= 2 and bytes[0] == '"' and bytes[bytes.len - 1] == '"');	328	assert(bytes.len >= 2 and bytes[0] == '"' and bytes[bytes.len - 1] == '"');
329		329
330	var index: usize = 1;	330	var index: usize = 1;
...	@@ -340,18 +340,18 @@ pub fn parseWrite(writer: anytype, bytes: []const u8) error{OutOfMemory}!Result	...	@@ -340,18 +340,18 @@ pub fn parseWrite(writer: anytype, bytes: []const u8) error{OutOfMemory}!Result
340	if (bytes[escape_char_index] == 'u') {	340	if (bytes[escape_char_index] == 'u') {
341	var buf: [4]u8 = undefined;	341	var buf: [4]u8 = undefined;
342	const len = utf8Encode(codepoint, &buf) catch {	342	const len = utf8Encode(codepoint, &buf) catch {
343	return Result{ .failure = .{ .invalid_unicode_codepoint = escape_char_index + 1 } };	343	return .{ .failure = .{ .invalid_unicode_codepoint = escape_char_index + 1 } };
344	};	344	};
345	try writer.writeAll(buf[0..len]);	345	try writer.writeAll(buf[0..len]);
346	} else {	346	} else {
347	try writer.writeByte(@as(u8, @intCast(codepoint)));	347	try writer.writeByte(@as(u8, @intCast(codepoint)));
348	}	348	}
349	},	349	},
350	.failure => \|err\| return Result{ .failure = err },	350	.failure => \|err\| return .{ .failure = err },
351	}	351	}
352	},	352	},
353	'\n' => return Result{ .failure = .{ .invalid_character = index } },	353	'\n' => return .{ .failure = .{ .invalid_character = index } },
354	'"' => return Result.success,	354	'"' => return .success,
355	else => {	355	else => {
356	try writer.writeByte(b);	356	try writer.writeByte(b);
357	index += 1;	357	index += 1;
...	@@ -363,10 +363,12 @@ pub fn parseWrite(writer: anytype, bytes: []const u8) error{OutOfMemory}!Result	...	@@ -363,10 +363,12 @@ pub fn parseWrite(writer: anytype, bytes: []const u8) error{OutOfMemory}!Result
363	/// Higher level API. Does not return extra info about parse errors.	363	/// Higher level API. Does not return extra info about parse errors.
364	/// Caller owns returned memory.	364	/// Caller owns returned memory.
365	pub fn parseAlloc(allocator: std.mem.Allocator, bytes: []const u8) ParseError![]u8 {	365	pub fn parseAlloc(allocator: std.mem.Allocator, bytes: []const u8) ParseError![]u8 {
366	var buf = std.ArrayList(u8).init(allocator);	366	var buf: std.io.AllocatingWriter = undefined;
		367	const bw = buf.init(allocator);
367	defer buf.deinit();	368	defer buf.deinit();
368		369	// TODO try @errorCast(...)
369	switch (try parseWrite(buf.writer(), bytes)) {	370	const result = parseWrite(bw, bytes) catch \|err\| return @errorCast(err);
		371	switch (result) {
370	.success => return buf.toOwnedSlice(),	372	.success => return buf.toOwnedSlice(),
371	.failure => return error.InvalidLiteral,	373	.failure => return error.InvalidLiteral,
372	}	374	}

src/Air/print.zig+12-13

...	@@ -1,6 +1,5 @@	...	@@ -1,6 +1,5 @@
1	const std = @import("std");	1	const std = @import("std");
2	const Allocator = std.mem.Allocator;	2	const Allocator = std.mem.Allocator;
3	const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
4		3
5	const build_options = @import("build_options");	4	const build_options = @import("build_options");
6	const Zcu = @import("../Zcu.zig");	5	const Zcu = @import("../Zcu.zig");
...	@@ -25,20 +24,20 @@ pub fn write(air: Air, stream: anytype, pt: Zcu.PerThread, liveness: ?Air.Livene	...	@@ -25,20 +24,20 @@ pub fn write(air: Air, stream: anytype, pt: Zcu.PerThread, liveness: ?Air.Livene
25		24
26	// zig fmt: off	25	// zig fmt: off
27	stream.print(	26	stream.print(
28	\\# Total AIR+Liveness bytes: {}	27	\\# Total AIR+Liveness bytes: {Bi}
29	\\# AIR Instructions: {d} ({})	28	\\# AIR Instructions: {d} ({Bi})
30	\\# AIR Extra Data: {d} ({})	29	\\# AIR Extra Data: {d} ({Bi})
31	\\# Liveness tomb_bits: {}	30	\\# Liveness tomb_bits: {Bi}
32	\\# Liveness Extra Data: {d} ({})	31	\\# Liveness Extra Data: {d} ({Bi})
33	\\# Liveness special table: {d} ({})	32	\\# Liveness special table: {d} ({Bi})
34	\\	33	\\
35	, .{	34	, .{
36	fmtIntSizeBin(total_bytes),	35	total_bytes,
37	air.instructions.len, fmtIntSizeBin(instruction_bytes),	36	air.instructions.len, instruction_bytes,
38	air.extra.items.len, fmtIntSizeBin(extra_bytes),	37	air.extra.items.len, extra_bytes,
39	fmtIntSizeBin(tomb_bytes),	38	tomb_bytes,
40	if (liveness) \|l\| l.extra.len else 0, fmtIntSizeBin(liveness_extra_bytes),	39	if (liveness) \|l\| l.extra.len else 0, liveness_extra_bytes,
41	if (liveness) \|l\| l.special.count() else 0, fmtIntSizeBin(liveness_special_bytes),	40	if (liveness) \|l\| l.special.count() else 0, liveness_special_bytes,
42	}) catch return;	41	}) catch return;
43	// zig fmt: on	42	// zig fmt: on
44		43

src/Builtin.zig+10-10

...	@@ -51,7 +51,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -51,7 +51,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
51	const zig_backend = opts.zig_backend;	51	const zig_backend = opts.zig_backend;
52		52
53	@setEvalBranchQuota(4000);	53	@setEvalBranchQuota(4000);
54	try buffer.writer().print(	54	try buffer.print(
55	\\const std = @import("std");	55	\\const std = @import("std");
56	\\/// Zig version. When writing code that supports multiple versions of Zig, prefer	56	\\/// Zig version. When writing code that supports multiple versions of Zig, prefer
57	\\/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.	57	\\/// feature detection (i.e. with `@hasDecl` or `@hasField`) over version checks.
...	@@ -89,10 +89,10 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -89,10 +89,10 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
89	const index = @as(std.Target.Cpu.Feature.Set.Index, @intCast(index_usize));	89	const index = @as(std.Target.Cpu.Feature.Set.Index, @intCast(index_usize));
90	const is_enabled = target.cpu.features.isEnabled(index);	90	const is_enabled = target.cpu.features.isEnabled(index);
91	if (is_enabled) {	91	if (is_enabled) {
92	try buffer.writer().print(" .{p_},\n", .{std.zig.fmtId(feature.name)});	92	try buffer.print(" .{p_},\n", .{std.zig.fmtId(feature.name)});
93	}	93	}
94	}	94	}
95	try buffer.writer().print(	95	try buffer.print(
96	\\ }}),	96	\\ }}),
97	\\}};	97	\\}};
98	\\pub const os: std.Target.Os = .{{	98	\\pub const os: std.Target.Os = .{{
...	@@ -104,7 +104,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -104,7 +104,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
104		104
105	switch (target.os.versionRange()) {	105	switch (target.os.versionRange()) {
106	.none => try buffer.appendSlice(" .none = {} },\n"),	106	.none => try buffer.appendSlice(" .none = {} },\n"),
107	.semver => \|semver\| try buffer.writer().print(	107	.semver => \|semver\| try buffer.print(
108	\\ .semver = .{{	108	\\ .semver = .{{
109	\\ .min = .{{	109	\\ .min = .{{
110	\\ .major = {},	110	\\ .major = {},
...	@@ -127,7 +127,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -127,7 +127,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
127	semver.max.minor,	127	semver.max.minor,
128	semver.max.patch,	128	semver.max.patch,
129	}),	129	}),
130	.linux => \|linux\| try buffer.writer().print(	130	.linux => \|linux\| try buffer.print(
131	\\ .linux = .{{	131	\\ .linux = .{{
132	\\ .range = .{{	132	\\ .range = .{{
133	\\ .min = .{{	133	\\ .min = .{{
...	@@ -164,7 +164,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -164,7 +164,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
164		164
165	linux.android,	165	linux.android,
166	}),	166	}),
167	.hurd => \|hurd\| try buffer.writer().print(	167	.hurd => \|hurd\| try buffer.print(
168	\\ .hurd = .{{	168	\\ .hurd = .{{
169	\\ .range = .{{	169	\\ .range = .{{
170	\\ .min = .{{	170	\\ .min = .{{
...	@@ -198,7 +198,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -198,7 +198,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
198	hurd.glibc.minor,	198	hurd.glibc.minor,
199	hurd.glibc.patch,	199	hurd.glibc.patch,
200	}),	200	}),
201	.windows => \|windows\| try buffer.writer().print(	201	.windows => \|windows\| try buffer.print(
202	\\ .windows = .{{	202	\\ .windows = .{{
203	\\ .min = {c},	203	\\ .min = {c},
204	\\ .max = {c},	204	\\ .max = {c},
...	@@ -217,7 +217,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -217,7 +217,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
217	);	217	);
218		218
219	if (target.dynamic_linker.get()) \|dl\| {	219	if (target.dynamic_linker.get()) \|dl\| {
220	try buffer.writer().print(	220	try buffer.print(
221	\\ .dynamic_linker = .init("{s}"),	221	\\ .dynamic_linker = .init("{s}"),
222	\\}};	222	\\}};
223	\\	223	\\
...	@@ -237,7 +237,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -237,7 +237,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
237	// knows libc will provide it, and likewise c.zig will not export memcpy.	237	// knows libc will provide it, and likewise c.zig will not export memcpy.
238	const link_libc = opts.link_libc;	238	const link_libc = opts.link_libc;
239		239
240	try buffer.writer().print(	240	try buffer.print(
241	\\pub const object_format: std.Target.ObjectFormat = .{p_};	241	\\pub const object_format: std.Target.ObjectFormat = .{p_};
242	\\pub const mode: std.builtin.OptimizeMode = .{p_};	242	\\pub const mode: std.builtin.OptimizeMode = .{p_};
243	\\pub const link_libc = {};	243	\\pub const link_libc = {};
...	@@ -269,7 +269,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {	...	@@ -269,7 +269,7 @@ pub fn append(opts: @This(), buffer: *std.ArrayList(u8)) Allocator.Error!void {
269	});	269	});
270		270
271	if (target.os.tag == .wasi) {	271	if (target.os.tag == .wasi) {
272	try buffer.writer().print(	272	try buffer.print(
273	\\pub const wasi_exec_model: std.builtin.WasiExecModel = .{p_};	273	\\pub const wasi_exec_model: std.builtin.WasiExecModel = .{p_};
274	\\	274	\\
275	, .{std.zig.fmtId(@tagName(opts.wasi_exec_model))});	275	, .{std.zig.fmtId(@tagName(opts.wasi_exec_model))});

src/Package/Fetch.zig+2-4

 @@ -1643,10 +1643,8 @@ fn dumpHashInfo(all_files: []const *const HashedFile) !void {
     const w = bw.writer();
     for (all_files) |hashed_file| {
-        try w.print("{s}: {s}: {s}\n", .{
+        try w.print("{s}: {x}: {s}\n", .{
-            @tagName(hashed_file.kind),
+            @tagName(hashed_file.kind), &hashed_file.hash, hashed_file.normalized_path,
-            std.fmt.fmtSliceHexLower(&hashed_file.hash),
-            hashed_file.normalized_path,
         });
     }

src/Package/Fetch/git.zig+1-1

...	@@ -127,7 +127,7 @@ pub const Oid = union(Format) {	...	@@ -127,7 +127,7 @@ pub const Oid = union(Format) {
127	) @TypeOf(writer).Error!void {	127	) @TypeOf(writer).Error!void {
128	_ = fmt;	128	_ = fmt;
129	_ = options;	129	_ = options;
130	try writer.print("{}", .{std.fmt.fmtSliceHexLower(oid.slice())});	130	try writer.print("{x}", .{oid.slice()});
131	}	131	}
132		132
133	pub fn slice(oid: *const Oid) []const u8 {	133	pub fn slice(oid: *const Oid) []const u8 {

src/Zcu/PerThread.zig+2-5

 @@ -477,11 +477,8 @@ pub fn updateZirRefs(pt: Zcu.PerThread) Allocator.Error!void {
                     if (std.zig.srcHashEql(old_hash, new_hash)) {
                         break :hash_changed;
                     }
-                    log.debug("hash for (%{d} -> %{d}) changed: {} -> {}", .{
+                    log.debug("hash for (%{d} -> %{d}) changed: {x} -> {x}", .{
-                        old_inst,
+                        old_inst, new_inst, &old_hash, &new_hash,
-                        new_inst,
-                        std.fmt.fmtSliceHexLower(&old_hash),
-                        std.fmt.fmtSliceHexLower(&new_hash),
                     });
                 }
                 // The source hash associated with this instruction changed - invalidate relevant dependencies.

src/arch/x86_64/encoder.zig+2-2

...	@@ -1205,9 +1205,9 @@ pub const Vex = struct {	...	@@ -1205,9 +1205,9 @@ pub const Vex = struct {
1205	fn expectEqualHexStrings(expected: []const u8, given: []const u8, assembly: []const u8) !void {	1205	fn expectEqualHexStrings(expected: []const u8, given: []const u8, assembly: []const u8) !void {
1206	assert(expected.len > 0);	1206	assert(expected.len > 0);
1207	if (std.mem.eql(u8, expected, given)) return;	1207	if (std.mem.eql(u8, expected, given)) return;
1208	const expected_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{std.fmt.fmtSliceHexLower(expected)});	1208	const expected_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{expected});
1209	defer testing.allocator.free(expected_fmt);	1209	defer testing.allocator.free(expected_fmt);
1210	const given_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{std.fmt.fmtSliceHexLower(given)});	1210	const given_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{given});
1211	defer testing.allocator.free(given_fmt);	1211	defer testing.allocator.free(given_fmt);
1212	const idx = std.mem.indexOfDiff(u8, expected_fmt, given_fmt).?;	1212	const idx = std.mem.indexOfDiff(u8, expected_fmt, given_fmt).?;
1213	const padding = try testing.allocator.alloc(u8, idx + 5);	1213	const padding = try testing.allocator.alloc(u8, idx + 5);

src/fmt.zig+3-37

...	@@ -190,41 +190,7 @@ pub fn run(	...	@@ -190,41 +190,7 @@ pub fn run(
190	}	190	}
191	}	191	}
192		192
193	const FmtError = error{	193	fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) anyerror!void {
194	SystemResources,
195	OperationAborted,
196	IoPending,
197	BrokenPipe,
198	Unexpected,
199	WouldBlock,
200	Canceled,
201	FileClosed,
202	DestinationAddressRequired,
203	DiskQuota,
204	FileTooBig,
205	MessageTooBig,
206	InputOutput,
207	NoSpaceLeft,
208	AccessDenied,
209	OutOfMemory,
210	RenameAcrossMountPoints,
211	ReadOnlyFileSystem,
212	LinkQuotaExceeded,
213	FileBusy,
214	EndOfStream,
215	Unseekable,
216	NotOpenForWriting,
217	UnsupportedEncoding,
218	InvalidEncoding,
219	ConnectionResetByPeer,
220	SocketNotConnected,
221	LockViolation,
222	NetNameDeleted,
223	InvalidArgument,
224	ProcessNotFound,
225	} \|\| fs.File.OpenError;
226
227	fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) FmtError!void {
228	fmtPathFile(fmt, file_path, check_mode, dir, sub_path) catch \|err\| switch (err) {	194	fmtPathFile(fmt, file_path, check_mode, dir, sub_path) catch \|err\| switch (err) {
229	error.IsDir, error.AccessDenied => return fmtPathDir(fmt, file_path, check_mode, dir, sub_path),	195	error.IsDir, error.AccessDenied => return fmtPathDir(fmt, file_path, check_mode, dir, sub_path),
230	else => {	196	else => {
...	@@ -241,7 +207,7 @@ fn fmtPathDir(	...	@@ -241,7 +207,7 @@ fn fmtPathDir(
241	check_mode: bool,	207	check_mode: bool,
242	parent_dir: fs.Dir,	208	parent_dir: fs.Dir,
243	parent_sub_path: []const u8,	209	parent_sub_path: []const u8,
244	) FmtError!void {	210	) anyerror!void {
245	var dir = try parent_dir.openDir(parent_sub_path, .{ .iterate = true });	211	var dir = try parent_dir.openDir(parent_sub_path, .{ .iterate = true });
246	defer dir.close();	212	defer dir.close();
247		213
...	@@ -277,7 +243,7 @@ fn fmtPathFile(	...	@@ -277,7 +243,7 @@ fn fmtPathFile(
277	check_mode: bool,	243	check_mode: bool,
278	dir: fs.Dir,	244	dir: fs.Dir,
279	sub_path: []const u8,	245	sub_path: []const u8,
280	) FmtError!void {	246	) anyerror!void {
281	const source_file = try dir.openFile(sub_path, .{});	247	const source_file = try dir.openFile(sub_path, .{});
282	var file_closed = false;	248	var file_closed = false;
283	errdefer if (!file_closed) source_file.close();	249	errdefer if (!file_closed) source_file.close();

src/libs/mingw.zig+14-13

 @@ -388,7 +388,7 @@ pub fn libExists(
 /// This function body is verbose but all it does is test 3 different paths and
 /// see if a .def file exists.
 fn findDef(
-    allocator: Allocator,
+    gpa: Allocator,
     target: *const std.Target,
     zig_lib_directory: Cache.Directory,
     lib_name: []const u8,
 @@ -401,7 +401,8 @@ fn findDef(
         else => unreachable,
     };
-    var override_path = std.ArrayList(u8).init(allocator);
+    var override_path: std.io.AllocatingWriter = undefined;
+    const override_path_writer = override_path.init(gpa);
     defer override_path.deinit();
     const s = path.sep_str;
 @@ -410,11 +411,11 @@ fn findDef(
         // Try the archtecture-specific path first.
         const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "{s}" ++ s ++ "{s}.def";
         if (zig_lib_directory.path) |p| {
-            try override_path.writer().print("{s}" ++ s ++ fmt_path, .{ p, lib_path, lib_name });
+            try override_path_writer.print("{s}" ++ s ++ fmt_path, .{ p, lib_path, lib_name });
         } else {
-            try override_path.writer().print(fmt_path, .{ lib_path, lib_name });
+            try override_path_writer.print(fmt_path, .{ lib_path, lib_name });
         }
-        if (std.fs.cwd().access(override_path.items, .{})) |_| {
+        if (std.fs.cwd().access(override_path.getWritten(), .{})) |_| {
             return override_path.toOwnedSlice();
         } else |err| switch (err) {
             error.FileNotFound => {},
 @@ -424,14 +425,14 @@ fn findDef(
     {
         // Try the generic version.
-        override_path.shrinkRetainingCapacity(0);
+        override_path.clearRetainingCapacity();
         const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def";
         if (zig_lib_directory.path) |p| {
-            try override_path.writer().print("{s}" ++ s ++ fmt_path, .{ p, lib_name });
+            try override_path_writer.print("{s}" ++ s ++ fmt_path, .{ p, lib_name });
         } else {
-            try override_path.writer().print(fmt_path, .{lib_name});
+            try override_path_writer.print(fmt_path, .{lib_name});
         }
-        if (std.fs.cwd().access(override_path.items, .{})) |_| {
+        if (std.fs.cwd().access(override_path.getWritten(), .{})) |_| {
             return override_path.toOwnedSlice();
         } else |err| switch (err) {
             error.FileNotFound => {},
 @@ -441,14 +442,14 @@ fn findDef(
     {
         // Try the generic version and preprocess it.
-        override_path.shrinkRetainingCapacity(0);
+        override_path.clearRetainingCapacity();
         const fmt_path = "libc" ++ s ++ "mingw" ++ s ++ "lib-common" ++ s ++ "{s}.def.in";
         if (zig_lib_directory.path) |p| {
-            try override_path.writer().print("{s}" ++ s ++ fmt_path, .{ p, lib_name });
+            try override_path_writer.print("{s}" ++ s ++ fmt_path, .{ p, lib_name });
         } else {
-            try override_path.writer().print(fmt_path, .{lib_name});
+            try override_path_writer.print(fmt_path, .{lib_name});
         }
-        if (std.fs.cwd().access(override_path.items, .{})) |_| {
+        if (std.fs.cwd().access(override_path.getWritten(), .{})) |_| {
             return override_path.toOwnedSlice();
         } else |err| switch (err) {
             error.FileNotFound => {},

src/link/Coff.zig+2-2

...	@@ -830,8 +830,8 @@ fn debugMem(allocator: Allocator, handle: std.process.Child.Id, pvaddr: std.os.w	...	@@ -830,8 +830,8 @@ fn debugMem(allocator: Allocator, handle: std.process.Child.Id, pvaddr: std.os.w
830	const buffer = try allocator.alloc(u8, code.len);	830	const buffer = try allocator.alloc(u8, code.len);
831	defer allocator.free(buffer);	831	defer allocator.free(buffer);
832	const memread = try std.os.windows.ReadProcessMemory(handle, pvaddr, buffer);	832	const memread = try std.os.windows.ReadProcessMemory(handle, pvaddr, buffer);
833	log.debug("to write: {x}", .{std.fmt.fmtSliceHexLower(code)});	833	log.debug("to write: {x}", .{code});
834	log.debug("in memory: {x}", .{std.fmt.fmtSliceHexLower(memread)});	834	log.debug("in memory: {x}", .{memread});
835	}	835	}
836		836
837	fn writeMemProtected(handle: std.process.Child.Id, pvaddr: std.os.windows.LPVOID, code: []const u8) !void {	837	fn writeMemProtected(handle: std.process.Child.Id, pvaddr: std.os.windows.LPVOID, code: []const u8) !void {

src/link/MachO/dyld_info/Trie.zig+2-2

...	@@ -336,9 +336,9 @@ const Edge = struct {	...	@@ -336,9 +336,9 @@ const Edge = struct {
336	fn expectEqualHexStrings(expected: []const u8, given: []const u8) !void {	336	fn expectEqualHexStrings(expected: []const u8, given: []const u8) !void {
337	assert(expected.len > 0);	337	assert(expected.len > 0);
338	if (mem.eql(u8, expected, given)) return;	338	if (mem.eql(u8, expected, given)) return;
339	const expected_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{std.fmt.fmtSliceHexLower(expected)});	339	const expected_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{expected});
340	defer testing.allocator.free(expected_fmt);	340	defer testing.allocator.free(expected_fmt);
341	const given_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{std.fmt.fmtSliceHexLower(given)});	341	const given_fmt = try std.fmt.allocPrint(testing.allocator, "{x}", .{given});
342	defer testing.allocator.free(given_fmt);	342	defer testing.allocator.free(given_fmt);
343	const idx = mem.indexOfDiff(u8, expected_fmt, given_fmt).?;	343	const idx = mem.indexOfDiff(u8, expected_fmt, given_fmt).?;
344	const padding = try testing.allocator.alloc(u8, idx + 5);	344	const padding = try testing.allocator.alloc(u8, idx + 5);

src/link/Wasm/Flush.zig+3-9

 @@ -1035,20 +1035,14 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void {
                 var id: [16]u8 = undefined;
                 std.crypto.hash.sha3.TurboShake128(null).hash(binary_bytes.items, &id, .{});
                 var uuid: [36]u8 = undefined;
-                _ = try std.fmt.bufPrint(&uuid, "{s}-{s}-{s}-{s}-{s}", .{
+                _ = try std.fmt.bufPrint(&uuid, "{x}-{x}-{x}-{x}-{x}", .{
-                    std.fmt.fmtSliceHexLower(id[0..4]),
+                    id[0..4], id[4..6], id[6..8], id[8..10], id[10..],
-                    std.fmt.fmtSliceHexLower(id[4..6]),
-                    std.fmt.fmtSliceHexLower(id[6..8]),
-                    std.fmt.fmtSliceHexLower(id[8..10]),
-                    std.fmt.fmtSliceHexLower(id[10..]),
                 });
                 try emitBuildIdSection(gpa, binary_bytes, &uuid);
             },
             .hexstring => |hs| {
                 var buffer: [32 * 2]u8 = undefined;
-                const str = std.fmt.bufPrint(&buffer, "{s}", .{
+                const str = std.fmt.bufPrint(&buffer, "{x}", .{hs.toSlice()}) catch unreachable;
-                    std.fmt.fmtSliceHexLower(hs.toSlice()),
-                }) catch unreachable;
                 try emitBuildIdSection(gpa, binary_bytes, str);
             },
             else => |mode| {

src/main.zig+73-58

...	@@ -65,6 +65,9 @@ pub fn wasi_cwd() std.os.wasi.fd_t {	...	@@ -65,6 +65,9 @@ pub fn wasi_cwd() std.os.wasi.fd_t {
65		65
66	const fatal = std.process.fatal;	66	const fatal = std.process.fatal;
67		67
		68	/// This can be global since stdout is a singleton.
		69	var stdout_buffer: [4096]u8 = undefined;
		70
68	/// Shaming all the locations that inappropriately use an O(N) search algorithm.	71	/// Shaming all the locations that inappropriately use an O(N) search algorithm.
69	/// Please delete this and fix the compilation errors!	72	/// Please delete this and fix the compilation errors!
70	pub const @"bad O(N)" = void;	73	pub const @"bad O(N)" = void;
...	@@ -338,9 +341,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {	...	@@ -338,9 +341,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
338	return cmdInit(gpa, arena, cmd_args);	341	return cmdInit(gpa, arena, cmd_args);
339	} else if (mem.eql(u8, cmd, "targets")) {	342	} else if (mem.eql(u8, cmd, "targets")) {
340	dev.check(.targets_command);	343	dev.check(.targets_command);
341	const host = std.zig.resolveTargetQueryOrFatal(.{});	344	return @import("print_targets.zig").cmdTargets(arena, cmd_args);
342	const stdout = io.getStdOut().writer();
343	return @import("print_targets.zig").cmdTargets(arena, cmd_args, stdout, &host);
344	} else if (mem.eql(u8, cmd, "version")) {	345	} else if (mem.eql(u8, cmd, "version")) {
345	dev.check(.version_command);	346	dev.check(.version_command);
346	try std.io.getStdOut().writeAll(build_options.version ++ "\n");	347	try std.io.getStdOut().writeAll(build_options.version ++ "\n");
...	@@ -351,7 +352,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {	...	@@ -351,7 +352,7 @@ fn mainArgs(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
351	} else if (mem.eql(u8, cmd, "env")) {	352	} else if (mem.eql(u8, cmd, "env")) {
352	dev.check(.env_command);	353	dev.check(.env_command);
353	verifyLibcxxCorrectlyLinked();	354	verifyLibcxxCorrectlyLinked();
354	return @import("print_env.zig").cmdEnv(arena, cmd_args, io.getStdOut().writer());	355	return @import("print_env.zig").cmdEnv(arena, cmd_args);
355	} else if (mem.eql(u8, cmd, "reduce")) {	356	} else if (mem.eql(u8, cmd, "reduce")) {
356	return jitCmd(gpa, arena, cmd_args, .{	357	return jitCmd(gpa, arena, cmd_args, .{
357	.cmd_name = "reduce",	358	.cmd_name = "reduce",
...	@@ -3334,9 +3335,8 @@ fn buildOutputType(	...	@@ -3334,9 +3335,8 @@ fn buildOutputType(
3334	var bin_digest: Cache.BinDigest = undefined;	3335	var bin_digest: Cache.BinDigest = undefined;
3335	hasher.final(&bin_digest);	3336	hasher.final(&bin_digest);
3336		3337
3337	const sub_path = try std.fmt.allocPrint(arena, "tmp" ++ sep ++ "{s}-stdin{s}", .{	3338	const sub_path = try std.fmt.allocPrint(arena, "tmp" ++ sep ++ "{x}-stdin{s}", .{
3338	std.fmt.fmtSliceHexLower(&bin_digest),	3339	&bin_digest, ext.canonicalName(target),
3339	ext.canonicalName(target),
3340	});	3340	});
3341	try dirs.local_cache.handle.rename(dump_path, sub_path);	3341	try dirs.local_cache.handle.rename(dump_path, sub_path);
3342		3342
...	@@ -6061,6 +6061,11 @@ fn cmdAstCheck(	...	@@ -6061,6 +6061,11 @@ fn cmdAstCheck(
6061		6061
6062	const tree = try Ast.parse(arena, source, mode);	6062	const tree = try Ast.parse(arena, source, mode);
6063		6063
		6064	var bw: std.io.BufferedWriter = .{
		6065	.unbuffered_writer = io.getStdOut().writer(),
		6066	.buffer = &stdout_buffer,
		6067	};
		6068
6064	switch (mode) {	6069	switch (mode) {
6065	.zig => {	6070	.zig => {
6066	const zir = try AstGen.generate(arena, tree);	6071	const zir = try AstGen.generate(arena, tree);
...	@@ -6103,31 +6108,30 @@ fn cmdAstCheck(	...	@@ -6103,31 +6108,30 @@ fn cmdAstCheck(
6103	const extra_bytes = zir.extra.len * @sizeOf(u32);	6108	const extra_bytes = zir.extra.len * @sizeOf(u32);
6104	const total_bytes = @sizeOf(Zir) + instruction_bytes + extra_bytes +	6109	const total_bytes = @sizeOf(Zir) + instruction_bytes + extra_bytes +
6105	zir.string_bytes.len * @sizeOf(u8);	6110	zir.string_bytes.len * @sizeOf(u8);
6106	const stdout = io.getStdOut();
6107	const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
6108	// zig fmt: off	6111	// zig fmt: off
6109	try stdout.writer().print(	6112	try bw.print(
6110	\\# Source bytes: {}	6113	\\# Source bytes: {Bi}
6111	\\# Tokens: {} ({})	6114	\\# Tokens: {} ({Bi})
6112	\\# AST Nodes: {} ({})	6115	\\# AST Nodes: {} ({Bi})
6113	\\# Total ZIR bytes: {}	6116	\\# Total ZIR bytes: {Bi}
6114	\\# Instructions: {d} ({})	6117	\\# Instructions: {d} ({Bi})
6115	\\# String Table Bytes: {}	6118	\\# String Table Bytes: {}
6116	\\# Extra Data Items: {d} ({})	6119	\\# Extra Data Items: {d} ({Bi})
6117	\\	6120	\\
6118	, .{	6121	, .{
6119	fmtIntSizeBin(source.len),	6122	source.len,
6120	tree.tokens.len, fmtIntSizeBin(token_bytes),	6123	tree.tokens.len, token_bytes,
6121	tree.nodes.len, fmtIntSizeBin(tree_bytes),	6124	tree.nodes.len, tree_bytes,
6122	fmtIntSizeBin(total_bytes),	6125	total_bytes,
6123	zir.instructions.len, fmtIntSizeBin(instruction_bytes),	6126	zir.instructions.len, instruction_bytes,
6124	fmtIntSizeBin(zir.string_bytes.len),	6127	zir.string_bytes.len,
6125	zir.extra.len, fmtIntSizeBin(extra_bytes),	6128	zir.extra.len, extra_bytes,
6126	});	6129	});
6127	// zig fmt: on	6130	// zig fmt: on
6128	}	6131	}
6129		6132
6130	try @import("print_zir.zig").renderAsTextToFile(arena, tree, zir, io.getStdOut());	6133	try @import("print_zir.zig").renderAsText(arena, tree, zir, &bw);
		6134	try bw.flush();
6131		6135
6132	if (zir.hasCompileErrors()) {	6136	if (zir.hasCompileErrors()) {
6133	process.exit(1);	6137	process.exit(1);
...	@@ -6154,7 +6158,8 @@ fn cmdAstCheck(	...	@@ -6154,7 +6158,8 @@ fn cmdAstCheck(
6154	fatal("-t option only available in builds of zig with debug extensions", .{});	6158	fatal("-t option only available in builds of zig with debug extensions", .{});
6155	}	6159	}
6156		6160
6157	try @import("print_zoir.zig").renderToFile(zoir, arena, io.getStdOut());	6161	try @import("print_zoir.zig").renderToWriter(zoir, arena, &bw);
		6162	try bw.flush();
6158	return cleanExit();	6163	return cleanExit();
6159	},	6164	},
6160	}	6165	}
...	@@ -6275,11 +6280,13 @@ fn detectNativeCpuWithLLVM(	...	@@ -6275,11 +6280,13 @@ fn detectNativeCpuWithLLVM(
6275	}	6280	}
6276		6281
6277	fn printCpu(cpu: std.Target.Cpu) !void {	6282	fn printCpu(cpu: std.Target.Cpu) !void {
6278	var bw = io.bufferedWriter(io.getStdOut().writer());	6283	var bw: std.io.BufferedWriter = .{
6279	const stdout = bw.writer();	6284	.unbuffered_writer = io.getStdOut().writer(),
		6285	.buffer = &stdout_buffer,
		6286	};
6280		6287
6281	if (cpu.model.llvm_name) \|llvm_name\| {	6288	if (cpu.model.llvm_name) \|llvm_name\| {
6282	try stdout.print("{s}\n", .{llvm_name});	6289	try bw.print("{s}\n", .{llvm_name});
6283	}	6290	}
6284		6291
6285	const all_features = cpu.arch.allFeaturesList();	6292	const all_features = cpu.arch.allFeaturesList();
...	@@ -6288,7 +6295,7 @@ fn printCpu(cpu: std.Target.Cpu) !void {	...	@@ -6288,7 +6295,7 @@ fn printCpu(cpu: std.Target.Cpu) !void {
6288	const index: std.Target.Cpu.Feature.Set.Index = @intCast(index_usize);	6295	const index: std.Target.Cpu.Feature.Set.Index = @intCast(index_usize);
6289	const is_enabled = cpu.features.isEnabled(index);	6296	const is_enabled = cpu.features.isEnabled(index);
6290	const plus_or_minus = "-+"[@intFromBool(is_enabled)];	6297	const plus_or_minus = "-+"[@intFromBool(is_enabled)];
6291	try stdout.print("{c}{s}\n", .{ plus_or_minus, llvm_name });	6298	try bw.print("{c}{s}\n", .{ plus_or_minus, llvm_name });
6292	}	6299	}
6293		6300
6294	try bw.flush();	6301	try bw.flush();
...	@@ -6356,6 +6363,11 @@ fn cmdDumpZir(	...	@@ -6356,6 +6363,11 @@ fn cmdDumpZir(
6356		6363
6357	const zir = try Zcu.loadZirCache(arena, f);	6364	const zir = try Zcu.loadZirCache(arena, f);
6358		6365
		6366	var bw: std.io.BufferedWriter = .{
		6367	.unbuffered_writer = io.getStdOut().writer(),
		6368	.buffer = &stdout_buffer,
		6369	};
		6370
6359	{	6371	{
6360	const instruction_bytes = zir.instructions.len *	6372	const instruction_bytes = zir.instructions.len *
6361	// Here we don't use @sizeOf(Zir.Inst.Data) because it would include	6373	// Here we don't use @sizeOf(Zir.Inst.Data) because it would include
...	@@ -6364,25 +6376,24 @@ fn cmdDumpZir(	...	@@ -6364,25 +6376,24 @@ fn cmdDumpZir(
6364	const extra_bytes = zir.extra.len * @sizeOf(u32);	6376	const extra_bytes = zir.extra.len * @sizeOf(u32);
6365	const total_bytes = @sizeOf(Zir) + instruction_bytes + extra_bytes +	6377	const total_bytes = @sizeOf(Zir) + instruction_bytes + extra_bytes +
6366	zir.string_bytes.len * @sizeOf(u8);	6378	zir.string_bytes.len * @sizeOf(u8);
6367	const stdout = io.getStdOut();
6368	const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
6369	// zig fmt: off	6379	// zig fmt: off
6370	try stdout.writer().print(	6380	try bw.print(
6371	\\# Total ZIR bytes: {}	6381	\\# Total ZIR bytes: {Bi}
6372	\\# Instructions: {d} ({})	6382	\\# Instructions: {d} ({Bi})
6373	\\# String Table Bytes: {}	6383	\\# String Table Bytes: {Bi}
6374	\\# Extra Data Items: {d} ({})	6384	\\# Extra Data Items: {d} ({Bi})
6375	\\	6385	\\
6376	, .{	6386	, .{
6377	fmtIntSizeBin(total_bytes),	6387	total_bytes,
6378	zir.instructions.len, fmtIntSizeBin(instruction_bytes),	6388	zir.instructions.len, instruction_bytes,
6379	fmtIntSizeBin(zir.string_bytes.len),	6389	zir.string_bytes.len,
6380	zir.extra.len, fmtIntSizeBin(extra_bytes),	6390	zir.extra.len, extra_bytes,
6381	});	6391	});
6382	// zig fmt: on	6392	// zig fmt: on
6383	}	6393	}
6384		6394
6385	return @import("print_zir.zig").renderAsTextToFile(arena, null, zir, io.getStdOut());	6395	try @import("print_zir.zig").renderAsText(arena, null, zir, &bw);
		6396	try bw.flush();
6386	}	6397	}
6387		6398
6388	/// This is only enabled for debug builds.	6399	/// This is only enabled for debug builds.
...	@@ -6440,13 +6451,15 @@ fn cmdChangelist(	...	@@ -6440,13 +6451,15 @@ fn cmdChangelist(
6440	var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;	6451	var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .empty;
6441	try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);	6452	try Zcu.mapOldZirToNew(arena, old_zir, new_zir, &inst_map);
6442		6453
6443	var bw = io.bufferedWriter(io.getStdOut().writer());	6454	var bw: std.io.BufferedWriter = .{
6444	const stdout = bw.writer();	6455	.unbuffered_writer = io.getStdOut().writer(),
		6456	.buffer = &stdout_buffer,
		6457	};
6445	{	6458	{
6446	try stdout.print("Instruction mappings:\n", .{});	6459	try bw.print("Instruction mappings:\n", .{});
6447	var it = inst_map.iterator();	6460	var it = inst_map.iterator();
6448	while (it.next()) \|entry\| {	6461	while (it.next()) \|entry\| {
6449	try stdout.print(" %{d} => %{d}\n", .{	6462	try bw.print(" %{d} => %{d}\n", .{
6450	@intFromEnum(entry.key_ptr.*),	6463	@intFromEnum(entry.key_ptr.*),
6451	@intFromEnum(entry.value_ptr.*),	6464	@intFromEnum(entry.value_ptr.*),
6452	});	6465	});
...	@@ -6714,13 +6727,10 @@ fn accessFrameworkPath(	...	@@ -6714,13 +6727,10 @@ fn accessFrameworkPath(
6714		6727
6715	for (&[_][]const u8{ ".tbd", ".dylib", "" }) \|ext\| {	6728	for (&[_][]const u8{ ".tbd", ".dylib", "" }) \|ext\| {
6716	test_path.clearRetainingCapacity();	6729	test_path.clearRetainingCapacity();
6717	try test_path.writer().print("{s}" ++ sep ++ "{s}.framework" ++ sep ++ "{s}{s}", .{	6730	try test_path.print("{s}" ++ sep ++ "{s}.framework" ++ sep ++ "{s}{s}", .{
6718	framework_dir_path,	6731	framework_dir_path, framework_name, framework_name, ext,
6719	framework_name,
6720	framework_name,
6721	ext,
6722	});	6732	});
6723	try checked_paths.writer().print("\n {s}", .{test_path.items});	6733	try checked_paths.print("\n {s}", .{test_path.items});
6724	fs.cwd().access(test_path.items, .{}) catch \|err\| switch (err) {	6734	fs.cwd().access(test_path.items, .{}) catch \|err\| switch (err) {
6725	error.FileNotFound => continue,	6735	error.FileNotFound => continue,
6726	else => \|e\| fatal("unable to search for {s} framework '{s}': {s}", .{	6736	else => \|e\| fatal("unable to search for {s} framework '{s}': {s}", .{
...	@@ -7033,14 +7043,19 @@ fn cmdFetch(	...	@@ -7033,14 +7043,19 @@ fn cmdFetch(
7033	try fixups.append_string_after_node.put(gpa, manifest.version_node, dependencies_text);	7043	try fixups.append_string_after_node.put(gpa, manifest.version_node, dependencies_text);
7034	}	7044	}
7035		7045
7036	var rendered = std.ArrayList(u8).init(gpa);	7046	var file = build_root.directory.handle.createFile(Package.Manifest.basename, .{}) catch \|err\| {
7037	defer rendered.deinit();	7047	fatal("unable to create {s} file: {s}", .{ Package.Manifest.basename, err });
7038	try ast.renderToArrayList(&rendered, fixups);
7039
7040	build_root.directory.handle.writeFile(.{ .sub_path = Package.Manifest.basename, .data = rendered.items }) catch \|err\| {
7041	fatal("unable to write {s} file: {s}", .{ Package.Manifest.basename, @errorName(err) });
7042	};	7048	};
7043		7049	defer file.close();
		7050	var buffer: [4096]u8 = undefined;
		7051	var bw: std.io.BufferedWriter = .{
		7052	.unbuffered_writer = file.writer(),
		7053	.buffer = &buffer,
		7054	};
		7055	ast.render(gpa, &bw, fixups) catch \|err\| fatal("failed to render AST to {s}: {s}", .{
		7056	Package.Manifest.basename, err,
		7057	});
		7058	bw.flush() catch \|err\| fatal("failed to flush {s}: {s}", .{ Package.Manifest.basename, err });
7044	return cleanExit();	7059	return cleanExit();
7045	}	7060	}
7046		7061

src/print_env.zig+8-6

...	@@ -4,7 +4,7 @@ const introspect = @import("introspect.zig");	...	@@ -4,7 +4,7 @@ const introspect = @import("introspect.zig");
4	const Allocator = std.mem.Allocator;	4	const Allocator = std.mem.Allocator;
5	const fatal = std.process.fatal;	5	const fatal = std.process.fatal;
6		6
7	pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Writer) !void {	7	pub fn cmdEnv(arena: Allocator, args: []const []const u8) !void {
8	_ = args;	8	_ = args;
9	const cwd_path = try introspect.getResolvedCwd(arena);	9	const cwd_path = try introspect.getResolvedCwd(arena);
10	const self_exe_path = try std.fs.selfExePathAlloc(arena);	10	const self_exe_path = try std.fs.selfExePathAlloc(arena);
...	@@ -21,10 +21,12 @@ pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Wr	...	@@ -21,10 +21,12 @@ pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Wr
21	const host = try std.zig.system.resolveTargetQuery(.{});	21	const host = try std.zig.system.resolveTargetQuery(.{});
22	const triple = try host.zigTriple(arena);	22	const triple = try host.zigTriple(arena);
23		23
24	var bw = std.io.bufferedWriter(stdout);	24	var buffer: [1024]u8 = undefined;
25	const w = bw.writer();	25	var bw: std.io.BufferedWriter = .{
26		26	.buffer = &buffer,
27	var jws = std.json.writeStream(w, .{ .whitespace = .indent_1 });	27	.unbuffered_writer = std.io.getStdOut().writer(),
		28	};
		29	var jws = std.json.writeStream(bw, .{ .whitespace = .indent_1 });
28		30
29	try jws.beginObject();	31	try jws.beginObject();
30		32
...	@@ -55,7 +57,7 @@ pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Wr	...	@@ -55,7 +57,7 @@ pub fn cmdEnv(arena: Allocator, args: []const []const u8, stdout: std.fs.File.Wr
55	try jws.endObject();	57	try jws.endObject();
56		58
57	try jws.endObject();	59	try jws.endObject();
58	try w.writeByte('\n');	60	try bw.writeByte('\n');
59		61
60	try bw.flush();	62	try bw.flush();
61	}	63	}

src/print_targets.zig+26-30

 @@ -11,36 +11,36 @@ const assert = std.debug.assert;
 const glibc = @import("libs/glibc.zig");
 const introspect = @import("introspect.zig");
-pub fn cmdTargets(
+pub fn cmdTargets(arena: Allocator, args: []const []const u8) anyerror!void {
-    allocator: Allocator,
-    args: []const []const u8,
-    /// Output stream
-    stdout: anytype,
-    native_target: *const Target,
-) !void {
     _ = args;
-    var zig_lib_directory = introspect.findZigLibDir(allocator) catch |err| {
+    const host = std.zig.resolveTargetQueryOrFatal(.{});
+    var buffer: [1024]u8 = undefined;
+    var bw: std.io.BufferedWriter = .{
+        .unbuffered_writer = io.getStdOut().writer(),
+        .buffer = &buffer,
+    };
+    try print(arena, &bw, host);
+    try bw.flush();
+}
+fn print(arena: Allocator, output: *std.io.BufferedWriter, host: *const Target) anyerror!void {
+    var zig_lib_directory = introspect.findZigLibDir(arena) catch |err| {
         fatal("unable to find zig installation directory: {s}\n", .{@errorName(err)});
     };
     defer zig_lib_directory.handle.close();
-    defer allocator.free(zig_lib_directory.path.?);
     const abilists_contents = zig_lib_directory.handle.readFileAlloc(
-        allocator,
+        arena,
         glibc.abilists_path,
         glibc.abilists_max_size,
     ) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
         else => fatal("unable to read " ++ glibc.abilists_path ++ ": {s}", .{@errorName(err)}),
     };
-    defer allocator.free(abilists_contents);
-    const glibc_abi = try glibc.loadMetaData(allocator, abilists_contents);
+    const glibc_abi = try glibc.loadMetaData(arena, abilists_contents);
-    defer glibc_abi.destroy(allocator);
-    var bw = io.bufferedWriter(stdout);
+    var sz = std.zon.stringify.serializer(output, .{});
-    const w = bw.writer();
-    var sz = std.zon.stringify.serializer(w, .{});
     {
         var root_obj = try sz.beginStruct(.{});
 @@ -52,10 +52,9 @@ pub fn cmdTargets(
         {
             var libc_obj = try root_obj.beginTupleField("libc", .{});
             for (std.zig.target.available_libcs) |libc| {
-                const tmp = try std.fmt.allocPrint(allocator, "{s}-{s}-{s}", .{
+                const tmp = try std.fmt.allocPrint(arena, "{s}-{s}-{s}", .{
                     @tagName(libc.arch), @tagName(libc.os), @tagName(libc.abi),
                 });
-                defer allocator.free(tmp);
                 try libc_obj.field(tmp, .{});
             }
             try libc_obj.end();
 @@ -64,8 +63,7 @@ pub fn cmdTargets(
         {
             var glibc_obj = try root_obj.beginTupleField("glibc", .{});
             for (glibc_abi.all_versions) |ver| {
-                const tmp = try std.fmt.allocPrint(allocator, "{}", .{ver});
+                const tmp = try std.fmt.allocPrint(arena, "{}", .{ver});
-                defer allocator.free(tmp);
                 try glibc_obj.field(tmp, .{});
             }
             try glibc_obj.end();
 @@ -105,21 +103,20 @@ pub fn cmdTargets(
         {
             var native_obj = try root_obj.beginStructField("native", .{});
             {
-                const triple = try native_target.zigTriple(allocator);
+                const triple = try host.zigTriple(arena);
-                defer allocator.free(triple);
                 try native_obj.field("triple", triple, .{});
             }
             {
                 var cpu_obj = try native_obj.beginStructField("cpu", .{});
-                try cpu_obj.field("arch", @tagName(native_target.cpu.arch), .{});
+                try cpu_obj.field("arch", @tagName(host.cpu.arch), .{});
-                try cpu_obj.field("name", native_target.cpu.model.name, .{});
+                try cpu_obj.field("name", host.cpu.model.name, .{});
                 {
                     var features = try native_obj.beginTupleField("features", .{});
-                    for (native_target.cpu.arch.allFeaturesList(), 0..) |feature, i_usize| {
+                    for (host.cpu.arch.allFeaturesList(), 0..) |feature, i_usize| {
                         const index = @as(Target.Cpu.Feature.Set.Index, @intCast(i_usize));
-                        if (native_target.cpu.features.isEnabled(index)) {
+                        if (host.cpu.features.isEnabled(index)) {
                             try features.field(feature.name, .{});
                         }
                     }
 @@ -128,14 +125,13 @@ pub fn cmdTargets(
                 try cpu_obj.end();
             }
-            try native_obj.field("os", @tagName(native_target.os.tag), .{});
+            try native_obj.field("os", @tagName(host.os.tag), .{});
-            try native_obj.field("abi", @tagName(native_target.abi), .{});
+            try native_obj.field("abi", @tagName(host.abi), .{});
             try native_obj.end();
         }
         try root_obj.end();
     }
-    try w.writeByte('\n');
+    try output.writeByte('\n');
-    return bw.flush();
 }

src/print_zir.zig+161-173

src/print_zoir.zig+13-20

 @@ -1,13 +1,6 @@
-pub fn renderToFile(zoir: Zoir, arena: Allocator, f: std.fs.File) (std.fs.File.WriteError || Allocator.Error)!void {
+pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: *std.io.BufferedWriter) anyerror!void {
-    var bw = std.io.bufferedWriter(f.writer());
-    try renderToWriter(zoir, arena, bw.writer());
-    try bw.flush();
-}
-pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: anytype) (@TypeOf(w).Error || Allocator.Error)!void {
     assert(!zoir.hasCompileErrors());
-    const fmtIntSizeBin = std.fmt.fmtIntSizeBin;
     const bytes_per_node = comptime n: {
         var n: usize = 0;
         for (@typeInfo(Zoir.Node.Repr).@"struct".fields) |f| {
 @@ -23,22 +16,22 @@ pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: anytype) (@TypeOf(w).Erro
     // zig fmt: off
     try w.print(
-        \\# Nodes:              {} ({})
+        \\# Nodes:              {} ({Bi})
-        \\# Extra Data Items:   {} ({})
+        \\# Extra Data Items:   {} ({Bi})
-        \\# BigInt Limbs:       {} ({})
+        \\# BigInt Limbs:       {} ({Bi})
-        \\# String Table Bytes: {}
+        \\# String Table Bytes: {Bi}
-        \\# Total ZON Bytes:    {}
+        \\# Total ZON Bytes:    {Bi}
         \\
     , .{
-        zoir.nodes.len, fmtIntSizeBin(node_bytes),
+        zoir.nodes.len, node_bytes,
-        zoir.extra.len, fmtIntSizeBin(extra_bytes),
+        zoir.extra.len, extra_bytes,
-        zoir.limbs.len, fmtIntSizeBin(limb_bytes),
+        zoir.limbs.len, limb_bytes,
-        fmtIntSizeBin(string_bytes),
+        string_bytes,
-        fmtIntSizeBin(node_bytes + extra_bytes + limb_bytes + string_bytes),
+        node_bytes + extra_bytes + limb_bytes + string_bytes,
     });
     // zig fmt: on
     var pz: PrintZon = .{
-        .w = w.any(),
+        .w = w,
         .arena = arena,
         .zoir = zoir,
         .indent = 0,
 @@ -48,7 +41,7 @@ pub fn renderToWriter(zoir: Zoir, arena: Allocator, w: anytype) (@TypeOf(w).Erro
 }
 const PrintZon = struct {
-    w: std.io.AnyWriter,
+    w: *std.io.BufferedWriter,
     arena: Allocator,
     zoir: Zoir,
     indent: u32,

src/translate_c.zig+1-1

...	@@ -5905,7 +5905,7 @@ fn parseCPrimaryExpr(c: Context, m: MacroCtx, scope: *Scope) ParseError!Node {	...	@@ -5905,7 +5905,7 @@ fn parseCPrimaryExpr(c: Context, m: MacroCtx, scope: *Scope) ParseError!Node {
5905	if (slice[0] != '\'' or slice[1] == '\\' or slice.len == 3) {	5905	if (slice[0] != '\'' or slice[1] == '\\' or slice.len == 3) {
5906	return Tag.char_literal.create(c.arena, try escapeUnprintables(c, m));	5906	return Tag.char_literal.create(c.arena, try escapeUnprintables(c, m));
5907	} else {	5907	} else {
5908	const str = try std.fmt.allocPrint(c.arena, "0x{s}", .{std.fmt.fmtSliceHexLower(slice[1 .. slice.len - 1])});	5908	const str = try std.fmt.allocPrint(c.arena, "0x{x}", .{slice[1 .. slice.len - 1]});
5909	return Tag.integer_literal.create(c.arena, str);	5909	return Tag.integer_literal.create(c.arena, str);
5910	}	5910	}
5911	},	5911	},

...	@@ -9,13 +9,8 @@ const Zir = std.zig.Zir;	...	@@ -9,13 +9,8 @@ const Zir = std.zig.Zir;
9	const Zcu = @import("Zcu.zig");	9	const Zcu = @import("Zcu.zig");
10	const LazySrcLoc = Zcu.LazySrcLoc;	10	const LazySrcLoc = Zcu.LazySrcLoc;
11		11
12	/// Write human-readable, debug formatted ZIR code to a file.	12	/// Write human-readable, debug formatted ZIR code.
13	pub fn renderAsTextToFile(	13	pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.io.BufferedWriter) anyerror!void {
14	gpa: Allocator,
15	tree: ?Ast,
16	zir: Zir,
17	fs_file: std.fs.File,
18	) !void {
19	var arena = std.heap.ArenaAllocator.init(gpa);	14	var arena = std.heap.ArenaAllocator.init(gpa);
20	defer arena.deinit();	15	defer arena.deinit();
21		16
...	@@ -30,16 +25,13 @@ pub fn renderAsTextToFile(	...	@@ -30,16 +25,13 @@ pub fn renderAsTextToFile(
30	.recurse_blocks = true,	25	.recurse_blocks = true,
31	};	26	};
32		27
33	var raw_stream = std.io.bufferedWriter(fs_file.writer());
34	const stream = raw_stream.writer();
35
36	const main_struct_inst: Zir.Inst.Index = .main_struct_inst;	28	const main_struct_inst: Zir.Inst.Index = .main_struct_inst;
37	try stream.print("%{d} ", .{@intFromEnum(main_struct_inst)});	29	try bw.print("%{d} ", .{@intFromEnum(main_struct_inst)});
38	try writer.writeInstToStream(stream, main_struct_inst);	30	try writer.writeInstToStream(bw, main_struct_inst);
39	try stream.writeAll("\n");	31	try bw.writeAll("\n");
40	const imports_index = zir.extra[@intFromEnum(Zir.ExtraIndex.imports)];	32	const imports_index = zir.extra[@intFromEnum(Zir.ExtraIndex.imports)];
41	if (imports_index != 0) {	33	if (imports_index != 0) {
42	try stream.writeAll("Imports:\n");	34	try bw.writeAll("Imports:\n");
43		35
44	const extra = zir.extraData(Zir.Inst.Imports, imports_index);	36	const extra = zir.extraData(Zir.Inst.Imports, imports_index);
45	var extra_index = extra.end;	37	var extra_index = extra.end;
...	@@ -49,15 +41,13 @@ pub fn renderAsTextToFile(	...	@@ -49,15 +41,13 @@ pub fn renderAsTextToFile(
49	extra_index = item.end;	41	extra_index = item.end;
50		42
51	const import_path = zir.nullTerminatedString(item.data.name);	43	const import_path = zir.nullTerminatedString(item.data.name);
52	try stream.print(" @import(\"{}\") ", .{	44	try bw.print(" @import(\"{}\") ", .{
53	std.zig.fmtEscapes(import_path),	45	std.zig.fmtEscapes(import_path),
54	});	46	});
55	try writer.writeSrcTokAbs(stream, item.data.token);	47	try writer.writeSrcTokAbs(bw, item.data.token);
56	try stream.writeAll("\n");	48	try bw.writeAll("\n");