authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-26 22:31:28-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-28 18:30:57-07:00
log5d7507214d5695842235cf0ad83849c5a2c97664
treec3a95ca503e1dda902955447c4d7a757dd48b62b
parent2151b10a41aff2b81dbbadf8f823d21d7b80f43b

aro: update to not use GenericWriter

9 files changed, 181 insertions(+), 103 deletions(-)

lib/compiler/aro/aro/Attribute.zig+1-1
......@@ -780,7 +780,7 @@ fn ignoredAttrErr(p: *Parser, tok: TokenIndex, attr: Attribute.Tag, context: []c
780780 const strings_top = p.strings.items.len;
781781 defer p.strings.items.len = strings_top;
782782
783 try p.strings.writer().print("attribute '{s}' ignored on {s}", .{ @tagName(attr), context });
783 try p.strings.print("attribute '{s}' ignored on {s}", .{ @tagName(attr), context });
784784 const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
785785 try p.errStr(.ignored_attribute, tok, str);
786786}
lib/compiler/aro/aro/Builtins/Builtin.zig+2-3
......@@ -119,8 +119,7 @@ pub fn nameFromUniqueIndex(index: u16, buf: []u8) []u8 {
119119
120120 var node_index: u16 = 0;
121121 var count: u16 = index;
122 var fbs = std.io.fixedBufferStream(buf);
123 const w = fbs.writer();
122 var w: std.Io.Writer = .fixed(buf);
124123
125124 while (true) {
126125 var sibling_index = dafsa[node_index].child_index;
......@@ -142,7 +141,7 @@ pub fn nameFromUniqueIndex(index: u16, buf: []u8) []u8 {
142141 if (count == 0) break;
143142 }
144143
145 return fbs.getWritten();
144 return w.buffered();
146145}
147146
148147/// We're 1 bit shy of being able to fit this in a u32:
lib/compiler/aro/aro/Compilation.zig+29-26
......@@ -16,6 +16,7 @@ const Pragma = @import("Pragma.zig");
1616const StrInt = @import("StringInterner.zig");
1717const record_layout = @import("record_layout.zig");
1818const target_util = @import("target.zig");
19const Writer = std.Io.Writer;
1920
2021pub const Error = error{
2122 /// A fatal error has ocurred and compilation has stopped.
......@@ -199,7 +200,7 @@ fn getTimestamp(comp: *Compilation) !u47 {
199200 return @intCast(std.math.clamp(timestamp, 0, max_timestamp));
200201}
201202
202fn generateDateAndTime(w: anytype, timestamp: u47) !void {
203fn generateDateAndTime(w: *Writer, timestamp: u47) !void {
203204 const epoch_seconds = EpochSeconds{ .secs = timestamp };
204205 const epoch_day = epoch_seconds.getEpochDay();
205206 const day_seconds = epoch_seconds.getDaySeconds();
......@@ -242,7 +243,7 @@ pub const SystemDefinesMode = enum {
242243 include_system_defines,
243244};
244245
245fn generateSystemDefines(comp: *Compilation, w: anytype) !void {
246fn generateSystemDefines(comp: *Compilation, w: *Writer) !void {
246247 const ptr_width = comp.target.ptrBitWidth();
247248
248249 if (comp.langopts.gnuc_version > 0) {
......@@ -533,11 +534,13 @@ fn generateSystemDefines(comp: *Compilation, w: anytype) !void {
533534pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefinesMode) !Source {
534535 try comp.generateBuiltinTypes();
535536
536 var buf = std.array_list.Managed(u8).init(comp.gpa);
537 defer buf.deinit();
537 var allocating: std.Io.Writer.Allocating = .init(comp.gpa);
538 defer allocating.deinit();
539
540 const buf = &allocating.writer;
538541
539542 if (system_defines_mode == .include_system_defines) {
540 try buf.appendSlice(
543 try buf.writeAll(
541544 \\#define __VERSION__ "Aro
542545 ++ " " ++ @import("../backend.zig").version_str ++ "\"\n" ++
543546 \\#define __Aro__
......@@ -545,11 +548,11 @@ pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefi
545548 );
546549 }
547550
548 try buf.appendSlice("#define __STDC__ 1\n");
551 try buf.writeAll("#define __STDC__ 1\n");
549552 try buf.print("#define __STDC_HOSTED__ {d}\n", .{@intFromBool(comp.target.os.tag != .freestanding)});
550553
551554 // standard macros
552 try buf.appendSlice(
555 try buf.writeAll(
553556 \\#define __STDC_NO_COMPLEX__ 1
554557 \\#define __STDC_NO_THREADS__ 1
555558 \\#define __STDC_NO_VLA__ 1
......@@ -561,23 +564,23 @@ pub fn generateBuiltinMacros(comp: *Compilation, system_defines_mode: SystemDefi
561564 \\
562565 );
563566 if (comp.langopts.standard.StdCVersionMacro()) |stdc_version| {
564 try buf.appendSlice("#define __STDC_VERSION__ ");
565 try buf.appendSlice(stdc_version);
566 try buf.append('\n');
567 try buf.writeAll("#define __STDC_VERSION__ ");
568 try buf.writeAll(stdc_version);
569 try buf.writeByte('\n');
567570 }
568571
569572 // timestamps
570573 const timestamp = try comp.getTimestamp();
571 try generateDateAndTime(buf.writer(), timestamp);
574 try generateDateAndTime(buf, timestamp);
572575
573576 if (system_defines_mode == .include_system_defines) {
574 try comp.generateSystemDefines(buf.writer());
577 try comp.generateSystemDefines(buf);
575578 }
576579
577 return comp.addSourceFromBuffer("<builtin>", buf.items);
580 return comp.addSourceFromBuffer("<builtin>", allocating.written());
578581}
579582
580fn generateFloatMacros(w: anytype, prefix: []const u8, semantics: target_util.FPSemantics, ext: []const u8) !void {
583fn generateFloatMacros(w: *Writer, prefix: []const u8, semantics: target_util.FPSemantics, ext: []const u8) !void {
581584 const denormMin = semantics.chooseValue(
582585 []const u8,
583586 .{
......@@ -656,7 +659,7 @@ fn generateFloatMacros(w: anytype, prefix: []const u8, semantics: target_util.FP
656659 try w.print("#define {s}MIN__ {s}{s}\n", .{ prefix_slice, min, ext });
657660}
658661
659fn generateTypeMacro(w: anytype, mapper: StrInt.TypeMapper, name: []const u8, ty: Type, langopts: LangOpts) !void {
662fn generateTypeMacro(w: *Writer, mapper: StrInt.TypeMapper, name: []const u8, ty: Type, langopts: LangOpts) !void {
660663 try w.print("#define {s} ", .{name});
661664 try ty.print(mapper, langopts, w);
662665 try w.writeByte('\n');
......@@ -762,7 +765,7 @@ fn generateFastOrLeastType(
762765 bits: usize,
763766 kind: enum { least, fast },
764767 signedness: std.builtin.Signedness,
765 w: anytype,
768 w: *Writer,
766769 mapper: StrInt.TypeMapper,
767770) !void {
768771 const ty = comp.intLeastN(bits, signedness); // defining the fast types as the least types is permitted
......@@ -793,7 +796,7 @@ fn generateFastOrLeastType(
793796 try comp.generateFmt(prefix, w, ty);
794797}
795798
796fn generateFastAndLeastWidthTypes(comp: *Compilation, w: anytype, mapper: StrInt.TypeMapper) !void {
799fn generateFastAndLeastWidthTypes(comp: *Compilation, w: *Writer, mapper: StrInt.TypeMapper) !void {
797800 const sizes = [_]usize{ 8, 16, 32, 64 };
798801 for (sizes) |size| {
799802 try comp.generateFastOrLeastType(size, .least, .signed, w, mapper);
......@@ -803,7 +806,7 @@ fn generateFastAndLeastWidthTypes(comp: *Compilation, w: anytype, mapper: StrInt
803806 }
804807}
805808
806fn generateExactWidthTypes(comp: *const Compilation, w: anytype, mapper: StrInt.TypeMapper) !void {
809fn generateExactWidthTypes(comp: *const Compilation, w: *Writer, mapper: StrInt.TypeMapper) !void {
807810 try comp.generateExactWidthType(w, mapper, .schar);
808811
809812 if (comp.intSize(.short) > comp.intSize(.char)) {
......@@ -851,7 +854,7 @@ fn generateExactWidthTypes(comp: *const Compilation, w: anytype, mapper: StrInt.
851854 }
852855}
853856
854fn generateFmt(comp: *const Compilation, prefix: []const u8, w: anytype, ty: Type) !void {
857fn generateFmt(comp: *const Compilation, prefix: []const u8, w: *Writer, ty: Type) !void {
855858 const unsigned = ty.isUnsignedInt(comp);
856859 const modifier = ty.formatModifier();
857860 const formats = if (unsigned) "ouxX" else "di";
......@@ -860,7 +863,7 @@ fn generateFmt(comp: *const Compilation, prefix: []const u8, w: anytype, ty: Typ
860863 }
861864}
862865
863fn generateSuffixMacro(comp: *const Compilation, prefix: []const u8, w: anytype, ty: Type) !void {
866fn generateSuffixMacro(comp: *const Compilation, prefix: []const u8, w: *Writer, ty: Type) !void {
864867 return w.print("#define {s}_C_SUFFIX__ {s}\n", .{ prefix, ty.intValueSuffix(comp) });
865868}
866869
......@@ -868,7 +871,7 @@ fn generateSuffixMacro(comp: *const Compilation, prefix: []const u8, w: anytype,
868871/// Name macro (e.g. #define __UINT32_TYPE__ unsigned int)
869872/// Format strings (e.g. #define __UINT32_FMTu__ "u")
870873/// Suffix macro (e.g. #define __UINT32_C_SUFFIX__ U)
871fn generateExactWidthType(comp: *const Compilation, w: anytype, mapper: StrInt.TypeMapper, specifier: Type.Specifier) !void {
874fn generateExactWidthType(comp: *const Compilation, w: *Writer, mapper: StrInt.TypeMapper, specifier: Type.Specifier) !void {
872875 var ty = Type{ .specifier = specifier };
873876 const width = 8 * ty.sizeof(comp).?;
874877 const unsigned = ty.isUnsignedInt(comp);
......@@ -998,7 +1001,7 @@ fn generateVaListType(comp: *Compilation) !Type {
9981001 return ty;
9991002}
10001003
1001fn generateIntMax(comp: *const Compilation, w: anytype, name: []const u8, ty: Type) !void {
1004fn generateIntMax(comp: *const Compilation, w: *Writer, name: []const u8, ty: Type) !void {
10021005 const bit_count: u8 = @intCast(ty.sizeof(comp).? * 8);
10031006 const unsigned = ty.isUnsignedInt(comp);
10041007 const max: u128 = switch (bit_count) {
......@@ -1023,7 +1026,7 @@ pub fn wcharMax(comp: *const Compilation) u32 {
10231026 };
10241027}
10251028
1026fn generateExactWidthIntMax(comp: *const Compilation, w: anytype, specifier: Type.Specifier) !void {
1029fn generateExactWidthIntMax(comp: *const Compilation, w: *Writer, specifier: Type.Specifier) !void {
10271030 var ty = Type{ .specifier = specifier };
10281031 const bit_count: u8 = @intCast(ty.sizeof(comp).? * 8);
10291032 const unsigned = ty.isUnsignedInt(comp);
......@@ -1040,16 +1043,16 @@ fn generateExactWidthIntMax(comp: *const Compilation, w: anytype, specifier: Typ
10401043 return comp.generateIntMax(w, name, ty);
10411044}
10421045
1043fn generateIntWidth(comp: *Compilation, w: anytype, name: []const u8, ty: Type) !void {
1046fn generateIntWidth(comp: *Compilation, w: *Writer, name: []const u8, ty: Type) !void {
10441047 try w.print("#define __{s}_WIDTH__ {d}\n", .{ name, 8 * ty.sizeof(comp).? });
10451048}
10461049
1047fn generateIntMaxAndWidth(comp: *Compilation, w: anytype, name: []const u8, ty: Type) !void {
1050fn generateIntMaxAndWidth(comp: *Compilation, w: *Writer, name: []const u8, ty: Type) !void {
10481051 try comp.generateIntMax(w, name, ty);
10491052 try comp.generateIntWidth(w, name, ty);
10501053}
10511054
1052fn generateSizeofType(comp: *Compilation, w: anytype, name: []const u8, ty: Type) !void {
1055fn generateSizeofType(comp: *Compilation, w: *Writer, name: []const u8, ty: Type) !void {
10531056 try w.print("#define {s} {d}\n", .{ name, ty.sizeof(comp).? });
10541057}
10551058
lib/compiler/aro/aro/Parser.zig+120-44
......@@ -101,7 +101,7 @@ value_map: Tree.ValueMap,
101101
102102// buffers used during compilation
103103syms: SymbolStack = .{},
104strings: std.array_list.AlignedManaged(u8, .@"4"),
104strings: std.array_list.Managed(u8),
105105labels: std.array_list.Managed(Label),
106106list_buf: NodeList,
107107decl_buf: NodeList,
......@@ -447,7 +447,17 @@ pub fn typeStr(p: *Parser, ty: Type) ![]const u8 {
447447 defer p.strings.items.len = strings_top;
448448
449449 const mapper = p.comp.string_interner.getSlowTypeMapper();
450 try ty.print(mapper, p.comp.langopts, p.strings.writer());
450 {
451 var unmanaged = p.strings.moveToUnmanaged();
452 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
453 defer {
454 unmanaged = allocating.toArrayList();
455 p.strings = unmanaged.toManaged(p.comp.gpa);
456 }
457 ty.print(mapper, p.comp.langopts, &allocating.writer) catch |e| switch (e) {
458 error.WriteFailed => return error.OutOfMemory,
459 };
460 }
451461 return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
452462}
453463
......@@ -455,7 +465,7 @@ pub fn typePairStr(p: *Parser, a: Type, b: Type) ![]const u8 {
455465 return p.typePairStrExtra(a, " and ", b);
456466}
457467
458pub fn typePairStrExtra(p: *Parser, a: Type, msg: []const u8, b: Type) ![]const u8 {
468pub fn typePairStrExtra(p: *Parser, a: Type, msg: []const u8, b: Type) Error![]const u8 {
459469 if (@import("builtin").mode != .Debug) {
460470 if (a.is(.invalid) or b.is(.invalid)) {
461471 return "Tried to render invalid type - this is an aro bug.";
......@@ -466,29 +476,60 @@ pub fn typePairStrExtra(p: *Parser, a: Type, msg: []const u8, b: Type) ![]const
466476
467477 try p.strings.append('\'');
468478 const mapper = p.comp.string_interner.getSlowTypeMapper();
469 try a.print(mapper, p.comp.langopts, p.strings.writer());
479 {
480 var unmanaged = p.strings.moveToUnmanaged();
481 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
482 defer {
483 unmanaged = allocating.toArrayList();
484 p.strings = unmanaged.toManaged(p.comp.gpa);
485 }
486 a.print(mapper, p.comp.langopts, &allocating.writer) catch |e| switch (e) {
487 error.WriteFailed => return error.OutOfMemory,
488 };
489 }
470490 try p.strings.append('\'');
471491 try p.strings.appendSlice(msg);
472492 try p.strings.append('\'');
473 try b.print(mapper, p.comp.langopts, p.strings.writer());
493 {
494 var unmanaged = p.strings.moveToUnmanaged();
495 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
496 defer {
497 unmanaged = allocating.toArrayList();
498 p.strings = unmanaged.toManaged(p.comp.gpa);
499 }
500 b.print(mapper, p.comp.langopts, &allocating.writer) catch |e| switch (e) {
501 error.WriteFailed => return error.OutOfMemory,
502 };
503 }
474504 try p.strings.append('\'');
475505 return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
476506}
477507
478pub fn valueChangedStr(p: *Parser, res: *Result, old_value: Value, int_ty: Type) ![]const u8 {
508pub fn valueChangedStr(p: *Parser, res: *Result, old_value: Value, int_ty: Type) Error![]const u8 {
479509 const strings_top = p.strings.items.len;
480510 defer p.strings.items.len = strings_top;
481511
482 var w = p.strings.writer();
483512 const type_pair_str = try p.typePairStrExtra(res.ty, " to ", int_ty);
484 try w.writeAll(type_pair_str);
513 {
514 var unmanaged = p.strings.moveToUnmanaged();
515 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
516 defer {
517 unmanaged = allocating.toArrayList();
518 p.strings = unmanaged.toManaged(p.comp.gpa);
519 }
520 allocating.writer.writeAll(type_pair_str) catch return error.OutOfMemory;
485521
486 try w.writeAll(" changes ");
487 if (res.val.isZero(p.comp)) try w.writeAll("non-zero ");
488 try w.writeAll("value from ");
489 try old_value.print(res.ty, p.comp, w);
490 try w.writeAll(" to ");
491 try res.val.print(int_ty, p.comp, w);
522 allocating.writer.writeAll(" changes ") catch return error.OutOfMemory;
523 if (res.val.isZero(p.comp)) allocating.writer.writeAll("non-zero ") catch return error.OutOfMemory;
524 allocating.writer.writeAll("value from ") catch return error.OutOfMemory;
525 old_value.print(res.ty, p.comp, &allocating.writer) catch |e| switch (e) {
526 error.WriteFailed => return error.OutOfMemory,
527 };
528 allocating.writer.writeAll(" to ") catch return error.OutOfMemory;
529 res.val.print(int_ty, p.comp, &allocating.writer) catch |e| switch (e) {
530 error.WriteFailed => return error.OutOfMemory,
531 };
532 }
492533
493534 return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
494535}
......@@ -498,9 +539,8 @@ fn checkDeprecatedUnavailable(p: *Parser, ty: Type, usage_tok: TokenIndex, decl_
498539 const strings_top = p.strings.items.len;
499540 defer p.strings.items.len = strings_top;
500541
501 const w = p.strings.writer();
502542 const msg_str = p.comp.interner.get(@"error".msg.ref()).bytes;
503 try w.print("call to '{s}' declared with attribute error: {f}", .{
543 try p.strings.print("call to '{s}' declared with attribute error: {f}", .{
504544 p.tokSlice(@"error".__name_tok), std.zig.fmtString(msg_str),
505545 });
506546 const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
......@@ -510,9 +550,8 @@ fn checkDeprecatedUnavailable(p: *Parser, ty: Type, usage_tok: TokenIndex, decl_
510550 const strings_top = p.strings.items.len;
511551 defer p.strings.items.len = strings_top;
512552
513 const w = p.strings.writer();
514553 const msg_str = p.comp.interner.get(warning.msg.ref()).bytes;
515 try w.print("call to '{s}' declared with attribute warning: {f}", .{
554 try p.strings.print("call to '{s}' declared with attribute warning: {f}", .{
516555 p.tokSlice(warning.__name_tok), std.zig.fmtString(msg_str),
517556 });
518557 const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
......@@ -532,17 +571,16 @@ fn errDeprecated(p: *Parser, tag: Diagnostics.Tag, tok_i: TokenIndex, msg: ?Valu
532571 const strings_top = p.strings.items.len;
533572 defer p.strings.items.len = strings_top;
534573
535 const w = p.strings.writer();
536 try w.print("'{s}' is ", .{p.tokSlice(tok_i)});
574 try p.strings.print("'{s}' is ", .{p.tokSlice(tok_i)});
537575 const reason: []const u8 = switch (tag) {
538576 .unavailable => "unavailable",
539577 .deprecated_declarations => "deprecated",
540578 else => unreachable,
541579 };
542 try w.writeAll(reason);
580 try p.strings.appendSlice(reason);
543581 if (msg) |m| {
544582 const str = p.comp.interner.get(m.ref()).bytes;
545 try w.print(": {f}", .{std.zig.fmtString(str)});
583 try p.strings.print(": {f}", .{std.zig.fmtString(str)});
546584 }
547585 const str = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
548586 return p.errStr(tag, tok_i, str);
......@@ -693,7 +731,7 @@ pub fn parse(pp: *Preprocessor) Compilation.Error!Tree {
693731 .gpa = pp.comp.gpa,
694732 .arena = arena.allocator(),
695733 .tok_ids = pp.tokens.items(.id),
696 .strings = std.array_list.AlignedManaged(u8, .@"4").init(pp.comp.gpa),
734 .strings = std.array_list.Managed(u8).init(pp.comp.gpa),
697735 .value_map = Tree.ValueMap.init(pp.comp.gpa),
698736 .data = NodeList.init(pp.comp.gpa),
699737 .labels = std.array_list.Managed(Label).init(pp.comp.gpa),
......@@ -1218,38 +1256,46 @@ fn decl(p: *Parser) Error!bool {
12181256 return true;
12191257}
12201258
1221fn staticAssertMessage(p: *Parser, cond_node: NodeIndex, message: Result) !?[]const u8 {
1259fn staticAssertMessage(p: *Parser, cond_node: NodeIndex, message: Result) Error!?[]const u8 {
12221260 const cond_tag = p.nodes.items(.tag)[@intFromEnum(cond_node)];
12231261 if (cond_tag != .builtin_types_compatible_p and message.node == .none) return null;
12241262
1225 var buf = std.array_list.Managed(u8).init(p.gpa);
1226 defer buf.deinit();
1263 var allocating: std.Io.Writer.Allocating = .init(p.gpa);
1264 defer allocating.deinit();
1265
1266 const buf = &allocating.writer;
12271267
12281268 if (cond_tag == .builtin_types_compatible_p) {
12291269 const mapper = p.comp.string_interner.getSlowTypeMapper();
12301270 const data = p.nodes.items(.data)[@intFromEnum(cond_node)].bin;
12311271
1232 try buf.appendSlice("'__builtin_types_compatible_p(");
1272 buf.writeAll("'__builtin_types_compatible_p(") catch return error.OutOfMemory;
12331273
12341274 const lhs_ty = p.nodes.items(.ty)[@intFromEnum(data.lhs)];
1235 try lhs_ty.print(mapper, p.comp.langopts, buf.writer());
1236 try buf.appendSlice(", ");
1275 lhs_ty.print(mapper, p.comp.langopts, buf) catch |e| switch (e) {
1276 error.WriteFailed => return error.OutOfMemory,
1277 };
1278 buf.writeAll(", ") catch return error.OutOfMemory;
12371279
12381280 const rhs_ty = p.nodes.items(.ty)[@intFromEnum(data.rhs)];
1239 try rhs_ty.print(mapper, p.comp.langopts, buf.writer());
1281 rhs_ty.print(mapper, p.comp.langopts, buf) catch |e| switch (e) {
1282 error.WriteFailed => return error.OutOfMemory,
1283 };
12401284
1241 try buf.appendSlice(")'");
1285 buf.writeAll(")'") catch return error.OutOfMemory;
12421286 }
12431287 if (message.node != .none) {
12441288 assert(p.nodes.items(.tag)[@intFromEnum(message.node)] == .string_literal_expr);
1245 if (buf.items.len > 0) {
1246 try buf.append(' ');
1289 if (buf.buffered().len > 0) {
1290 buf.writeByte(' ') catch return error.OutOfMemory;
12471291 }
12481292 const bytes = p.comp.interner.get(message.val.ref()).bytes;
1249 try buf.ensureUnusedCapacity(bytes.len);
1250 try Value.printString(bytes, message.ty, p.comp, buf.writer());
1293 try allocating.ensureUnusedCapacity(bytes.len);
1294 Value.printString(bytes, message.ty, p.comp, buf) catch |e| switch (e) {
1295 error.WriteFailed => return error.OutOfMemory,
1296 };
12511297 }
1252 return try p.comp.diagnostics.arena.allocator().dupe(u8, buf.items);
1298 return try p.comp.diagnostics.arena.allocator().dupe(u8, allocating.written());
12531299}
12541300
12551301/// staticAssert
......@@ -4981,7 +5027,7 @@ const CallExpr = union(enum) {
49815027 return true;
49825028 }
49835029
4984 fn checkVarArg(self: CallExpr, p: *Parser, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, arg_idx: u32) !void {
5030 fn checkVarArg(self: CallExpr, p: *Parser, first_after: TokenIndex, param_tok: TokenIndex, arg: *Result, arg_idx: u32) Error!void {
49855031 if (self == .standard) return;
49865032
49875033 const builtin_tok = p.nodes.items(.data)[@intFromEnum(self.builtin.node)].decl.name;
......@@ -5183,7 +5229,17 @@ pub const Result = struct {
51835229 const strings_top = p.strings.items.len;
51845230 defer p.strings.items.len = strings_top;
51855231
5186 try res.val.print(res.ty, p.comp, p.strings.writer());
5232 {
5233 var unmanaged = p.strings.moveToUnmanaged();
5234 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
5235 defer {
5236 unmanaged = allocating.toArrayList();
5237 p.strings = unmanaged.toManaged(p.comp.gpa);
5238 }
5239 res.val.print(res.ty, p.comp, &allocating.writer) catch |e| switch (e) {
5240 error.WriteFailed => return error.OutOfMemory,
5241 };
5242 }
51875243 return try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items[strings_top..]);
51885244 }
51895245
......@@ -5347,7 +5403,7 @@ pub const Result = struct {
53475403 conditional,
53485404 add,
53495405 sub,
5350 }) !bool {
5406 }) Error!bool {
53515407 if (b.ty.specifier == .invalid) {
53525408 try a.saveValue(p);
53535409 a.ty = Type.invalid;
......@@ -5643,7 +5699,7 @@ pub const Result = struct {
56435699 }
56445700 }
56455701
5646 fn floatToIntWarning(res: *Result, p: *Parser, int_ty: Type, old_value: Value, change_kind: Value.FloatToIntChangeKind, tok: TokenIndex) !void {
5702 fn floatToIntWarning(res: *Result, p: *Parser, int_ty: Type, old_value: Value, change_kind: Value.FloatToIntChangeKind, tok: TokenIndex) Error!void {
56475703 switch (change_kind) {
56485704 .none => return p.errStr(.float_to_int, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
56495705 .out_of_range => return p.errStr(.float_out_of_range, tok, try p.typePairStrExtra(res.ty, " to ", int_ty)),
......@@ -5866,7 +5922,7 @@ pub const Result = struct {
58665922 res.val = .{};
58675923 }
58685924
5869 fn castType(res: *Result, p: *Parser, to: Type, operand_tok: TokenIndex, l_paren: TokenIndex) !void {
5925 fn castType(res: *Result, p: *Parser, to: Type, operand_tok: TokenIndex, l_paren: TokenIndex) Error!void {
58705926 var cast_kind: Tree.CastKind = undefined;
58715927
58725928 if (to.is(.void)) {
......@@ -7595,9 +7651,19 @@ fn validateFieldAccess(p: *Parser, record_ty: *const Type.Record, expr_ty: Type,
75957651
75967652 p.strings.items.len = 0;
75977653
7598 try p.strings.writer().print("'{s}' in '", .{p.tokSlice(field_name_tok)});
7654 try p.strings.print("'{s}' in '", .{p.tokSlice(field_name_tok)});
75997655 const mapper = p.comp.string_interner.getSlowTypeMapper();
7600 try expr_ty.print(mapper, p.comp.langopts, p.strings.writer());
7656 {
7657 var unmanaged = p.strings.moveToUnmanaged();
7658 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
7659 defer {
7660 unmanaged = allocating.toArrayList();
7661 p.strings = unmanaged.toManaged(p.comp.gpa);
7662 }
7663 expr_ty.print(mapper, p.comp.langopts, &allocating.writer) catch |e| switch (e) {
7664 error.WriteFailed => return error.OutOfMemory,
7665 };
7666 }
76017667 try p.strings.append('\'');
76027668
76037669 const duped = try p.comp.diagnostics.arena.allocator().dupe(u8, p.strings.items);
......@@ -8016,7 +8082,17 @@ fn primaryExpr(p: *Parser) Error!Result {
80168082 defer p.strings.items.len = strings_top;
80178083
80188084 const mapper = p.comp.string_interner.getSlowTypeMapper();
8019 try Type.printNamed(func_ty, p.tokSlice(p.func.name), mapper, p.comp.langopts, p.strings.writer());
8085 {
8086 var unmanaged = p.strings.moveToUnmanaged();
8087 var allocating: std.Io.Writer.Allocating = .fromArrayList(p.comp.gpa, &unmanaged);
8088 defer {
8089 unmanaged = allocating.toArrayList();
8090 p.strings = unmanaged.toManaged(p.comp.gpa);
8091 }
8092 Type.printNamed(func_ty, p.tokSlice(p.func.name), mapper, p.comp.langopts, &allocating.writer) catch |e| switch (e) {
8093 error.WriteFailed => return error.OutOfMemory,
8094 };
8095 }
80208096 try p.strings.append(0);
80218097 const predef = try p.makePredefinedIdentifier(strings_top);
80228098 ty = predef.ty;
lib/compiler/aro/aro/Preprocessor.zig+12-17
......@@ -15,6 +15,7 @@ const TokenWithExpansionLocs = Tree.TokenWithExpansionLocs;
1515const Attribute = @import("Attribute.zig");
1616const features = @import("features.zig");
1717const Hideset = @import("Hideset.zig");
18const Writer = std.Io.Writer;
1819
1920const DefineMap = std.StringHashMapUnmanaged(Macro);
2021const RawTokenList = std.array_list.Managed(RawToken);
......@@ -982,7 +983,7 @@ fn expr(pp: *Preprocessor, tokenizer: *Tokenizer) MacroError!bool {
982983 .tok_i = @intCast(token_state.tokens_len),
983984 .arena = pp.arena.allocator(),
984985 .in_macro = true,
985 .strings = std.array_list.AlignedManaged(u8, .@"4").init(pp.comp.gpa),
986 .strings = std.array_list.Managed(u8).init(pp.comp.gpa),
986987
987988 .data = undefined,
988989 .value_map = undefined,
......@@ -1193,24 +1194,21 @@ fn expandObjMacro(pp: *Preprocessor, simple_macro: *const Macro) Error!ExpandBuf
11931194 .macro_file => {
11941195 const start = pp.comp.generated_buf.items.len;
11951196 const source = pp.comp.getSource(pp.expansion_source_loc.id);
1196 const w = pp.comp.generated_buf.writer(pp.gpa);
1197 try w.print("\"{s}\"\n", .{source.path});
1197 try pp.comp.generated_buf.print(pp.gpa, "\"{s}\"\n", .{source.path});
11981198
11991199 buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .string_literal, tok));
12001200 },
12011201 .macro_line => {
12021202 const start = pp.comp.generated_buf.items.len;
12031203 const source = pp.comp.getSource(pp.expansion_source_loc.id);
1204 const w = pp.comp.generated_buf.writer(pp.gpa);
1205 try w.print("{d}\n", .{source.physicalLine(pp.expansion_source_loc)});
1204 try pp.comp.generated_buf.print(pp.gpa, "{d}\n", .{source.physicalLine(pp.expansion_source_loc)});
12061205
12071206 buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .pp_num, tok));
12081207 },
12091208 .macro_counter => {
12101209 defer pp.counter += 1;
12111210 const start = pp.comp.generated_buf.items.len;
1212 const w = pp.comp.generated_buf.writer(pp.gpa);
1213 try w.print("{d}\n", .{pp.counter});
1211 try pp.comp.generated_buf.print(pp.gpa, "{d}\n", .{pp.counter});
12141212
12151213 buf.appendAssumeCapacity(try pp.makeGeneratedToken(start, .pp_num, tok));
12161214 },
......@@ -1682,8 +1680,7 @@ fn expandFuncMacro(
16821680 break :blk false;
16831681 } else try pp.handleBuiltinMacro(raw.id, arg, macro_tok.loc);
16841682 const start = pp.comp.generated_buf.items.len;
1685 const w = pp.comp.generated_buf.writer(pp.gpa);
1686 try w.print("{}\n", .{@intFromBool(result)});
1683 try pp.comp.generated_buf.print(pp.gpa, "{}\n", .{@intFromBool(result)});
16871684 try buf.append(try pp.makeGeneratedToken(start, .pp_num, tokFromRaw(raw)));
16881685 },
16891686 .macro_param_has_c_attribute => {
......@@ -2988,18 +2985,16 @@ fn embed(pp: *Preprocessor, tokenizer: *Tokenizer) MacroError!void {
29882985 // TODO: We currently only support systems with CHAR_BIT == 8
29892986 // If the target's CHAR_BIT is not 8, we need to write out correctly-sized embed_bytes
29902987 // and correctly account for the target's endianness
2991 const writer = pp.comp.generated_buf.writer(pp.gpa);
2992
29932988 {
29942989 const byte = embed_bytes[0];
29952990 const start = pp.comp.generated_buf.items.len;
2996 try writer.print("{d}", .{byte});
2991 try pp.comp.generated_buf.print(pp.gpa, "{d}", .{byte});
29972992 pp.addTokenAssumeCapacity(try pp.makeGeneratedToken(start, .embed_byte, filename_tok));
29982993 }
29992994
30002995 for (embed_bytes[1..]) |byte| {
30012996 const start = pp.comp.generated_buf.items.len;
3002 try writer.print(",{d}", .{byte});
2997 try pp.comp.generated_buf.print(pp.gpa, ",{d}", .{byte});
30032998 pp.addTokenAssumeCapacity(.{ .id = .comma, .loc = .{ .id = .generated, .byte_offset = @intCast(start) } });
30042999 pp.addTokenAssumeCapacity(try pp.makeGeneratedToken(start + 1, .embed_byte, filename_tok));
30053000 }
......@@ -3241,7 +3236,7 @@ fn findIncludeSource(pp: *Preprocessor, tokenizer: *Tokenizer, first: RawToken,
32413236
32423237fn printLinemarker(
32433238 pp: *Preprocessor,
3244 w: anytype,
3239 w: *Writer,
32453240 line_no: u32,
32463241 source: Source,
32473242 start_resume: enum(u8) { start, @"resume", none },
......@@ -3301,7 +3296,7 @@ pub const DumpMode = enum {
33013296/// Pretty-print the macro define or undef at location `loc`.
33023297/// We re-tokenize the directive because we are printing a macro that may have the same name as one in
33033298/// `pp.defines` but a different definition (due to being #undef'ed and then redefined)
3304fn prettyPrintMacro(pp: *Preprocessor, w: anytype, loc: Source.Location, parts: enum { name_only, name_and_body }) !void {
3299fn prettyPrintMacro(pp: *Preprocessor, w: *Writer, loc: Source.Location, parts: enum { name_only, name_and_body }) !void {
33053300 const source = pp.comp.getSource(loc.id);
33063301 var tokenizer: Tokenizer = .{
33073302 .buf = source.buf,
......@@ -3339,7 +3334,7 @@ fn prettyPrintMacro(pp: *Preprocessor, w: anytype, loc: Source.Location, parts:
33393334 }
33403335}
33413336
3342fn prettyPrintMacrosOnly(pp: *Preprocessor, w: anytype) !void {
3337fn prettyPrintMacrosOnly(pp: *Preprocessor, w: *Writer) !void {
33433338 var it = pp.defines.valueIterator();
33443339 while (it.next()) |macro| {
33453340 if (macro.is_builtin) continue;
......@@ -3351,7 +3346,7 @@ fn prettyPrintMacrosOnly(pp: *Preprocessor, w: anytype) !void {
33513346}
33523347
33533348/// Pretty print tokens and try to preserve whitespace.
3354pub fn prettyPrintTokens(pp: *Preprocessor, w: anytype, macro_dump_mode: DumpMode) !void {
3349pub fn prettyPrintTokens(pp: *Preprocessor, w: *Writer, macro_dump_mode: DumpMode) !void {
33553350 if (macro_dump_mode == .macros_only) {
33563351 return pp.prettyPrintMacrosOnly(w);
33573352 }
lib/compiler/aro/aro/Type.zig+9-8
......@@ -9,6 +9,7 @@ const StringInterner = @import("StringInterner.zig");
99const StringId = StringInterner.StringId;
1010const target_util = @import("target.zig");
1111const LangOpts = @import("LangOpts.zig");
12const Writer = std.Io.Writer;
1213
1314pub const Qualifiers = packed struct {
1415 @"const": bool = false,
......@@ -23,7 +24,7 @@ pub const Qualifiers = packed struct {
2324 return quals.@"const" or quals.restrict or quals.@"volatile" or quals.atomic;
2425 }
2526
26 pub fn dump(quals: Qualifiers, w: anytype) !void {
27 pub fn dump(quals: Qualifiers, w: *Writer) !void {
2728 if (quals.@"const") try w.writeAll("const ");
2829 if (quals.atomic) try w.writeAll("_Atomic ");
2930 if (quals.@"volatile") try w.writeAll("volatile ");
......@@ -2411,12 +2412,12 @@ pub fn intValueSuffix(ty: Type, comp: *const Compilation) []const u8 {
24112412}
24122413
24132414/// Print type in C style
2414pub fn print(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: anytype) @TypeOf(w).Error!void {
2415pub fn print(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: *Writer) Writer.Error!void {
24152416 _ = try ty.printPrologue(mapper, langopts, w);
24162417 try ty.printEpilogue(mapper, langopts, w);
24172418}
24182419
2419pub fn printNamed(ty: Type, name: []const u8, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: anytype) @TypeOf(w).Error!void {
2420pub fn printNamed(ty: Type, name: []const u8, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: *Writer) Writer.Error!void {
24202421 const simple = try ty.printPrologue(mapper, langopts, w);
24212422 if (simple) try w.writeByte(' ');
24222423 try w.writeAll(name);
......@@ -2426,7 +2427,7 @@ pub fn printNamed(ty: Type, name: []const u8, mapper: StringInterner.TypeMapper,
24262427const StringGetter = fn (TokenIndex) []const u8;
24272428
24282429/// return true if `ty` is simple
2429fn printPrologue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: anytype) @TypeOf(w).Error!bool {
2430fn printPrologue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: *Writer) Writer.Error!bool {
24302431 if (ty.qual.atomic) {
24312432 var non_atomic_ty = ty;
24322433 non_atomic_ty.qual.atomic = false;
......@@ -2497,7 +2498,7 @@ fn printPrologue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts
24972498 return true;
24982499}
24992500
2500fn printEpilogue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: anytype) @TypeOf(w).Error!void {
2501fn printEpilogue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: *Writer) Writer.Error!void {
25012502 if (ty.qual.atomic) return;
25022503 if (ty.isPtr()) {
25032504 const elem_ty = ty.elemType();
......@@ -2564,7 +2565,7 @@ fn printEpilogue(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts
25642565const dump_detailed_containers = false;
25652566
25662567// Print as Zig types since those are actually readable
2567pub fn dump(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: anytype) @TypeOf(w).Error!void {
2568pub fn dump(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: *Writer) Writer.Error!void {
25682569 try ty.qual.dump(w);
25692570 switch (ty.specifier) {
25702571 .invalid => try w.writeAll("invalid"),
......@@ -2656,7 +2657,7 @@ pub fn dump(ty: Type, mapper: StringInterner.TypeMapper, langopts: LangOpts, w:
26562657 }
26572658}
26582659
2659fn dumpEnum(@"enum": *Enum, mapper: StringInterner.TypeMapper, w: anytype) @TypeOf(w).Error!void {
2660fn dumpEnum(@"enum": *Enum, mapper: StringInterner.TypeMapper, w: *Writer) Writer.Error!void {
26602661 try w.writeAll(" {");
26612662 for (@"enum".fields) |field| {
26622663 try w.print(" {s} = {d},", .{ mapper.lookup(field.name), field.value });
......@@ -2664,7 +2665,7 @@ fn dumpEnum(@"enum": *Enum, mapper: StringInterner.TypeMapper, w: anytype) @Type
26642665 try w.writeAll(" }");
26652666}
26662667
2667fn dumpRecord(record: *Record, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: anytype) @TypeOf(w).Error!void {
2668fn dumpRecord(record: *Record, mapper: StringInterner.TypeMapper, langopts: LangOpts, w: *Writer) Writer.Error!void {
26682669 try w.writeAll(" {");
26692670 for (record.fields) |field| {
26702671 try w.writeByte(' ');
lib/compiler/aro/aro/Value.zig+3-2
......@@ -9,6 +9,7 @@ const Compilation = @import("Compilation.zig");
99const Type = @import("Type.zig");
1010const target_util = @import("target.zig");
1111const annex_g = @import("annex_g.zig");
12const Writer = std.Io.Writer;
1213
1314const Value = @This();
1415
......@@ -953,7 +954,7 @@ pub fn maxInt(ty: Type, comp: *Compilation) !Value {
953954 return twosCompIntLimit(.max, ty, comp);
954955}
955956
956pub fn print(v: Value, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w).Error!void {
957pub fn print(v: Value, ty: Type, comp: *const Compilation, w: *Writer) Writer.Error!void {
957958 if (ty.is(.bool)) {
958959 return w.writeAll(if (v.isZero(comp)) "false" else "true");
959960 }
......@@ -977,7 +978,7 @@ pub fn print(v: Value, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w
977978 }
978979}
979980
980pub fn printString(bytes: []const u8, ty: Type, comp: *const Compilation, w: anytype) @TypeOf(w).Error!void {
981pub fn printString(bytes: []const u8, ty: Type, comp: *const Compilation, w: *Writer) Writer.Error!void {
981982 const size: Compilation.CharUnitSize = @enumFromInt(ty.elemType().sizeof(comp).?);
982983 const without_null = bytes[0 .. bytes.len - @intFromEnum(size)];
983984 try w.writeByte('"');
lib/compiler/aro_translate_c/ast.zig+1-1
......@@ -832,7 +832,7 @@ const Context = struct {
832832
833833 fn addTokenFmt(c: *Context, tag: TokenTag, comptime format: []const u8, args: anytype) Allocator.Error!TokenIndex {
834834 const start_index = c.buf.items.len;
835 try c.buf.writer().print(format ++ " ", args);
835 try c.buf.print(format ++ " ", args);
836836
837837 try c.tokens.append(c.gpa, .{
838838 .tag = tag,
src/libs/mingw.zig+4-1
......@@ -334,7 +334,10 @@ pub fn buildImportLib(comp: *Compilation, lib_name: []const u8) !void {
334334 // new scope to ensure definition file is written before passing the path to WriteImportLibrary
335335 const def_final_file = try o_dir.createFile(final_def_basename, .{ .truncate = true });
336336 defer def_final_file.close();
337 try pp.prettyPrintTokens(def_final_file.deprecatedWriter(), .result_only);
337 var buffer: [1024]u8 = undefined;
338 var def_final_file_writer = def_final_file.writer(&buffer);
339 try pp.prettyPrintTokens(&def_final_file_writer.interface, .result_only);
340 try def_final_file_writer.interface.flush();
338341 }
339342
340343 const lib_final_path = try std.fs.path.join(gpa, &.{ "o", &digest, final_lib_basename });