authorgravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2025-08-13 09:33:02+02:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-13 01:43:52-07:00
logb8124d9c0b01e8ac7cd0daf93a0ed018da5f2352
tree37ff66d809c8817ebd60871c4c296a269032b60f
parent7abd62800cde3f42c0ef65126ed478a0c3d3d549

std.io.Writer.Allocating: rename getWritten() to written()

This "get" is useless noise and was copied from FixedBufferWriter. Since this API has not yet landed in a release, now is a good time to make the breaking change to fix this.

25 files changed, 202 insertions(+), 202 deletions(-)

lib/docs/wasm/Walk.zig+1-1
......@@ -443,7 +443,7 @@ fn parse(file_name: []const u8, source: []u8) Oom!Ast {
443443 error.WriteFailed => return error.OutOfMemory,
444444 };
445445 log.err("{s}:{d}:{d}: {s}", .{
446 file_name, err_loc.line + 1, err_loc.column + 1, rendered_err.getWritten(),
446 file_name, err_loc.line + 1, err_loc.column + 1, rendered_err.written(),
447447 });
448448 }
449449 return Ast.parse(gpa, "", .zig);
lib/std/Build/Step/ConfigHeader.zig+4-4
......@@ -239,7 +239,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
239239 },
240240 }
241241
242 const output = aw.getWritten();
242 const output = aw.written();
243243 man.hash.addBytes(output);
244244
245245 if (try step.cacheHit(&man)) {
......@@ -347,10 +347,10 @@ fn render_autoconf_at(
347347 while (line_it.next()) |line| : (line_index += 1) {
348348 const last_line = line_it.index == line_it.buffer.len;
349349
350 const old_len = aw.getWritten().len;
350 const old_len = aw.written().len;
351351 expand_variables_autoconf_at(bw, line, values, used) catch |err| switch (err) {
352352 error.MissingValue => {
353 const name = aw.getWritten()[old_len..];
353 const name = aw.written()[old_len..];
354354 defer aw.shrinkRetainingCapacity(old_len);
355355 try step.addError("{s}:{d}: error: unspecified config header value: '{s}'", .{
356356 src_path, line_index + 1, name,
......@@ -763,7 +763,7 @@ fn testReplaceVariablesAutoconfAt(
763763 try expand_variables_autoconf_at(&aw.writer, contents, values, used);
764764
765765 for (used) |u| if (!u) return error.UnusedValue;
766 try std.testing.expectEqualStrings(expected, aw.getWritten());
766 try std.testing.expectEqualStrings(expected, aw.written());
767767}
768768
769769fn testReplaceVariablesCMake(
lib/std/Io/Writer.zig+2-2
......@@ -2557,7 +2557,7 @@ pub const Allocating = struct {
25572557 return list.toOwnedSliceSentinel(gpa, sentinel);
25582558 }
25592559
2560 pub fn getWritten(a: *Allocating) []u8 {
2560 pub fn written(a: *Allocating) []u8 {
25612561 return a.writer.buffered();
25622562 }
25632563
......@@ -2624,7 +2624,7 @@ pub const Allocating = struct {
26242624 const y: i32 = 1234;
26252625 try w.print("x: {}\ny: {}\n", .{ x, y });
26262626
2627 try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", a.getWritten());
2627 try testing.expectEqualSlices(u8, "x: 42\ny: 1234\n", a.written());
26282628 }
26292629};
26302630
lib/std/compress/flate/Decompress.zig+1-1
......@@ -1272,5 +1272,5 @@ fn testDecompress(container: Container, compressed: []const u8, expected_plain:
12721272 var decompress: Decompress = .init(&in, container, &.{});
12731273 const decompressed_len = try decompress.reader.streamRemaining(&aw.writer);
12741274 try testing.expectEqual(expected_plain.len, decompressed_len);
1275 try testing.expectEqualSlices(u8, expected_plain, aw.getWritten());
1275 try testing.expectEqualSlices(u8, expected_plain, aw.written());
12761276}
lib/std/debug.zig+11-11
......@@ -318,7 +318,7 @@ test dumpHexFallible {
318318 @sizeOf(usize) * 2,
319319 });
320320 defer std.testing.allocator.free(expected);
321 try std.testing.expectEqualStrings(expected, aw.getWritten());
321 try std.testing.expectEqualStrings(expected, aw.written());
322322}
323323
324324/// Tries to print the current stack trace to stderr, unbuffered, and ignores any error returned.
......@@ -1258,7 +1258,7 @@ test printLineFromFileAnyOs {
12581258 try expectError(error.EndOfFile, printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 }));
12591259
12601260 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
1261 try expectEqualStrings("no new lines in this file, but one is printed anyway\n", aw.getWritten());
1261 try expectEqualStrings("no new lines in this file, but one is printed anyway\n", aw.written());
12621262 aw.clearRetainingCapacity();
12631263 }
12641264 {
......@@ -1274,11 +1274,11 @@ test printLineFromFileAnyOs {
12741274 });
12751275
12761276 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
1277 try expectEqualStrings("1\n", aw.getWritten());
1277 try expectEqualStrings("1\n", aw.written());
12781278 aw.clearRetainingCapacity();
12791279
12801280 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 3, .column = 0 });
1281 try expectEqualStrings("3\n", aw.getWritten());
1281 try expectEqualStrings("3\n", aw.written());
12821282 aw.clearRetainingCapacity();
12831283 }
12841284 {
......@@ -1297,7 +1297,7 @@ test printLineFromFileAnyOs {
12971297 try writer.flush();
12981298
12991299 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 });
1300 try expectEqualStrings(("a" ** overlap) ++ "\n", aw.getWritten());
1300 try expectEqualStrings(("a" ** overlap) ++ "\n", aw.written());
13011301 aw.clearRetainingCapacity();
13021302 }
13031303 {
......@@ -1311,7 +1311,7 @@ test printLineFromFileAnyOs {
13111311 try writer.splatByteAll('a', std.heap.page_size_max);
13121312
13131313 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
1314 try expectEqualStrings(("a" ** std.heap.page_size_max) ++ "\n", aw.getWritten());
1314 try expectEqualStrings(("a" ** std.heap.page_size_max) ++ "\n", aw.written());
13151315 aw.clearRetainingCapacity();
13161316 }
13171317 {
......@@ -1327,17 +1327,17 @@ test printLineFromFileAnyOs {
13271327 try expectError(error.EndOfFile, printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 }));
13281328
13291329 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
1330 try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "\n", aw.getWritten());
1330 try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "\n", aw.written());
13311331 aw.clearRetainingCapacity();
13321332
13331333 try writer.writeAll("a\na");
13341334
13351335 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 1, .column = 0 });
1336 try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "a\n", aw.getWritten());
1336 try expectEqualStrings(("a" ** (3 * std.heap.page_size_max)) ++ "a\n", aw.written());
13371337 aw.clearRetainingCapacity();
13381338
13391339 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = 2, .column = 0 });
1340 try expectEqualStrings("a\n", aw.getWritten());
1340 try expectEqualStrings("a\n", aw.written());
13411341 aw.clearRetainingCapacity();
13421342 }
13431343 {
......@@ -1353,11 +1353,11 @@ test printLineFromFileAnyOs {
13531353 try writer.writeAll("abc\ndef");
13541354
13551355 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = real_file_start + 1, .column = 0 });
1356 try expectEqualStrings("abc\n", aw.getWritten());
1356 try expectEqualStrings("abc\n", aw.written());
13571357 aw.clearRetainingCapacity();
13581358
13591359 try printLineFromFileAnyOs(output_stream, .{ .file_name = path, .line = real_file_start + 2, .column = 0 });
1360 try expectEqualStrings("def\n", aw.getWritten());
1360 try expectEqualStrings("def\n", aw.written());
13611361 aw.clearRetainingCapacity();
13621362 }
13631363}
lib/std/http/test.zig+1-1
......@@ -1020,7 +1020,7 @@ fn echoTests(client: *http.Client, port: u16) !void {
10201020 .response_writer = &body.writer,
10211021 });
10221022 try expectEqual(.ok, res.status);
1023 try expectEqualStrings("Hello, World!\n", body.getWritten());
1023 try expectEqualStrings("Hello, World!\n", body.written());
10241024 }
10251025
10261026 { // expect: 100-continue
lib/std/json.zig+1-1
......@@ -57,7 +57,7 @@ test Stringify {
5757 \\ "foo": 123
5858 \\}
5959 ;
60 try testing.expectEqualSlices(u8, expected, out.getWritten());
60 try testing.expectEqualSlices(u8, expected, out.written());
6161}
6262
6363pub const ObjectMap = @import("json/dynamic.zig").ObjectMap;
lib/std/json/Stringify.zig+1-1
......@@ -582,7 +582,7 @@ test value {
582582
583583 const T = struct { a: i32, b: []const u8 };
584584 try value(T{ .a = 123, .b = "xy" }, .{}, writer);
585 try std.testing.expectEqualSlices(u8, "{\"a\":123,\"b\":\"xy\"}", out.getWritten());
585 try std.testing.expectEqualSlices(u8, "{\"a\":123,\"b\":\"xy\"}", out.written());
586586
587587 try testStringify("9999999999999999", 9999999999999999, .{});
588588 try testStringify("\"9999999999999999\"", 9999999999999999, .{ .emit_nonportable_numbers_as_strings = true });
lib/std/tar/Writer.zig+4-4
......@@ -403,7 +403,7 @@ test "write files" {
403403 for (files) |file|
404404 try w.writeFileBytes(file.path, file.content, .{});
405405
406 var input: std.Io.Reader = .fixed(output.getWritten());
406 var input: std.Io.Reader = .fixed(output.written());
407407 var it: std.tar.Iterator = .init(&input, .{
408408 .file_name_buffer = &file_name_buffer,
409409 .link_name_buffer = &link_name_buffer,
......@@ -427,7 +427,7 @@ test "write files" {
427427 var content: std.Io.Writer.Allocating = .init(testing.allocator);
428428 defer content.deinit();
429429 try it.streamRemaining(actual, &content.writer);
430 try testing.expectEqualSlices(u8, expected.content, content.getWritten());
430 try testing.expectEqualSlices(u8, expected.content, content.written());
431431 }
432432 }
433433 // without root
......@@ -440,7 +440,7 @@ test "write files" {
440440 try w.writeFileStream(file.path, file.content.len, &content, .{});
441441 }
442442
443 var input: std.Io.Reader = .fixed(output.getWritten());
443 var input: std.Io.Reader = .fixed(output.written());
444444 var it: std.tar.Iterator = .init(&input, .{
445445 .file_name_buffer = &file_name_buffer,
446446 .link_name_buffer = &link_name_buffer,
......@@ -455,7 +455,7 @@ test "write files" {
455455 var content: std.Io.Writer.Allocating = .init(testing.allocator);
456456 defer content.deinit();
457457 try it.streamRemaining(actual, &content.writer);
458 try testing.expectEqualSlices(u8, expected.content, content.getWritten());
458 try testing.expectEqualSlices(u8, expected.content, content.written());
459459 }
460460 try w.finishPedantically();
461461 }
lib/std/tar/test.zig+1-1
......@@ -361,7 +361,7 @@ fn testCase(case: Case) !void {
361361 var aw: std.Io.Writer.Allocating = .init(std.testing.allocator);
362362 defer aw.deinit();
363363 try it.streamRemaining(actual, &aw.writer);
364 const chksum = std.fmt.bytesToHex(std.crypto.hash.Md5.hashResult(aw.getWritten()), .lower);
364 const chksum = std.fmt.bytesToHex(std.crypto.hash.Md5.hashResult(aw.written()), .lower);
365365 try testing.expectEqualStrings(case.chksums[i], &chksum);
366366 } else {
367367 if (expected.truncated) {
lib/std/zig/Ast/Render.zig+5-5
......@@ -2189,12 +2189,12 @@ fn renderArrayInit(
21892189 var single_line = true;
21902190 var contains_newline = false;
21912191 for (section_exprs, 0..) |expr, i| {
2192 const start = sub_expr_buffer.getWritten().len;
2192 const start = sub_expr_buffer.written().len;
21932193 sub_expr_buffer_starts[i] = start;
21942194
21952195 if (i + 1 < section_exprs.len) {
21962196 try renderExpression(&sub_render, expr, .none);
2197 const written = sub_expr_buffer.getWritten();
2197 const written = sub_expr_buffer.written();
21982198 const width = written.len - start;
21992199 const this_contains_newline = mem.indexOfScalar(u8, written[start..], '\n') != null;
22002200 contains_newline = contains_newline or this_contains_newline;
......@@ -2218,7 +2218,7 @@ fn renderArrayInit(
22182218 try renderExpression(&sub_render, expr, .comma);
22192219 ais.popSpace();
22202220
2221 const written = sub_expr_buffer.getWritten();
2221 const written = sub_expr_buffer.written();
22222222 const width = written.len - start - 2;
22232223 const this_contains_newline = mem.indexOfScalar(u8, written[start .. written.len - 1], '\n') != null;
22242224 contains_newline = contains_newline or this_contains_newline;
......@@ -2231,14 +2231,14 @@ fn renderArrayInit(
22312231 }
22322232 }
22332233 }
2234 sub_expr_buffer_starts[section_exprs.len] = sub_expr_buffer.getWritten().len;
2234 sub_expr_buffer_starts[section_exprs.len] = sub_expr_buffer.written().len;
22352235
22362236 // Render exprs in current section.
22372237 column_counter = 0;
22382238 for (section_exprs, 0..) |expr, i| {
22392239 const start = sub_expr_buffer_starts[i];
22402240 const end = sub_expr_buffer_starts[i + 1];
2241 const expr_text = sub_expr_buffer.getWritten()[start..end];
2241 const expr_text = sub_expr_buffer.written()[start..end];
22422242 if (!expr_newlines[i]) {
22432243 try ais.writeAll(expr_text);
22442244 } else {
lib/std/zig/AstGen.zig+4-4
......@@ -13765,19 +13765,19 @@ fn lowerAstErrors(astgen: *AstGen) error{OutOfMemory}!void {
1376513765 };
1376613766 msg.clearRetainingCapacity();
1376713767 tree.renderError(ast_err, msg_w) catch return error.OutOfMemory;
13768 return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.getWritten()}, notes.items);
13768 return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.written()}, notes.items);
1376913769 }
1377013770
1377113771 var cur_err = tree.errors[0];
1377213772 for (tree.errors[1..]) |err| {
1377313773 if (err.is_note) {
1377413774 tree.renderError(err, msg_w) catch return error.OutOfMemory;
13775 try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.getWritten()}));
13775 try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.written()}));
1377613776 } else {
1377713777 // Flush error
1377813778 const extra_offset = tree.errorOffset(cur_err);
1377913779 tree.renderError(cur_err, msg_w) catch return error.OutOfMemory;
13780 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
13780 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.written()}, notes.items);
1378113781 notes.clearRetainingCapacity();
1378213782 cur_err = err;
1378313783
......@@ -13791,7 +13791,7 @@ fn lowerAstErrors(astgen: *AstGen) error{OutOfMemory}!void {
1379113791 // Flush error
1379213792 const extra_offset = tree.errorOffset(cur_err);
1379313793 tree.renderError(cur_err, msg_w) catch return error.OutOfMemory;
13794 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
13794 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.written()}, notes.items);
1379513795}
1379613796
1379713797const DeclarationName = union(enum) {
lib/std/zig/ErrorBundle.zig+1-1
......@@ -817,6 +817,6 @@ pub const Wip = struct {
817817 defer copy_buf.deinit();
818818 try copy.renderToWriter(.{ .ttyconf = ttyconf }, copy_bw);
819819
820 try std.testing.expectEqualStrings(bundle_bw.getWritten(), copy_bw.getWritten());
820 try std.testing.expectEqualStrings(bundle_bw.written(), copy_bw.written());
821821 }
822822};
lib/std/zig/ZonGen.zig+3-3
......@@ -896,12 +896,12 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {
896896 for (tree.errors[1..]) |err| {
897897 if (err.is_note) {
898898 tree.renderError(err, msg_bw) catch return error.OutOfMemory;
899 try notes.append(gpa, try zg.errNoteTok(err.token, "{s}", .{msg.getWritten()}));
899 try notes.append(gpa, try zg.errNoteTok(err.token, "{s}", .{msg.written()}));
900900 } else {
901901 // Flush error
902902 tree.renderError(cur_err, msg_bw) catch return error.OutOfMemory;
903903 const extra_offset = tree.errorOffset(cur_err);
904 try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
904 try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.written()}, notes.items);
905905 notes.clearRetainingCapacity();
906906 cur_err = err;
907907
......@@ -917,5 +917,5 @@ fn lowerAstErrors(zg: *ZonGen) Allocator.Error!void {
917917 // Flush error
918918 const extra_offset = tree.errorOffset(cur_err);
919919 tree.renderError(cur_err, msg_bw) catch return error.OutOfMemory;
920 try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
920 try zg.addErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.written()}, notes.items);
921921}
lib/std/zon/stringify.zig+116-116
......@@ -125,7 +125,7 @@ fn expectSerializeEqual(
125125 defer aw.deinit();
126126
127127 try serialize(value, options, bw);
128 try std.testing.expectEqualStrings(expected, aw.getWritten());
128 try std.testing.expectEqualStrings(expected, aw.written());
129129}
130130
131131test "std.zon stringify whitespace, high level API" {
......@@ -233,42 +233,42 @@ test "std.zon stringify whitespace, low level API" {
233233 {
234234 var container = try s.beginStruct(.{});
235235 try container.end();
236 try std.testing.expectEqualStrings(".{}", aw.getWritten());
236 try std.testing.expectEqualStrings(".{}", aw.written());
237237 aw.clearRetainingCapacity();
238238 }
239239
240240 {
241241 var container = try s.beginTuple(.{});
242242 try container.end();
243 try std.testing.expectEqualStrings(".{}", aw.getWritten());
243 try std.testing.expectEqualStrings(".{}", aw.written());
244244 aw.clearRetainingCapacity();
245245 }
246246
247247 {
248248 var container = try s.beginStruct(.{ .whitespace_style = .{ .wrap = false } });
249249 try container.end();
250 try std.testing.expectEqualStrings(".{}", aw.getWritten());
250 try std.testing.expectEqualStrings(".{}", aw.written());
251251 aw.clearRetainingCapacity();
252252 }
253253
254254 {
255255 var container = try s.beginTuple(.{ .whitespace_style = .{ .wrap = false } });
256256 try container.end();
257 try std.testing.expectEqualStrings(".{}", aw.getWritten());
257 try std.testing.expectEqualStrings(".{}", aw.written());
258258 aw.clearRetainingCapacity();
259259 }
260260
261261 {
262262 var container = try s.beginStruct(.{ .whitespace_style = .{ .fields = 0 } });
263263 try container.end();
264 try std.testing.expectEqualStrings(".{}", aw.getWritten());
264 try std.testing.expectEqualStrings(".{}", aw.written());
265265 aw.clearRetainingCapacity();
266266 }
267267
268268 {
269269 var container = try s.beginTuple(.{ .whitespace_style = .{ .fields = 0 } });
270270 try container.end();
271 try std.testing.expectEqualStrings(".{}", aw.getWritten());
271 try std.testing.expectEqualStrings(".{}", aw.written());
272272 aw.clearRetainingCapacity();
273273 }
274274
......@@ -282,9 +282,9 @@ test "std.zon stringify whitespace, low level API" {
282282 \\.{
283283 \\ .a = 1,
284284 \\}
285 , aw.getWritten());
285 , aw.written());
286286 } else {
287 try std.testing.expectEqualStrings(".{.a=1}", aw.getWritten());
287 try std.testing.expectEqualStrings(".{.a=1}", aw.written());
288288 }
289289 aw.clearRetainingCapacity();
290290 }
......@@ -298,9 +298,9 @@ test "std.zon stringify whitespace, low level API" {
298298 \\.{
299299 \\ 1,
300300 \\}
301 , aw.getWritten());
301 , aw.written());
302302 } else {
303 try std.testing.expectEqualStrings(".{1}", aw.getWritten());
303 try std.testing.expectEqualStrings(".{1}", aw.written());
304304 }
305305 aw.clearRetainingCapacity();
306306 }
......@@ -310,9 +310,9 @@ test "std.zon stringify whitespace, low level API" {
310310 try container.field("a", 1, .{});
311311 try container.end();
312312 if (whitespace) {
313 try std.testing.expectEqualStrings(".{ .a = 1 }", aw.getWritten());
313 try std.testing.expectEqualStrings(".{ .a = 1 }", aw.written());
314314 } else {
315 try std.testing.expectEqualStrings(".{.a=1}", aw.getWritten());
315 try std.testing.expectEqualStrings(".{.a=1}", aw.written());
316316 }
317317 aw.clearRetainingCapacity();
318318 }
......@@ -324,9 +324,9 @@ test "std.zon stringify whitespace, low level API" {
324324 try container.field(1, .{});
325325 try container.end();
326326 if (whitespace) {
327 try std.testing.expectEqualStrings(".{ 1 }", aw.getWritten());
327 try std.testing.expectEqualStrings(".{ 1 }", aw.written());
328328 } else {
329 try std.testing.expectEqualStrings(".{1}", aw.getWritten());
329 try std.testing.expectEqualStrings(".{1}", aw.written());
330330 }
331331 aw.clearRetainingCapacity();
332332 }
......@@ -336,9 +336,9 @@ test "std.zon stringify whitespace, low level API" {
336336 try container.field("a", 1, .{});
337337 try container.end();
338338 if (whitespace) {
339 try std.testing.expectEqualStrings(".{ .a = 1 }", aw.getWritten());
339 try std.testing.expectEqualStrings(".{ .a = 1 }", aw.written());
340340 } else {
341 try std.testing.expectEqualStrings(".{.a=1}", aw.getWritten());
341 try std.testing.expectEqualStrings(".{.a=1}", aw.written());
342342 }
343343 aw.clearRetainingCapacity();
344344 }
......@@ -347,7 +347,7 @@ test "std.zon stringify whitespace, low level API" {
347347 var container = try s.beginTuple(.{ .whitespace_style = .{ .fields = 1 } });
348348 try container.field(1, .{});
349349 try container.end();
350 try std.testing.expectEqualStrings(".{1}", aw.getWritten());
350 try std.testing.expectEqualStrings(".{1}", aw.written());
351351 aw.clearRetainingCapacity();
352352 }
353353
......@@ -363,9 +363,9 @@ test "std.zon stringify whitespace, low level API" {
363363 \\ .a = 1,
364364 \\ .b = 2,
365365 \\}
366 , aw.getWritten());
366 , aw.written());
367367 } else {
368 try std.testing.expectEqualStrings(".{.a=1,.b=2}", aw.getWritten());
368 try std.testing.expectEqualStrings(".{.a=1,.b=2}", aw.written());
369369 }
370370 aw.clearRetainingCapacity();
371371 }
......@@ -381,9 +381,9 @@ test "std.zon stringify whitespace, low level API" {
381381 \\ 1,
382382 \\ 2,
383383 \\}
384 , aw.getWritten());
384 , aw.written());
385385 } else {
386 try std.testing.expectEqualStrings(".{1,2}", aw.getWritten());
386 try std.testing.expectEqualStrings(".{1,2}", aw.written());
387387 }
388388 aw.clearRetainingCapacity();
389389 }
......@@ -394,9 +394,9 @@ test "std.zon stringify whitespace, low level API" {
394394 try container.field("b", 2, .{});
395395 try container.end();
396396 if (whitespace) {
397 try std.testing.expectEqualStrings(".{ .a = 1, .b = 2 }", aw.getWritten());
397 try std.testing.expectEqualStrings(".{ .a = 1, .b = 2 }", aw.written());
398398 } else {
399 try std.testing.expectEqualStrings(".{.a=1,.b=2}", aw.getWritten());
399 try std.testing.expectEqualStrings(".{.a=1,.b=2}", aw.written());
400400 }
401401 aw.clearRetainingCapacity();
402402 }
......@@ -407,9 +407,9 @@ test "std.zon stringify whitespace, low level API" {
407407 try container.field(2, .{});
408408 try container.end();
409409 if (whitespace) {
410 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.getWritten());
410 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.written());
411411 } else {
412 try std.testing.expectEqualStrings(".{1,2}", aw.getWritten());
412 try std.testing.expectEqualStrings(".{1,2}", aw.written());
413413 }
414414 aw.clearRetainingCapacity();
415415 }
......@@ -420,9 +420,9 @@ test "std.zon stringify whitespace, low level API" {
420420 try container.field("b", 2, .{});
421421 try container.end();
422422 if (whitespace) {
423 try std.testing.expectEqualStrings(".{ .a = 1, .b = 2 }", aw.getWritten());
423 try std.testing.expectEqualStrings(".{ .a = 1, .b = 2 }", aw.written());
424424 } else {
425 try std.testing.expectEqualStrings(".{.a=1,.b=2}", aw.getWritten());
425 try std.testing.expectEqualStrings(".{.a=1,.b=2}", aw.written());
426426 }
427427 aw.clearRetainingCapacity();
428428 }
......@@ -433,9 +433,9 @@ test "std.zon stringify whitespace, low level API" {
433433 try container.field(2, .{});
434434 try container.end();
435435 if (whitespace) {
436 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.getWritten());
436 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.written());
437437 } else {
438 try std.testing.expectEqualStrings(".{1,2}", aw.getWritten());
438 try std.testing.expectEqualStrings(".{1,2}", aw.written());
439439 }
440440 aw.clearRetainingCapacity();
441441 }
......@@ -454,9 +454,9 @@ test "std.zon stringify whitespace, low level API" {
454454 \\ .b = 2,
455455 \\ .c = 3,
456456 \\}
457 , aw.getWritten());
457 , aw.written());
458458 } else {
459 try std.testing.expectEqualStrings(".{.a=1,.b=2,.c=3}", aw.getWritten());
459 try std.testing.expectEqualStrings(".{.a=1,.b=2,.c=3}", aw.written());
460460 }
461461 aw.clearRetainingCapacity();
462462 }
......@@ -474,9 +474,9 @@ test "std.zon stringify whitespace, low level API" {
474474 \\ 2,
475475 \\ 3,
476476 \\}
477 , aw.getWritten());
477 , aw.written());
478478 } else {
479 try std.testing.expectEqualStrings(".{1,2,3}", aw.getWritten());
479 try std.testing.expectEqualStrings(".{1,2,3}", aw.written());
480480 }
481481 aw.clearRetainingCapacity();
482482 }
......@@ -488,9 +488,9 @@ test "std.zon stringify whitespace, low level API" {
488488 try container.field("c", 3, .{});
489489 try container.end();
490490 if (whitespace) {
491 try std.testing.expectEqualStrings(".{ .a = 1, .b = 2, .c = 3 }", aw.getWritten());
491 try std.testing.expectEqualStrings(".{ .a = 1, .b = 2, .c = 3 }", aw.written());
492492 } else {
493 try std.testing.expectEqualStrings(".{.a=1,.b=2,.c=3}", aw.getWritten());
493 try std.testing.expectEqualStrings(".{.a=1,.b=2,.c=3}", aw.written());
494494 }
495495 aw.clearRetainingCapacity();
496496 }
......@@ -502,9 +502,9 @@ test "std.zon stringify whitespace, low level API" {
502502 try container.field(3, .{});
503503 try container.end();
504504 if (whitespace) {
505 try std.testing.expectEqualStrings(".{ 1, 2, 3 }", aw.getWritten());
505 try std.testing.expectEqualStrings(".{ 1, 2, 3 }", aw.written());
506506 } else {
507 try std.testing.expectEqualStrings(".{1,2,3}", aw.getWritten());
507 try std.testing.expectEqualStrings(".{1,2,3}", aw.written());
508508 }
509509 aw.clearRetainingCapacity();
510510 }
......@@ -522,9 +522,9 @@ test "std.zon stringify whitespace, low level API" {
522522 \\ .b = 2,
523523 \\ .c = 3,
524524 \\}
525 , aw.getWritten());
525 , aw.written());
526526 } else {
527 try std.testing.expectEqualStrings(".{.a=1,.b=2,.c=3}", aw.getWritten());
527 try std.testing.expectEqualStrings(".{.a=1,.b=2,.c=3}", aw.written());
528528 }
529529 aw.clearRetainingCapacity();
530530 }
......@@ -542,9 +542,9 @@ test "std.zon stringify whitespace, low level API" {
542542 \\ 2,
543543 \\ 3,
544544 \\}
545 , aw.getWritten());
545 , aw.written());
546546 } else {
547 try std.testing.expectEqualStrings(".{1,2,3}", aw.getWritten());
547 try std.testing.expectEqualStrings(".{1,2,3}", aw.written());
548548 }
549549 aw.clearRetainingCapacity();
550550 }
......@@ -566,11 +566,11 @@ test "std.zon stringify whitespace, low level API" {
566566 \\ 5,
567567 \\ 6,
568568 \\} }
569 , aw.getWritten());
569 , aw.written());
570570 } else {
571571 try std.testing.expectEqualStrings(
572572 ".{.first=.{1,2,3},.second=.{4,5,6}}",
573 aw.getWritten(),
573 aw.written(),
574574 );
575575 }
576576 aw.clearRetainingCapacity();
......@@ -585,108 +585,108 @@ test "std.zon stringify utf8 codepoints" {
585585
586586 // Printable ASCII
587587 try s.int('a');
588 try std.testing.expectEqualStrings("97", aw.getWritten());
588 try std.testing.expectEqualStrings("97", aw.written());
589589 aw.clearRetainingCapacity();
590590
591591 try s.codePoint('a');
592 try std.testing.expectEqualStrings("'a'", aw.getWritten());
592 try std.testing.expectEqualStrings("'a'", aw.written());
593593 aw.clearRetainingCapacity();
594594
595595 try s.value('a', .{ .emit_codepoint_literals = .always });
596 try std.testing.expectEqualStrings("'a'", aw.getWritten());
596 try std.testing.expectEqualStrings("'a'", aw.written());
597597 aw.clearRetainingCapacity();
598598
599599 try s.value('a', .{ .emit_codepoint_literals = .printable_ascii });
600 try std.testing.expectEqualStrings("'a'", aw.getWritten());
600 try std.testing.expectEqualStrings("'a'", aw.written());
601601 aw.clearRetainingCapacity();
602602
603603 try s.value('a', .{ .emit_codepoint_literals = .never });
604 try std.testing.expectEqualStrings("97", aw.getWritten());
604 try std.testing.expectEqualStrings("97", aw.written());
605605 aw.clearRetainingCapacity();
606606
607607 // Short escaped codepoint
608608 try s.int('\n');
609 try std.testing.expectEqualStrings("10", aw.getWritten());
609 try std.testing.expectEqualStrings("10", aw.written());
610610 aw.clearRetainingCapacity();
611611
612612 try s.codePoint('\n');
613 try std.testing.expectEqualStrings("'\\n'", aw.getWritten());
613 try std.testing.expectEqualStrings("'\\n'", aw.written());
614614 aw.clearRetainingCapacity();
615615
616616 try s.value('\n', .{ .emit_codepoint_literals = .always });
617 try std.testing.expectEqualStrings("'\\n'", aw.getWritten());
617 try std.testing.expectEqualStrings("'\\n'", aw.written());
618618 aw.clearRetainingCapacity();
619619
620620 try s.value('\n', .{ .emit_codepoint_literals = .printable_ascii });
621 try std.testing.expectEqualStrings("10", aw.getWritten());
621 try std.testing.expectEqualStrings("10", aw.written());
622622 aw.clearRetainingCapacity();
623623
624624 try s.value('\n', .{ .emit_codepoint_literals = .never });
625 try std.testing.expectEqualStrings("10", aw.getWritten());
625 try std.testing.expectEqualStrings("10", aw.written());
626626 aw.clearRetainingCapacity();
627627
628628 // Large codepoint
629629 try s.int('⚡');
630 try std.testing.expectEqualStrings("9889", aw.getWritten());
630 try std.testing.expectEqualStrings("9889", aw.written());
631631 aw.clearRetainingCapacity();
632632
633633 try s.codePoint('⚡');
634 try std.testing.expectEqualStrings("'\\u{26a1}'", aw.getWritten());
634 try std.testing.expectEqualStrings("'\\u{26a1}'", aw.written());
635635 aw.clearRetainingCapacity();
636636
637637 try s.value('⚡', .{ .emit_codepoint_literals = .always });
638 try std.testing.expectEqualStrings("'\\u{26a1}'", aw.getWritten());
638 try std.testing.expectEqualStrings("'\\u{26a1}'", aw.written());
639639 aw.clearRetainingCapacity();
640640
641641 try s.value('⚡', .{ .emit_codepoint_literals = .printable_ascii });
642 try std.testing.expectEqualStrings("9889", aw.getWritten());
642 try std.testing.expectEqualStrings("9889", aw.written());
643643 aw.clearRetainingCapacity();
644644
645645 try s.value('⚡', .{ .emit_codepoint_literals = .never });
646 try std.testing.expectEqualStrings("9889", aw.getWritten());
646 try std.testing.expectEqualStrings("9889", aw.written());
647647 aw.clearRetainingCapacity();
648648
649649 // Invalid codepoint
650650 try s.codePoint(0x110000 + 1);
651 try std.testing.expectEqualStrings("'\\u{110001}'", aw.getWritten());
651 try std.testing.expectEqualStrings("'\\u{110001}'", aw.written());
652652 aw.clearRetainingCapacity();
653653
654654 try s.int(0x110000 + 1);
655 try std.testing.expectEqualStrings("1114113", aw.getWritten());
655 try std.testing.expectEqualStrings("1114113", aw.written());
656656 aw.clearRetainingCapacity();
657657
658658 try s.value(0x110000 + 1, .{ .emit_codepoint_literals = .always });
659 try std.testing.expectEqualStrings("1114113", aw.getWritten());
659 try std.testing.expectEqualStrings("1114113", aw.written());
660660 aw.clearRetainingCapacity();
661661
662662 try s.value(0x110000 + 1, .{ .emit_codepoint_literals = .printable_ascii });
663 try std.testing.expectEqualStrings("1114113", aw.getWritten());
663 try std.testing.expectEqualStrings("1114113", aw.written());
664664 aw.clearRetainingCapacity();
665665
666666 try s.value(0x110000 + 1, .{ .emit_codepoint_literals = .never });
667 try std.testing.expectEqualStrings("1114113", aw.getWritten());
667 try std.testing.expectEqualStrings("1114113", aw.written());
668668 aw.clearRetainingCapacity();
669669
670670 // Valid codepoint, not a codepoint type
671671 try s.value(@as(u22, 'a'), .{ .emit_codepoint_literals = .always });
672 try std.testing.expectEqualStrings("97", aw.getWritten());
672 try std.testing.expectEqualStrings("97", aw.written());
673673 aw.clearRetainingCapacity();
674674
675675 try s.value(@as(u22, 'a'), .{ .emit_codepoint_literals = .printable_ascii });
676 try std.testing.expectEqualStrings("97", aw.getWritten());
676 try std.testing.expectEqualStrings("97", aw.written());
677677 aw.clearRetainingCapacity();
678678
679679 try s.value(@as(i32, 'a'), .{ .emit_codepoint_literals = .never });
680 try std.testing.expectEqualStrings("97", aw.getWritten());
680 try std.testing.expectEqualStrings("97", aw.written());
681681 aw.clearRetainingCapacity();
682682
683683 // Make sure value options are passed to children
684684 try s.value(.{ .c = '⚡' }, .{ .emit_codepoint_literals = .always });
685 try std.testing.expectEqualStrings(".{ .c = '\\u{26a1}' }", aw.getWritten());
685 try std.testing.expectEqualStrings(".{ .c = '\\u{26a1}' }", aw.written());
686686 aw.clearRetainingCapacity();
687687
688688 try s.value(.{ .c = '⚡' }, .{ .emit_codepoint_literals = .never });
689 try std.testing.expectEqualStrings(".{ .c = 9889 }", aw.getWritten());
689 try std.testing.expectEqualStrings(".{ .c = 9889 }", aw.written());
690690 aw.clearRetainingCapacity();
691691}
692692
......@@ -697,7 +697,7 @@ test "std.zon stringify strings" {
697697
698698 // Minimal case
699699 try s.string("abc⚡\n");
700 try std.testing.expectEqualStrings("\"abc\\xe2\\x9a\\xa1\\n\"", aw.getWritten());
700 try std.testing.expectEqualStrings("\"abc\\xe2\\x9a\\xa1\\n\"", aw.written());
701701 aw.clearRetainingCapacity();
702702
703703 try s.tuple("abc⚡\n", .{});
......@@ -711,11 +711,11 @@ test "std.zon stringify strings" {
711711 \\ 161,
712712 \\ 10,
713713 \\}
714 , aw.getWritten());
714 , aw.written());
715715 aw.clearRetainingCapacity();
716716
717717 try s.value("abc⚡\n", .{});
718 try std.testing.expectEqualStrings("\"abc\\xe2\\x9a\\xa1\\n\"", aw.getWritten());
718 try std.testing.expectEqualStrings("\"abc\\xe2\\x9a\\xa1\\n\"", aw.written());
719719 aw.clearRetainingCapacity();
720720
721721 try s.value("abc⚡\n", .{ .emit_strings_as_containers = true });
......@@ -729,12 +729,12 @@ test "std.zon stringify strings" {
729729 \\ 161,
730730 \\ 10,
731731 \\}
732 , aw.getWritten());
732 , aw.written());
733733 aw.clearRetainingCapacity();
734734
735735 // Value options are inherited by children
736736 try s.value(.{ .str = "abc" }, .{});
737 try std.testing.expectEqualStrings(".{ .str = \"abc\" }", aw.getWritten());
737 try std.testing.expectEqualStrings(".{ .str = \"abc\" }", aw.written());
738738 aw.clearRetainingCapacity();
739739
740740 try s.value(.{ .str = "abc" }, .{ .emit_strings_as_containers = true });
......@@ -744,7 +744,7 @@ test "std.zon stringify strings" {
744744 \\ 98,
745745 \\ 99,
746746 \\} }
747 , aw.getWritten());
747 , aw.written());
748748 aw.clearRetainingCapacity();
749749
750750 // Arrays (rather than pointers to arrays) of u8s are not considered strings, so that data can
......@@ -756,7 +756,7 @@ test "std.zon stringify strings" {
756756 \\ 98,
757757 \\ 99,
758758 \\}
759 , aw.getWritten());
759 , aw.written());
760760 aw.clearRetainingCapacity();
761761}
762762
......@@ -770,46 +770,46 @@ test "std.zon stringify multiline strings" {
770770
771771 {
772772 try s.multilineString("", .{ .top_level = true });
773 try std.testing.expectEqualStrings("\\\\", aw.getWritten());
773 try std.testing.expectEqualStrings("\\\\", aw.written());
774774 aw.clearRetainingCapacity();
775775 }
776776
777777 {
778778 try s.multilineString("abc⚡", .{ .top_level = true });
779 try std.testing.expectEqualStrings("\\\\abc⚡", aw.getWritten());
779 try std.testing.expectEqualStrings("\\\\abc⚡", aw.written());
780780 aw.clearRetainingCapacity();
781781 }
782782
783783 {
784784 try s.multilineString("abc⚡\ndef", .{ .top_level = true });
785 try std.testing.expectEqualStrings("\\\\abc⚡\n\\\\def", aw.getWritten());
785 try std.testing.expectEqualStrings("\\\\abc⚡\n\\\\def", aw.written());
786786 aw.clearRetainingCapacity();
787787 }
788788
789789 {
790790 try s.multilineString("abc⚡\r\ndef", .{ .top_level = true });
791 try std.testing.expectEqualStrings("\\\\abc⚡\n\\\\def", aw.getWritten());
791 try std.testing.expectEqualStrings("\\\\abc⚡\n\\\\def", aw.written());
792792 aw.clearRetainingCapacity();
793793 }
794794
795795 {
796796 try s.multilineString("\nabc⚡", .{ .top_level = true });
797 try std.testing.expectEqualStrings("\\\\\n\\\\abc⚡", aw.getWritten());
797 try std.testing.expectEqualStrings("\\\\\n\\\\abc⚡", aw.written());
798798 aw.clearRetainingCapacity();
799799 }
800800
801801 {
802802 try s.multilineString("\r\nabc⚡", .{ .top_level = true });
803 try std.testing.expectEqualStrings("\\\\\n\\\\abc⚡", aw.getWritten());
803 try std.testing.expectEqualStrings("\\\\\n\\\\abc⚡", aw.written());
804804 aw.clearRetainingCapacity();
805805 }
806806
807807 {
808808 try s.multilineString("abc\ndef", .{});
809809 if (whitespace) {
810 try std.testing.expectEqualStrings("\n\\\\abc\n\\\\def\n", aw.getWritten());
810 try std.testing.expectEqualStrings("\n\\\\abc\n\\\\def\n", aw.written());
811811 } else {
812 try std.testing.expectEqualStrings("\\\\abc\n\\\\def\n", aw.getWritten());
812 try std.testing.expectEqualStrings("\\\\abc\n\\\\def\n", aw.written());
813813 }
814814 aw.clearRetainingCapacity();
815815 }
......@@ -817,7 +817,7 @@ test "std.zon stringify multiline strings" {
817817 {
818818 const str: []const u8 = &.{ 'a', '\r', 'c' };
819819 try s.string(str);
820 try std.testing.expectEqualStrings("\"a\\rc\"", aw.getWritten());
820 try std.testing.expectEqualStrings("\"a\\rc\"", aw.written());
821821 aw.clearRetainingCapacity();
822822 }
823823
......@@ -834,7 +834,7 @@ test "std.zon stringify multiline strings" {
834834 error.InnerCarriageReturn,
835835 s.multilineString(@as([]const u8, &.{ 'a', '\r', 'c', '\r', '\n' }), .{}),
836836 );
837 try std.testing.expectEqualStrings("", aw.getWritten());
837 try std.testing.expectEqualStrings("", aw.written());
838838 aw.clearRetainingCapacity();
839839 }
840840 }
......@@ -989,11 +989,11 @@ test "std.zon depth limits" {
989989
990990 // Normal operation
991991 try serializeMaxDepth(.{ 1, .{ 2, 3 } }, .{}, bw, 16);
992 try std.testing.expectEqualStrings(".{ 1, .{ 2, 3 } }", aw.getWritten());
992 try std.testing.expectEqualStrings(".{ 1, .{ 2, 3 } }", aw.written());
993993 aw.clearRetainingCapacity();
994994
995995 try serializeArbitraryDepth(.{ 1, .{ 2, 3 } }, .{}, bw);
996 try std.testing.expectEqualStrings(".{ 1, .{ 2, 3 } }", aw.getWritten());
996 try std.testing.expectEqualStrings(".{ 1, .{ 2, 3 } }", aw.written());
997997 aw.clearRetainingCapacity();
998998
999999 // Max depth failing on non recursive type
......@@ -1001,14 +1001,14 @@ test "std.zon depth limits" {
10011001 error.ExceededMaxDepth,
10021002 serializeMaxDepth(.{ 1, .{ 2, .{ 3, 4 } } }, .{}, bw, 3),
10031003 );
1004 try std.testing.expectEqualStrings("", aw.getWritten());
1004 try std.testing.expectEqualStrings("", aw.written());
10051005 aw.clearRetainingCapacity();
10061006
10071007 // Max depth passing on recursive type
10081008 {
10091009 const maybe_recurse = Recurse{ .r = &.{} };
10101010 try serializeMaxDepth(maybe_recurse, .{}, bw, 2);
1011 try std.testing.expectEqualStrings(".{ .r = .{} }", aw.getWritten());
1011 try std.testing.expectEqualStrings(".{ .r = .{} }", aw.written());
10121012 aw.clearRetainingCapacity();
10131013 }
10141014
......@@ -1016,7 +1016,7 @@ test "std.zon depth limits" {
10161016 {
10171017 const maybe_recurse = Recurse{ .r = &.{} };
10181018 try serializeArbitraryDepth(maybe_recurse, .{}, bw);
1019 try std.testing.expectEqualStrings(".{ .r = .{} }", aw.getWritten());
1019 try std.testing.expectEqualStrings(".{ .r = .{} }", aw.written());
10201020 aw.clearRetainingCapacity();
10211021 }
10221022
......@@ -1028,7 +1028,7 @@ test "std.zon depth limits" {
10281028 error.ExceededMaxDepth,
10291029 serializeMaxDepth(maybe_recurse, .{}, bw, 2),
10301030 );
1031 try std.testing.expectEqualStrings("", aw.getWritten());
1031 try std.testing.expectEqualStrings("", aw.written());
10321032 aw.clearRetainingCapacity();
10331033 }
10341034
......@@ -1041,7 +1041,7 @@ test "std.zon depth limits" {
10411041 error.ExceededMaxDepth,
10421042 serializeMaxDepth(maybe_recurse, .{}, bw, 2),
10431043 );
1044 try std.testing.expectEqualStrings("", aw.getWritten());
1044 try std.testing.expectEqualStrings("", aw.written());
10451045 aw.clearRetainingCapacity();
10461046
10471047 var s: Serializer = .{ .writer = bw };
......@@ -1050,11 +1050,11 @@ test "std.zon depth limits" {
10501050 error.ExceededMaxDepth,
10511051 s.tupleMaxDepth(maybe_recurse, .{}, 2),
10521052 );
1053 try std.testing.expectEqualStrings("", aw.getWritten());
1053 try std.testing.expectEqualStrings("", aw.written());
10541054 aw.clearRetainingCapacity();
10551055
10561056 try s.tupleArbitraryDepth(maybe_recurse, .{});
1057 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.getWritten());
1057 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.written());
10581058 aw.clearRetainingCapacity();
10591059 }
10601060
......@@ -1064,17 +1064,17 @@ test "std.zon depth limits" {
10641064 const maybe_recurse: []const Recurse = &temp;
10651065
10661066 try serializeMaxDepth(maybe_recurse, .{}, bw, 3);
1067 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.getWritten());
1067 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.written());
10681068 aw.clearRetainingCapacity();
10691069
10701070 var s: Serializer = .{ .writer = bw };
10711071
10721072 try s.tupleMaxDepth(maybe_recurse, .{}, 3);
1073 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.getWritten());
1073 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.written());
10741074 aw.clearRetainingCapacity();
10751075
10761076 try s.tupleArbitraryDepth(maybe_recurse, .{});
1077 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.getWritten());
1077 try std.testing.expectEqualStrings(".{.{ .r = .{} }}", aw.written());
10781078 aw.clearRetainingCapacity();
10791079 }
10801080
......@@ -1088,7 +1088,7 @@ test "std.zon depth limits" {
10881088 error.ExceededMaxDepth,
10891089 serializeMaxDepth(maybe_recurse, .{}, bw, 128),
10901090 );
1091 try std.testing.expectEqualStrings("", aw.getWritten());
1091 try std.testing.expectEqualStrings("", aw.written());
10921092 aw.clearRetainingCapacity();
10931093
10941094 var s: Serializer = .{ .writer = bw };
......@@ -1096,7 +1096,7 @@ test "std.zon depth limits" {
10961096 error.ExceededMaxDepth,
10971097 s.tupleMaxDepth(maybe_recurse, .{}, 128),
10981098 );
1099 try std.testing.expectEqualStrings("", aw.getWritten());
1099 try std.testing.expectEqualStrings("", aw.written());
11001100 aw.clearRetainingCapacity();
11011101 }
11021102
......@@ -1146,7 +1146,7 @@ test "std.zon depth limits" {
11461146 \\ 9,
11471147 \\ .{},
11481148 \\}
1149 , aw.getWritten());
1149 , aw.written());
11501150 }
11511151}
11521152
......@@ -1248,35 +1248,35 @@ test "std.zon stringify ident" {
12481248
12491249 try expectSerializeEqual(".{ .a = 0 }", .{ .a = 0 }, .{});
12501250 try s.ident("a");
1251 try std.testing.expectEqualStrings(".a", aw.getWritten());
1251 try std.testing.expectEqualStrings(".a", aw.written());
12521252 aw.clearRetainingCapacity();
12531253
12541254 try s.ident("foo_1");
1255 try std.testing.expectEqualStrings(".foo_1", aw.getWritten());
1255 try std.testing.expectEqualStrings(".foo_1", aw.written());
12561256 aw.clearRetainingCapacity();
12571257
12581258 try s.ident("_foo_1");
1259 try std.testing.expectEqualStrings("._foo_1", aw.getWritten());
1259 try std.testing.expectEqualStrings("._foo_1", aw.written());
12601260 aw.clearRetainingCapacity();
12611261
12621262 try s.ident("foo bar");
1263 try std.testing.expectEqualStrings(".@\"foo bar\"", aw.getWritten());
1263 try std.testing.expectEqualStrings(".@\"foo bar\"", aw.written());
12641264 aw.clearRetainingCapacity();
12651265
12661266 try s.ident("1foo");
1267 try std.testing.expectEqualStrings(".@\"1foo\"", aw.getWritten());
1267 try std.testing.expectEqualStrings(".@\"1foo\"", aw.written());
12681268 aw.clearRetainingCapacity();
12691269
12701270 try s.ident("var");
1271 try std.testing.expectEqualStrings(".@\"var\"", aw.getWritten());
1271 try std.testing.expectEqualStrings(".@\"var\"", aw.written());
12721272 aw.clearRetainingCapacity();
12731273
12741274 try s.ident("true");
1275 try std.testing.expectEqualStrings(".true", aw.getWritten());
1275 try std.testing.expectEqualStrings(".true", aw.written());
12761276 aw.clearRetainingCapacity();
12771277
12781278 try s.ident("_");
1279 try std.testing.expectEqualStrings("._", aw.getWritten());
1279 try std.testing.expectEqualStrings("._", aw.written());
12801280 aw.clearRetainingCapacity();
12811281
12821282 const Enum = enum {
......@@ -1295,17 +1295,17 @@ test "std.zon stringify as tuple" {
12951295
12961296 // Tuples
12971297 try s.tuple(.{ 1, 2 }, .{});
1298 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.getWritten());
1298 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.written());
12991299 aw.clearRetainingCapacity();
13001300
13011301 // Slice
13021302 try s.tuple(@as([]const u8, &.{ 1, 2 }), .{});
1303 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.getWritten());
1303 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.written());
13041304 aw.clearRetainingCapacity();
13051305
13061306 // Array
13071307 try s.tuple([2]u8{ 1, 2 }, .{});
1308 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.getWritten());
1308 try std.testing.expectEqualStrings(".{ 1, 2 }", aw.written());
13091309 aw.clearRetainingCapacity();
13101310}
13111311
......@@ -1316,12 +1316,12 @@ test "std.zon stringify as float" {
13161316
13171317 // Comptime float
13181318 try s.float(2.5);
1319 try std.testing.expectEqualStrings("2.5", aw.getWritten());
1319 try std.testing.expectEqualStrings("2.5", aw.written());
13201320 aw.clearRetainingCapacity();
13211321
13221322 // Sized float
13231323 try s.float(@as(f32, 2.5));
1324 try std.testing.expectEqualStrings("2.5", aw.getWritten());
1324 try std.testing.expectEqualStrings("2.5", aw.written());
13251325 aw.clearRetainingCapacity();
13261326}
13271327
......@@ -1446,7 +1446,7 @@ test "std.zon tuple/struct field" {
14461446 \\ .b = 1,
14471447 \\ },
14481448 \\}
1449 , aw.getWritten());
1449 , aw.written());
14501450 aw.clearRetainingCapacity();
14511451 }
14521452
......@@ -1478,7 +1478,7 @@ test "std.zon tuple/struct field" {
14781478 \\ .b = 1,
14791479 \\ },
14801480 \\}
1481 , aw.getWritten());
1481 , aw.written());
14821482 aw.clearRetainingCapacity();
14831483 }
14841484}
src/Compilation.zig+1-1
......@@ -1123,7 +1123,7 @@ pub const CObject = struct {
11231123 var aw: Writer.Allocating = .init(eb.gpa);
11241124 defer aw.deinit();
11251125 _ = file_reader.interface.streamDelimiterEnding(&aw.writer, '\n') catch break :source_line 0;
1126 break :source_line try eb.addString(aw.getWritten());
1126 break :source_line try eb.addString(aw.written());
11271127 };
11281128
11291129 return .{
src/Package/Fetch.zig+2-2
......@@ -2029,7 +2029,7 @@ const UnpackResult = struct {
20292029 \\ note: unable to create symlink from 'dir2/file2' to 'filename': SymlinkError
20302030 \\ note: file 'dir2/file4' has unsupported type 'x'
20312031 \\
2032 , aw.getWritten());
2032 , aw.written());
20332033 }
20342034};
20352035
......@@ -2333,7 +2333,7 @@ const TestFetchBuilder = struct {
23332333 var aw: std.io.Writer.Allocating = .init(std.testing.allocator);
23342334 defer aw.deinit();
23352335 try errors.renderToWriter(.{ .ttyconf = .no_color }, &aw.writer);
2336 try std.testing.expectEqualStrings(msg, aw.getWritten());
2336 try std.testing.expectEqualStrings(msg, aw.written());
23372337 }
23382338};
23392339
src/Sema.zig+5-5
......@@ -3071,7 +3071,7 @@ pub fn createTypeName(
30713071
30723072 w.writeByte(')') catch return error.OutOfMemory;
30733073 return .{
3074 .name = try ip.getOrPutString(gpa, pt.tid, aw.getWritten(), .no_embedded_nulls),
3074 .name = try ip.getOrPutString(gpa, pt.tid, aw.written(), .no_embedded_nulls),
30753075 .nav = .none,
30763076 };
30773077 },
......@@ -5484,7 +5484,7 @@ fn zirCompileLog(
54845484 }
54855485 }
54865486
5487 const line_data = try zcu.intern_pool.getOrPutString(gpa, pt.tid, aw.getWritten(), .no_embedded_nulls);
5487 const line_data = try zcu.intern_pool.getOrPutString(gpa, pt.tid, aw.written(), .no_embedded_nulls);
54885488
54895489 const line_idx: Zcu.CompileLogLine.Index = if (zcu.free_compile_log_lines.pop()) |idx| idx: {
54905490 zcu.compile_log_lines.items[@intFromEnum(idx)] = .{
......@@ -36892,11 +36892,11 @@ fn notePathToComptimeAllocPtr(
3689236892 switch (deriv_start) {
3689336893 .int, .nav_ptr => unreachable,
3689436894 .uav_ptr => |uav| {
36895 try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path_aw.getWritten() });
36895 try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path_aw.written() });
3689636896 return .{ .new_val = .fromInterned(uav.val) };
3689736897 },
3689836898 .comptime_alloc_ptr => |cta_info| {
36899 try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path_aw.getWritten() });
36899 try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path_aw.written() });
3690036900 const cta = sema.getComptimeAlloc(cta_info.idx);
3690136901 if (cta.is_const) {
3690236902 return .{ .new_val = cta_info.val };
......@@ -36906,7 +36906,7 @@ fn notePathToComptimeAllocPtr(
3690636906 }
3690736907 },
3690836908 .comptime_field_ptr => {
36909 try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path_aw.getWritten() });
36909 try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path_aw.written() });
3691036910 try sema.errNote(src, msg, "'{s}' is a comptime field", .{inter_name});
3691136911 return .done;
3691236912 },
src/codegen/c.zig+1-1
......@@ -728,7 +728,7 @@ pub const Object = struct {
728728 }
729729 fn outdent(o: *Object) !void {
730730 o.indent_counter -= indent_width;
731 const written = o.code.getWritten();
731 const written = o.code.written();
732732 switch (written[written.len - 1]) {
733733 indent_char => o.code.shrinkRetainingCapacity(written.len - indent_width),
734734 '\n' => try o.code.writer.splatByteAll(indent_char, o.indent_counter),
src/fmt.zig+2-2
......@@ -341,7 +341,7 @@ fn fmtPathFile(
341341 tree.render(gpa, &fmt.out_buffer.writer, .{}) catch |err| switch (err) {
342342 error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
343343 };
344 if (mem.eql(u8, fmt.out_buffer.getWritten(), source_code))
344 if (mem.eql(u8, fmt.out_buffer.written(), source_code))
345345 return;
346346
347347 if (check_mode) {
......@@ -351,7 +351,7 @@ fn fmtPathFile(
351351 var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode, .write_buffer = &.{} });
352352 defer af.deinit();
353353
354 try af.file_writer.interface.writeAll(fmt.out_buffer.getWritten());
354 try af.file_writer.interface.writeAll(fmt.out_buffer.written());
355355 try af.finish();
356356 try fmt.stdout_writer.interface.print("{s}\n", .{file_path});
357357 }
src/link/C.zig+7-7
......@@ -268,8 +268,8 @@ fn updateUav(self: *C, pt: Zcu.PerThread, i: usize) link.File.FlushError!void {
268268
269269 object.dg.ctype_pool.freeUnusedCapacity(gpa);
270270 self.uavs.values()[i] = .{
271 .fwd_decl = try self.addString(object.dg.fwd_decl.getWritten()),
272 .code = try self.addString(object.code.getWritten()),
271 .fwd_decl = try self.addString(object.dg.fwd_decl.written()),
272 .code = try self.addString(object.code.written()),
273273 .ctype_pool = object.dg.ctype_pool.move(),
274274 };
275275}
......@@ -335,8 +335,8 @@ pub fn updateNav(self: *C, pt: Zcu.PerThread, nav_index: InternPool.Nav.Index) l
335335 },
336336 error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
337337 };
338 gop.value_ptr.fwd_decl = try self.addString(object.dg.fwd_decl.getWritten());
339 gop.value_ptr.code = try self.addString(object.code.getWritten());
338 gop.value_ptr.fwd_decl = try self.addString(object.dg.fwd_decl.written());
339 gop.value_ptr.code = try self.addString(object.code.written());
340340 try self.addUavsFromCodegen(&object.dg.uavs);
341341}
342342
......@@ -409,7 +409,7 @@ pub fn flush(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.P
409409 // Covers defines, zig.h, ctypes, asm, lazy fwd.
410410 try f.all_buffers.ensureUnusedCapacity(gpa, 5);
411411
412 f.appendBufAssumeCapacity(abi_defines_aw.getWritten());
412 f.appendBufAssumeCapacity(abi_defines_aw.written());
413413 f.appendBufAssumeCapacity(zig_h);
414414
415415 const ctypes_index = f.all_buffers.items.len;
......@@ -420,7 +420,7 @@ pub fn flush(self: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.P
420420 codegen.genGlobalAsm(zcu, &asm_aw.writer) catch |err| switch (err) {
421421 error.WriteFailed => return error.OutOfMemory,
422422 };
423 f.appendBufAssumeCapacity(asm_aw.getWritten());
423 f.appendBufAssumeCapacity(asm_aw.written());
424424
425425 const lazy_index = f.all_buffers.items.len;
426426 f.all_buffers.items.len += 1;
......@@ -849,7 +849,7 @@ pub fn updateExports(
849849 codegen.genExports(&dg, exported, export_indices) catch |err| switch (err) {
850850 error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
851851 };
852 exported_block.* = .{ .fwd_decl = try self.addString(dg.fwd_decl.getWritten()) };
852 exported_block.* = .{ .fwd_decl = try self.addString(dg.fwd_decl.written()) };
853853}
854854
855855pub fn deleteExport(
src/link/Dwarf.zig+25-25
......@@ -748,7 +748,7 @@ const Unit = struct {
748748 assert(tw.end == unit.trailer_len);
749749 tw.splatByteAll(fill_byte, len - unit.trailer_len) catch unreachable;
750750 assert(tw.end == len);
751 try dwarf.getFile().?.pwriteAll(trailer_aw.getWritten(), sec.off(dwarf) + start);
751 try dwarf.getFile().?.pwriteAll(trailer_aw.written(), sec.off(dwarf) + start);
752752 }
753753
754754 fn resolveRelocs(unit: *Unit, sec: *Section, dwarf: *Dwarf) RelocError!void {
......@@ -1719,10 +1719,10 @@ pub const WipNav = struct {
17191719 else
17201720 std.leb.writeUnsignedFixed(
17211721 block_bytes,
1722 wip_nav.debug_info.getWritten()[block.abbrev_code..][0..block_bytes],
1722 wip_nav.debug_info.written()[block.abbrev_code..][0..block_bytes],
17231723 try wip_nav.dwarf.refAbbrevCode(.empty_block),
17241724 );
1725 std.mem.writeInt(u32, wip_nav.debug_info.getWritten()[block.high_pc..][0..4], @intCast(code_off - block.low_pc_off), wip_nav.dwarf.endian);
1725 std.mem.writeInt(u32, wip_nav.debug_info.written()[block.high_pc..][0..4], @intCast(code_off - block.low_pc_off), wip_nav.dwarf.endian);
17261726 wip_nav.any_children = true;
17271727 }
17281728
......@@ -1781,10 +1781,10 @@ pub const WipNav = struct {
17811781 else
17821782 std.leb.writeUnsignedFixed(
17831783 inlined_func_bytes,
1784 wip_nav.debug_info.getWritten()[block.abbrev_code..][0..inlined_func_bytes],
1784 wip_nav.debug_info.written()[block.abbrev_code..][0..inlined_func_bytes],
17851785 try wip_nav.dwarf.refAbbrevCode(.empty_inlined_func),
17861786 );
1787 std.mem.writeInt(u32, wip_nav.debug_info.getWritten()[block.high_pc..][0..4], @intCast(code_off - block.low_pc_off), wip_nav.dwarf.endian);
1787 std.mem.writeInt(u32, wip_nav.debug_info.written()[block.high_pc..][0..4], @intCast(code_off - block.low_pc_off), wip_nav.dwarf.endian);
17881788 try wip_nav.setInlineFunc(func);
17891789 wip_nav.any_children = true;
17901790 }
......@@ -2282,7 +2282,7 @@ pub const WipNav = struct {
22822282
22832283 if (!is_generic_decl) return;
22842284 const generic_decl_entry = wip_nav.entry;
2285 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, generic_decl_entry, dwarf, wip_nav.debug_info.getWritten());
2285 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, generic_decl_entry, dwarf, wip_nav.debug_info.written());
22862286 wip_nav.debug_info.clearRetainingCapacity();
22872287 wip_nav.entry = orig_entry;
22882288 try wip_nav.abbrevCode(abbrev_code.decl_instance);
......@@ -2851,7 +2851,7 @@ fn finishWipNavFuncWriterError(
28512851 DW.CFA.nop,
28522852 @intCast(dwarf.debug_frame.section.alignment.forward(dfw.end) - dfw.end),
28532853 );
2854 const contents = wip_nav.debug_frame.getWritten();
2854 const contents = wip_nav.debug_frame.written();
28552855 try dwarf.debug_frame.section.resizeEntry(wip_nav.unit, wip_nav.entry, dwarf, @intCast(contents.len));
28562856 const unit = dwarf.debug_frame.section.getUnit(wip_nav.unit);
28572857 const entry = unit.getEntry(wip_nav.entry);
......@@ -2878,12 +2878,12 @@ fn finishWipNavFuncWriterError(
28782878 },
28792879 }
28802880 {
2881 std.mem.writeInt(u32, wip_nav.debug_info.getWritten()[wip_nav.func_high_pc..][0..4], @intCast(code_size), dwarf.endian);
2881 std.mem.writeInt(u32, wip_nav.debug_info.written()[wip_nav.func_high_pc..][0..4], @intCast(code_size), dwarf.endian);
28822882 if (wip_nav.any_children) {
28832883 const diw = &wip_nav.debug_info.writer;
28842884 try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
28852885 } else {
2886 const abbrev_code_buf = wip_nav.debug_info.getWritten()[0..AbbrevCode.decl_bytes];
2886 const abbrev_code_buf = wip_nav.debug_info.written()[0..AbbrevCode.decl_bytes];
28872887 var abbrev_code_fr: std.Io.Reader = .fixed(abbrev_code_buf);
28882888 const abbrev_code: AbbrevCode = @enumFromInt(
28892889 abbrev_code_fr.takeLeb128(@typeInfo(AbbrevCode).@"enum".tag_type) catch unreachable,
......@@ -2944,15 +2944,15 @@ fn finishWipNavWriterError(
29442944 const nav = ip.getNav(nav_index);
29452945 log.debug("finishWipNav({f})", .{nav.fqn.fmt(ip)});
29462946
2947 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
2947 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
29482948 const dlw = &wip_nav.debug_line.writer;
29492949 if (dlw.end > 0) {
29502950 try dlw.writeByte(DW.LNS.extended_op);
29512951 try dlw.writeUleb128(1);
29522952 try dlw.writeByte(DW.LNE.end_sequence);
2953 try dwarf.debug_line.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_line.getWritten());
2953 try dwarf.debug_line.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_line.written());
29542954 }
2955 try dwarf.debug_loclists.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_loclists.getWritten());
2955 try dwarf.debug_loclists.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_loclists.written());
29562956
29572957 try wip_nav.updateLazy(zcu.navSrcLoc(nav_index));
29582958}
......@@ -3407,7 +3407,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo
34073407 try wip_nav.refNav(owner_nav);
34083408 },
34093409 }
3410 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
3410 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
34113411 try wip_nav.updateLazy(nav_src_loc);
34123412}
34133413
......@@ -3914,7 +3914,7 @@ fn updateLazyType(
39143914 .memoized_call,
39153915 => unreachable,
39163916 }
3917 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
3917 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
39183918}
39193919
39203920fn updateLazyValue(
......@@ -4288,7 +4288,7 @@ fn updateLazyValue(
42884288 },
42894289 .memoized_call => unreachable, // not a value
42904290 }
4291 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
4291 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
42924292}
42934293
42944294fn optRepr(opt_child_type: Type, zcu: *const Zcu) enum {
......@@ -4411,7 +4411,7 @@ fn updateContainerTypeWriterError(
44114411 try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
44124412 }
44134413
4414 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
4414 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
44154415 try wip_nav.updateLazy(ty_src_loc);
44164416 } else {
44174417 {
......@@ -4611,8 +4611,8 @@ fn updateContainerTypeWriterError(
46114611 },
46124612 else => unreachable,
46134613 }
4614 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
4615 try dwarf.debug_loclists.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_loclists.getWritten());
4614 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
4615 try dwarf.debug_loclists.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_loclists.written());
46164616 try wip_nav.updateLazy(ty_src_loc);
46174617 }
46184618}
......@@ -4661,7 +4661,7 @@ fn refAbbrevCode(
46614661 try daw.writeByte(if (abbrev.children) DW.CHILDREN.yes else DW.CHILDREN.no);
46624662 for (abbrev.attrs) |*attr| inline for (attr) |info| try daw.writeUleb128(@intFromEnum(info));
46634663 for (0..2) |_| try daw.writeUleb128(0);
4664 try dwarf.debug_abbrev.section.replaceEntry(DebugAbbrev.unit, entry, dwarf, debug_abbrev_aw.getWritten());
4664 try dwarf.debug_abbrev.section.replaceEntry(DebugAbbrev.unit, entry, dwarf, debug_abbrev_aw.written());
46654665 return @intFromEnum(abbrev_code);
46664666}
46674667
......@@ -4710,7 +4710,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
47104710 try wip_nav.strp(name.toSlice(ip));
47114711 }
47124712 if (global_error_set_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null));
4713 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.getWritten());
4713 try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written());
47144714 try wip_nav.updateLazy(.unneeded);
47154715 }
47164716
......@@ -4751,7 +4751,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
47514751 hw.writeByte(@intFromEnum(dwarf.address_size)) catch unreachable;
47524752 hw.writeByte(0) catch unreachable;
47534753 hw.splatByteAll(0, unit_ptr.header_len - hw.end) catch unreachable;
4754 try unit_ptr.replaceHeader(&dwarf.debug_aranges.section, dwarf, header_aw.getWritten());
4754 try unit_ptr.replaceHeader(&dwarf.debug_aranges.section, dwarf, header_aw.written());
47554755 try unit_ptr.writeTrailer(&dwarf.debug_aranges.section, dwarf);
47564756 }
47574757 dwarf.debug_aranges.section.dirty = false;
......@@ -4790,7 +4790,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
47904790 hw.writeByte(@as(u8, DW.CFA.offset) + Register.rip.dwarfNum()) catch unreachable;
47914791 hw.writeUleb128(1) catch unreachable;
47924792 hw.splatByteAll(DW.CFA.nop, unit.header_len - hw.end) catch unreachable;
4793 try unit.replaceHeader(&dwarf.debug_frame.section, dwarf, header_aw.getWritten());
4793 try unit.replaceHeader(&dwarf.debug_frame.section, dwarf, header_aw.written());
47944794 try unit.writeTrailer(&dwarf.debug_frame.section, dwarf);
47954795 }
47964796 },
......@@ -4880,7 +4880,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
48804880 });
48814881 hw.splatByteAll(0, dwarf.sectionOffsetBytes()) catch unreachable;
48824882 hw.writeUleb128(0) catch unreachable;
4883 try unit_ptr.replaceHeader(&dwarf.debug_info.section, dwarf, header_aw.getWritten());
4883 try unit_ptr.replaceHeader(&dwarf.debug_info.section, dwarf, header_aw.written());
48844884 try unit_ptr.writeTrailer(&dwarf.debug_info.section, dwarf);
48854885 }
48864886 dwarf.debug_info.section.dirty = false;
......@@ -4997,7 +4997,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
49974997 });
49984998 hw.splatByteAll(0, dwarf.sectionOffsetBytes()) catch unreachable;
49994999 }
5000 try unit.replaceHeader(&dwarf.debug_line.section, dwarf, header_aw.getWritten());
5000 try unit.replaceHeader(&dwarf.debug_line.section, dwarf, header_aw.written());
50015001 try unit.writeTrailer(&dwarf.debug_line.section, dwarf);
50025002 }
50035003 dwarf.debug_line.section.dirty = false;
......@@ -5034,7 +5034,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (FlushError || Writer.Erro
50345034 .@"32" => hw.writeInt(u32, dwarf.sectionOffsetBytes() * 1, dwarf.endian) catch unreachable,
50355035 .@"64" => hw.writeInt(u64, dwarf.sectionOffsetBytes() * 1, dwarf.endian) catch unreachable,
50365036 }
5037 try unit.replaceHeader(&dwarf.debug_rnglists.section, dwarf, header_aw.getWritten());
5037 try unit.replaceHeader(&dwarf.debug_rnglists.section, dwarf, header_aw.written());
50385038 try unit.writeTrailer(&dwarf.debug_rnglists.section, dwarf);
50395039 }
50405040 dwarf.debug_rnglists.section.dirty = false;
src/link/Elf.zig+1-1
......@@ -3156,7 +3156,7 @@ fn writeSyntheticSections(self: *Elf) !void {
31563156 try aw.ensureUnusedCapacity(self.gnu_hash.size());
31573157 defer aw.deinit();
31583158 try self.gnu_hash.write(self, &aw.writer);
3159 try self.pwriteAll(aw.getWritten(), shdr.sh_offset);
3159 try self.pwriteAll(aw.written(), shdr.sh_offset);
31603160 }
31613161
31623162 if (self.section_indexes.versym) |shndx| {
src/link/SpirV.zig+1-1
......@@ -274,7 +274,7 @@ pub fn flush(
274274 ) catch return error.OutOfMemory;
275275 }
276276 try linker.module.sections.debug_strings.emit(gpa, .OpSourceExtension, .{
277 .extension = error_info.getWritten(),
277 .extension = error_info.written(),
278278 });
279279
280280 const module = try linker.module.finalize(arena);
src/main.zig+1-1
......@@ -7198,7 +7198,7 @@ fn cmdFetch(
71987198 var aw: std.Io.Writer.Allocating = .init(gpa);
71997199 defer aw.deinit();
72007200 try ast.render(gpa, &aw.writer, fixups);
7201 const rendered = aw.getWritten();
7201 const rendered = aw.written();
72027202
72037203 build_root.directory.handle.writeFile(.{ .sub_path = Package.Manifest.basename, .data = rendered }) catch |err| {
72047204 fatal("unable to write {s} file: {t}", .{ Package.Manifest.basename, err });