authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-15 23:38:18-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-16 17:20:02-07:00
logc4776d66af3cec54a6f87337da714d388aa866da
tree4289adff4e2cf03f066ee09340f721f1fd2b921d
parentb3ee5a6c303998e82cdf95bd522bd9769c3d1911

update compiler

9 files changed, 91 insertions(+), 64 deletions(-)

lib/docs/wasm/Walk.zig+8-4
...@@ -433,14 +433,18 @@ fn parse(file_name: []const u8, source: []u8) Oom!Ast {...@@ -433,14 +433,18 @@ fn parse(file_name: []const u8, source: []u8) Oom!Ast {
433 defer ast.deinit(gpa);433 defer ast.deinit(gpa);
434434
435 const token_offsets = ast.tokens.items(.start);435 const token_offsets = ast.tokens.items(.start);
436 var rendered_err: std.ArrayListUnmanaged(u8) = .{};436 var rendered_err: std.Io.Writer.Allocating = .init(gpa);
437 defer rendered_err.deinit(gpa);437 defer rendered_err.deinit();
438 for (ast.errors) |err| {438 for (ast.errors) |err| {
439 const err_offset = token_offsets[err.token] + ast.errorOffset(err);439 const err_offset = token_offsets[err.token] + ast.errorOffset(err);
440 const err_loc = std.zig.findLineColumn(ast.source, err_offset);440 const err_loc = std.zig.findLineColumn(ast.source, err_offset);
441 rendered_err.clearRetainingCapacity();441 rendered_err.clearRetainingCapacity();
442 try ast.renderError(err, rendered_err.writer(gpa));442 ast.renderError(err, &rendered_err.writer) catch |e| switch (e) {
443 log.err("{s}:{d}:{d}: {s}", .{ file_name, err_loc.line + 1, err_loc.column + 1, rendered_err.items });443 error.WriteFailed => return error.OutOfMemory,
444 };
445 log.err("{s}:{d}:{d}: {s}", .{
446 file_name, err_loc.line + 1, err_loc.column + 1, rendered_err.getWritten(),
447 });
444 }448 }
445 return Ast.parse(gpa, "", .zig);449 return Ast.parse(gpa, "", .zig);
446 }450 }
lib/std/Io/Writer.zig+6
...@@ -2481,6 +2481,12 @@ pub const Allocating = struct {...@@ -2481,6 +2481,12 @@ pub const Allocating = struct {
2481 return list.ensureUnusedCapacity(a.allocator, additional_count);2481 return list.ensureUnusedCapacity(a.allocator, additional_count);
2482 }2482 }
24832483
2484 pub fn ensureTotalCapacity(a: *Allocating, new_capacity: usize) Allocator.Error!void {
2485 var list = a.toArrayList();
2486 defer a.setArrayList(list);
2487 return list.ensureTotalCapacity(a.allocator, new_capacity);
2488 }
2489
2484 pub fn toOwnedSlice(a: *Allocating) error{OutOfMemory}![]u8 {2490 pub fn toOwnedSlice(a: *Allocating) error{OutOfMemory}![]u8 {
2485 var list = a.toArrayList();2491 var list = a.toArrayList();
2486 defer a.setArrayList(list);2492 defer a.setArrayList(list);
lib/std/zig.zig+2-9
...@@ -530,18 +530,11 @@ test isUnderscore {...@@ -530,18 +530,11 @@ test isUnderscore {
530 try std.testing.expect(!isUnderscore("\\x5f"));530 try std.testing.expect(!isUnderscore("\\x5f"));
531}531}
532532
533pub fn readSourceFileToEndAlloc(gpa: Allocator, input: std.fs.File, size_hint: usize) ![:0]u8 {533pub fn readSourceFileToEndAlloc(gpa: Allocator, file_reader: *std.fs.File.Reader) ![:0]u8 {
534 var buffer: std.ArrayListAlignedUnmanaged(u8, .@"2") = .empty;534 var buffer: std.ArrayListAlignedUnmanaged(u8, .@"2") = .empty;
535 defer buffer.deinit(gpa);535 defer buffer.deinit(gpa);
536536
537 try buffer.ensureUnusedCapacity(gpa, size_hint);537 try file_reader.interface.appendRemaining(gpa, .@"2", &buffer, .limited(max_src_size));
538
539 input.readIntoArrayList(gpa, .limited(max_src_size), .@"2", &buffer) catch |err| switch (err) {
540 error.ConnectionResetByPeer => unreachable,
541 error.ConnectionTimedOut => unreachable,
542 error.NotOpenForReading => unreachable,
543 else => |e| return e,
544 };
545538
546 // Detect unsupported file types with their Byte Order Mark539 // Detect unsupported file types with their Byte Order Mark
547 const unsupported_boms = [_][]const u8{540 const unsupported_boms = [_][]const u8{
lib/std/zig/AstGen.zig+28-22
...@@ -11278,10 +11278,14 @@ fn parseStrLit(...@@ -11278,10 +11278,14 @@ fn parseStrLit(
11278 offset: u32,11278 offset: u32,
11279) InnerError!void {11279) InnerError!void {
11280 const raw_string = bytes[offset..];11280 const raw_string = bytes[offset..];
11281 var buf_managed = buf.toManaged(astgen.gpa);11281 const result = r: {
11282 const result = std.zig.string_literal.parseWrite(buf_managed.writer(), raw_string);11282 var aw: std.io.Writer.Allocating = .fromArrayList(astgen.gpa, buf);
11283 buf.* = buf_managed.moveToUnmanaged();11283 defer buf.* = aw.toArrayList();
11284 switch (try result) {11284 break :r std.zig.string_literal.parseWrite(&aw.writer, raw_string) catch |err| switch (err) {
11285 error.WriteFailed => return error.OutOfMemory,
11286 };
11287 };
11288 switch (result) {
11285 .success => return,11289 .success => return,
11286 .failure => |err| return astgen.failWithStrLitError(err, token, bytes, offset),11290 .failure => |err| return astgen.failWithStrLitError(err, token, bytes, offset),
11287 }11291 }
...@@ -11324,17 +11328,18 @@ fn appendErrorNodeNotes(...@@ -11324,17 +11328,18 @@ fn appendErrorNodeNotes(
11324 notes: []const u32,11328 notes: []const u32,
11325) Allocator.Error!void {11329) Allocator.Error!void {
11326 @branchHint(.cold);11330 @branchHint(.cold);
11331 const gpa = astgen.gpa;
11327 const string_bytes = &astgen.string_bytes;11332 const string_bytes = &astgen.string_bytes;
11328 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);11333 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
11329 try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);11334 try string_bytes.print(gpa, format ++ "\x00", args);
11330 const notes_index: u32 = if (notes.len != 0) blk: {11335 const notes_index: u32 = if (notes.len != 0) blk: {
11331 const notes_start = astgen.extra.items.len;11336 const notes_start = astgen.extra.items.len;
11332 try astgen.extra.ensureTotalCapacity(astgen.gpa, notes_start + 1 + notes.len);11337 try astgen.extra.ensureTotalCapacity(gpa, notes_start + 1 + notes.len);
11333 astgen.extra.appendAssumeCapacity(@intCast(notes.len));11338 astgen.extra.appendAssumeCapacity(@intCast(notes.len));
11334 astgen.extra.appendSliceAssumeCapacity(notes);11339 astgen.extra.appendSliceAssumeCapacity(notes);
11335 break :blk @intCast(notes_start);11340 break :blk @intCast(notes_start);
11336 } else 0;11341 } else 0;
11337 try astgen.compile_errors.append(astgen.gpa, .{11342 try astgen.compile_errors.append(gpa, .{
11338 .msg = msg,11343 .msg = msg,
11339 .node = node.toOptional(),11344 .node = node.toOptional(),
11340 .token = .none,11345 .token = .none,
...@@ -11418,7 +11423,7 @@ fn appendErrorTokNotesOff(...@@ -11418,7 +11423,7 @@ fn appendErrorTokNotesOff(
11418 const gpa = astgen.gpa;11423 const gpa = astgen.gpa;
11419 const string_bytes = &astgen.string_bytes;11424 const string_bytes = &astgen.string_bytes;
11420 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);11425 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
11421 try string_bytes.writer(gpa).print(format ++ "\x00", args);11426 try string_bytes.print(gpa, format ++ "\x00", args);
11422 const notes_index: u32 = if (notes.len != 0) blk: {11427 const notes_index: u32 = if (notes.len != 0) blk: {
11423 const notes_start = astgen.extra.items.len;11428 const notes_start = astgen.extra.items.len;
11424 try astgen.extra.ensureTotalCapacity(gpa, notes_start + 1 + notes.len);11429 try astgen.extra.ensureTotalCapacity(gpa, notes_start + 1 + notes.len);
...@@ -11454,7 +11459,7 @@ fn errNoteTokOff(...@@ -11454,7 +11459,7 @@ fn errNoteTokOff(
11454 @branchHint(.cold);11459 @branchHint(.cold);
11455 const string_bytes = &astgen.string_bytes;11460 const string_bytes = &astgen.string_bytes;
11456 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);11461 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
11457 try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);11462 try string_bytes.print(astgen.gpa, format ++ "\x00", args);
11458 return astgen.addExtra(Zir.Inst.CompileErrors.Item{11463 return astgen.addExtra(Zir.Inst.CompileErrors.Item{
11459 .msg = msg,11464 .msg = msg,
11460 .node = .none,11465 .node = .none,
...@@ -11473,7 +11478,7 @@ fn errNoteNode(...@@ -11473,7 +11478,7 @@ fn errNoteNode(
11473 @branchHint(.cold);11478 @branchHint(.cold);
11474 const string_bytes = &astgen.string_bytes;11479 const string_bytes = &astgen.string_bytes;
11475 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);11480 const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len);
11476 try string_bytes.writer(astgen.gpa).print(format ++ "\x00", args);11481 try string_bytes.print(astgen.gpa, format ++ "\x00", args);
11477 return astgen.addExtra(Zir.Inst.CompileErrors.Item{11482 return astgen.addExtra(Zir.Inst.CompileErrors.Item{
11478 .msg = msg,11483 .msg = msg,
11479 .node = node.toOptional(),11484 .node = node.toOptional(),
...@@ -13715,13 +13720,14 @@ fn emitDbgStmtForceCurrentIndex(gz: *GenZir, lc: LineColumn) !void {...@@ -13715,13 +13720,14 @@ fn emitDbgStmtForceCurrentIndex(gz: *GenZir, lc: LineColumn) !void {
13715 } });13720 } });
13716}13721}
1371713722
13718fn lowerAstErrors(astgen: *AstGen) !void {13723fn lowerAstErrors(astgen: *AstGen) error{OutOfMemory}!void {
13719 const gpa = astgen.gpa;13724 const gpa = astgen.gpa;
13720 const tree = astgen.tree;13725 const tree = astgen.tree;
13721 assert(tree.errors.len > 0);13726 assert(tree.errors.len > 0);
1372213727
13723 var msg: std.ArrayListUnmanaged(u8) = .empty;13728 var msg: std.io.Writer.Allocating = .init(gpa);
13724 defer msg.deinit(gpa);13729 defer msg.deinit();
13730 const msg_w = &msg.writer;
1372513731
13726 var notes: std.ArrayListUnmanaged(u32) = .empty;13732 var notes: std.ArrayListUnmanaged(u32) = .empty;
13727 defer notes.deinit(gpa);13733 defer notes.deinit(gpa);
...@@ -13749,26 +13755,26 @@ fn lowerAstErrors(astgen: *AstGen) !void {...@@ -13749,26 +13755,26 @@ fn lowerAstErrors(astgen: *AstGen) !void {
13749 break :blk idx - tok_start;13755 break :blk idx - tok_start;
13750 };13756 };
1375113757
13752 const err: Ast.Error = .{13758 const ast_err: Ast.Error = .{
13753 .tag = Ast.Error.Tag.invalid_byte,13759 .tag = Ast.Error.Tag.invalid_byte,
13754 .token = tok,13760 .token = tok,
13755 .extra = .{ .offset = bad_off },13761 .extra = .{ .offset = bad_off },
13756 };13762 };
13757 msg.clearRetainingCapacity();13763 msg.clearRetainingCapacity();
13758 try tree.renderError(err, msg.writer(gpa));13764 tree.renderError(ast_err, msg_w) catch return error.OutOfMemory;
13759 return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.items}, notes.items);13765 return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.getWritten()}, notes.items);
13760 }13766 }
1376113767
13762 var cur_err = tree.errors[0];13768 var cur_err = tree.errors[0];
13763 for (tree.errors[1..]) |err| {13769 for (tree.errors[1..]) |err| {
13764 if (err.is_note) {13770 if (err.is_note) {
13765 try tree.renderError(err, msg.writer(gpa));13771 tree.renderError(err, msg_w) catch return error.OutOfMemory;
13766 try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.items}));13772 try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.getWritten()}));
13767 } else {13773 } else {
13768 // Flush error13774 // Flush error
13769 const extra_offset = tree.errorOffset(cur_err);13775 const extra_offset = tree.errorOffset(cur_err);
13770 try tree.renderError(cur_err, msg.writer(gpa));13776 tree.renderError(cur_err, msg_w) catch return error.OutOfMemory;
13771 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);13777 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
13772 notes.clearRetainingCapacity();13778 notes.clearRetainingCapacity();
13773 cur_err = err;13779 cur_err = err;
1377413780
...@@ -13781,8 +13787,8 @@ fn lowerAstErrors(astgen: *AstGen) !void {...@@ -13781,8 +13787,8 @@ fn lowerAstErrors(astgen: *AstGen) !void {
1378113787
13782 // Flush error13788 // Flush error
13783 const extra_offset = tree.errorOffset(cur_err);13789 const extra_offset = tree.errorOffset(cur_err);
13784 try tree.renderError(cur_err, msg.writer(gpa));13790 tree.renderError(cur_err, msg_w) catch return error.OutOfMemory;
13785 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);13791 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
13786}13792}
1378713793
13788const DeclarationName = union(enum) {13794const DeclarationName = union(enum) {
src/Compilation.zig+1-1
...@@ -5328,7 +5328,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module...@@ -5328,7 +5328,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module
5328 var out_zig_file = try o_dir.createFile(cimport_zig_basename, .{});5328 var out_zig_file = try o_dir.createFile(cimport_zig_basename, .{});
5329 defer out_zig_file.close();5329 defer out_zig_file.close();
53305330
5331 const formatted = try tree.render(comp.gpa);5331 const formatted = try tree.renderAlloc(comp.gpa);
5332 defer comp.gpa.free(formatted);5332 defer comp.gpa.free(formatted);
53335333
5334 try out_zig_file.writeAll(formatted);5334 try out_zig_file.writeAll(formatted);
src/Package/Manifest.zig+8-4
...@@ -471,10 +471,14 @@ const Parse = struct {...@@ -471,10 +471,14 @@ const Parse = struct {
471 offset: u32,471 offset: u32,
472 ) InnerError!void {472 ) InnerError!void {
473 const raw_string = bytes[offset..];473 const raw_string = bytes[offset..];
474 var buf_managed = buf.toManaged(p.gpa);474 const result = r: {
475 const result = std.zig.string_literal.parseWrite(buf_managed.writer(), raw_string);475 var aw: std.io.Writer.Allocating = .fromArrayList(p.gpa, buf);
476 buf.* = buf_managed.moveToUnmanaged();476 defer buf.* = aw.toArrayList();
477 switch (try result) {477 break :r std.zig.string_literal.parseWrite(&aw.writer, raw_string) catch |err| switch (err) {
478 error.WriteFailed => return error.OutOfMemory,
479 };
480 };
481 switch (result) {
478 .success => {},482 .success => {},
479 .failure => |err| try p.appendStrLitError(err, token, bytes, offset),483 .failure => |err| try p.appendStrLitError(err, token, bytes, offset),
480 }484 }
src/fmt.zig+23-13
...@@ -34,7 +34,7 @@ const Fmt = struct {...@@ -34,7 +34,7 @@ const Fmt = struct {
34 color: Color,34 color: Color,
35 gpa: Allocator,35 gpa: Allocator,
36 arena: Allocator,36 arena: Allocator,
37 out_buffer: std.ArrayList(u8),37 out_buffer: std.Io.Writer.Allocating,
3838
39 const SeenMap = std.AutoHashMap(fs.File.INode, void);39 const SeenMap = std.AutoHashMap(fs.File.INode, void);
40};40};
...@@ -102,7 +102,9 @@ pub fn run(...@@ -102,7 +102,9 @@ pub fn run(
102 }102 }
103103
104 const stdin: fs.File = .stdin();104 const stdin: fs.File = .stdin();
105 const source_code = std.zig.readSourceFileToEndAlloc(gpa, stdin, null) catch |err| {105 var stdio_buffer: [1024]u8 = undefined;
106 var file_reader: fs.File.Reader = stdin.reader(&stdio_buffer);
107 const source_code = std.zig.readSourceFileToEndAlloc(gpa, &file_reader) catch |err| {
106 fatal("unable to read stdin: {}", .{err});108 fatal("unable to read stdin: {}", .{err});
107 };109 };
108 defer gpa.free(source_code);110 defer gpa.free(source_code);
...@@ -146,7 +148,7 @@ pub fn run(...@@ -146,7 +148,7 @@ pub fn run(
146 try std.zig.printAstErrorsToStderr(gpa, tree, "<stdin>", color);148 try std.zig.printAstErrorsToStderr(gpa, tree, "<stdin>", color);
147 process.exit(2);149 process.exit(2);
148 }150 }
149 const formatted = try tree.render(gpa);151 const formatted = try tree.renderAlloc(gpa);
150 defer gpa.free(formatted);152 defer gpa.free(formatted);
151153
152 if (check_flag) {154 if (check_flag) {
...@@ -169,7 +171,7 @@ pub fn run(...@@ -169,7 +171,7 @@ pub fn run(
169 .check_ast = check_ast_flag,171 .check_ast = check_ast_flag,
170 .force_zon = force_zon,172 .force_zon = force_zon,
171 .color = color,173 .color = color,
172 .out_buffer = std.ArrayList(u8).init(gpa),174 .out_buffer = .init(gpa),
173 };175 };
174 defer fmt.seen.deinit();176 defer fmt.seen.deinit();
175 defer fmt.out_buffer.deinit();177 defer fmt.out_buffer.deinit();
...@@ -230,6 +232,9 @@ const FmtError = error{...@@ -230,6 +232,9 @@ const FmtError = error{
230 NetNameDeleted,232 NetNameDeleted,
231 InvalidArgument,233 InvalidArgument,
232 ProcessNotFound,234 ProcessNotFound,
235 ConnectionTimedOut,
236 NotOpenForReading,
237 StreamTooLong,
233} || fs.File.OpenError;238} || fs.File.OpenError;
234239
235fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) FmtError!void {240fn fmtPath(fmt: *Fmt, file_path: []const u8, check_mode: bool, dir: fs.Dir, sub_path: []const u8) FmtError!void {
...@@ -295,12 +300,15 @@ fn fmtPathFile(...@@ -295,12 +300,15 @@ fn fmtPathFile(
295 if (stat.kind == .directory)300 if (stat.kind == .directory)
296 return error.IsDir;301 return error.IsDir;
297302
303 var read_buffer: [1024]u8 = undefined;
304 var file_reader: fs.File.Reader = source_file.reader(&read_buffer);
305 file_reader.size = stat.size;
306
298 const gpa = fmt.gpa;307 const gpa = fmt.gpa;
299 const source_code = try std.zig.readSourceFileToEndAlloc(308 const source_code = std.zig.readSourceFileToEndAlloc(gpa, &file_reader) catch |err| switch (err) {
300 gpa,309 error.ReadFailed => return file_reader.err.?,
301 source_file,310 else => |e| return e,
302 std.math.cast(usize, stat.size) orelse return error.FileTooBig,311 };
303 );
304 defer gpa.free(source_code);312 defer gpa.free(source_code);
305313
306 source_file.close();314 source_file.close();
...@@ -363,11 +371,13 @@ fn fmtPathFile(...@@ -363,11 +371,13 @@ fn fmtPathFile(
363 }371 }
364372
365 // As a heuristic, we make enough capacity for the same as the input source.373 // As a heuristic, we make enough capacity for the same as the input source.
366 fmt.out_buffer.shrinkRetainingCapacity(0);374 fmt.out_buffer.clearRetainingCapacity();
367 try fmt.out_buffer.ensureTotalCapacity(source_code.len);375 try fmt.out_buffer.ensureTotalCapacity(source_code.len);
368376
369 try tree.renderToArrayList(&fmt.out_buffer, .{});377 tree.render(gpa, &fmt.out_buffer.writer, .{}) catch |err| switch (err) {
370 if (mem.eql(u8, fmt.out_buffer.items, source_code))378 error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
379 };
380 if (mem.eql(u8, fmt.out_buffer.getWritten(), source_code))
371 return;381 return;
372382
373 if (check_mode) {383 if (check_mode) {
...@@ -378,7 +388,7 @@ fn fmtPathFile(...@@ -378,7 +388,7 @@ fn fmtPathFile(
378 var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode });388 var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode });
379 defer af.deinit();389 defer af.deinit();
380390
381 try af.file.writeAll(fmt.out_buffer.items);391 try af.file.writeAll(fmt.out_buffer.getWritten());
382 try af.finish();392 try af.finish();
383 const stdout = std.fs.File.stdout().deprecatedWriter();393 const stdout = std.fs.File.stdout().deprecatedWriter();
384 try stdout.print("{s}\n", .{file_path});394 try stdout.print("{s}\n", .{file_path});
src/main.zig+14-10
...@@ -4550,7 +4550,7 @@ fn cmdTranslateC(...@@ -4550,7 +4550,7 @@ fn cmdTranslateC(
4550 error.SemanticAnalyzeFail => break :f .{ .error_bundle = errors },4550 error.SemanticAnalyzeFail => break :f .{ .error_bundle = errors },
4551 };4551 };
4552 defer tree.deinit(comp.gpa);4552 defer tree.deinit(comp.gpa);
4553 break :f .{ .success = try tree.render(arena) };4553 break :f .{ .success = try tree.renderAlloc(arena) };
4554 },4554 },
4555 };4555 };
45564556
...@@ -6058,7 +6058,8 @@ fn cmdAstCheck(...@@ -6058,7 +6058,8 @@ fn cmdAstCheck(
6058 };6058 };
6059 } else fs.File.stdin();6059 } else fs.File.stdin();
6060 defer if (zig_source_path != null) f.close();6060 defer if (zig_source_path != null) f.close();
6061 break :s std.zig.readSourceFileToEndAlloc(arena, f, null) catch |err| {6061 var file_reader: fs.File.Reader = f.reader(&stdio_buffer);
6062 break :s std.zig.readSourceFileToEndAlloc(arena, &file_reader) catch |err| {
6062 fatal("unable to load file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });6063 fatal("unable to load file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });
6063 };6064 };
6064 };6065 };
...@@ -6416,14 +6417,16 @@ fn cmdChangelist(...@@ -6416,14 +6417,16 @@ fn cmdChangelist(
6416 var f = fs.cwd().openFile(old_source_path, .{}) catch |err|6417 var f = fs.cwd().openFile(old_source_path, .{}) catch |err|
6417 fatal("unable to open old source file '{s}': {s}", .{ old_source_path, @errorName(err) });6418 fatal("unable to open old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
6418 defer f.close();6419 defer f.close();
6419 break :source std.zig.readSourceFileToEndAlloc(arena, f, std.zig.max_src_size) catch |err|6420 var file_reader: fs.File.Reader = f.reader(&stdio_buffer);
6421 break :source std.zig.readSourceFileToEndAlloc(arena, &file_reader) catch |err|
6420 fatal("unable to read old source file '{s}': {s}", .{ old_source_path, @errorName(err) });6422 fatal("unable to read old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
6421 };6423 };
6422 const new_source = source: {6424 const new_source = source: {
6423 var f = fs.cwd().openFile(new_source_path, .{}) catch |err|6425 var f = fs.cwd().openFile(new_source_path, .{}) catch |err|
6424 fatal("unable to open new source file '{s}': {s}", .{ new_source_path, @errorName(err) });6426 fatal("unable to open new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
6425 defer f.close();6427 defer f.close();
6426 break :source std.zig.readSourceFileToEndAlloc(arena, f, std.zig.max_src_size) catch |err|6428 var file_reader: fs.File.Reader = f.reader(&stdio_buffer);
6429 break :source std.zig.readSourceFileToEndAlloc(arena, &file_reader) catch |err|
6427 fatal("unable to read new source file '{s}': {s}", .{ new_source_path, @errorName(err) });6430 fatal("unable to read new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
6428 };6431 };
64296432
...@@ -6946,7 +6949,7 @@ fn cmdFetch(...@@ -6946,7 +6949,7 @@ fn cmdFetch(
6946 ast.deinit(gpa);6949 ast.deinit(gpa);
6947 }6950 }
69486951
6949 var fixups: Ast.Fixups = .{};6952 var fixups: Ast.Render.Fixups = .{};
6950 defer fixups.deinit(gpa);6953 defer fixups.deinit(gpa);
69516954
6952 var saved_path_or_url = path_or_url;6955 var saved_path_or_url = path_or_url;
...@@ -7047,12 +7050,13 @@ fn cmdFetch(...@@ -7047,12 +7050,13 @@ fn cmdFetch(
7047 try fixups.append_string_after_node.put(gpa, manifest.version_node, dependencies_text);7050 try fixups.append_string_after_node.put(gpa, manifest.version_node, dependencies_text);
7048 }7051 }
70497052
7050 var rendered = std.ArrayList(u8).init(gpa);7053 var aw: std.Io.Writer.Allocating = .init(gpa);
7051 defer rendered.deinit();7054 defer aw.deinit();
7052 try ast.renderToArrayList(&rendered, fixups);7055 try ast.render(gpa, &aw.writer, fixups);
7056 const rendered = aw.getWritten();
70537057
7054 build_root.directory.handle.writeFile(.{ .sub_path = Package.Manifest.basename, .data = rendered.items }) catch |err| {7058 build_root.directory.handle.writeFile(.{ .sub_path = Package.Manifest.basename, .data = rendered }) catch |err| {
7055 fatal("unable to write {s} file: {s}", .{ Package.Manifest.basename, @errorName(err) });7059 fatal("unable to write {s} file: {t}", .{ Package.Manifest.basename, err });
7056 };7060 };
70577061
7058 return cleanExit();7062 return cleanExit();
tools/gen_spirv_spec.zig+1-1
...@@ -120,7 +120,7 @@ pub fn main() !void {...@@ -120,7 +120,7 @@ pub fn main() !void {
120 error_bundle.renderToStdErr(color.renderOptions());120 error_bundle.renderToStdErr(color.renderOptions());
121 }121 }
122122
123 const formatted_output = try tree.render(allocator);123 const formatted_output = try tree.renderAlloc(allocator);
124 _ = try std.fs.File.stdout().write(formatted_output);124 _ = try std.fs.File.stdout().write(formatted_output);
125}125}
126126