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 {
433433 defer ast.deinit(gpa);
434434
435435 const token_offsets = ast.tokens.items(.start);
436 var rendered_err: std.ArrayListUnmanaged(u8) = .{};
437 defer rendered_err.deinit(gpa);
436 var rendered_err: std.Io.Writer.Allocating = .init(gpa);
437 defer rendered_err.deinit();
438438 for (ast.errors) |err| {
439439 const err_offset = token_offsets[err.token] + ast.errorOffset(err);
440440 const err_loc = std.zig.findLineColumn(ast.source, err_offset);
441441 rendered_err.clearRetainingCapacity();
442 try ast.renderError(err, rendered_err.writer(gpa));
443 log.err("{s}:{d}:{d}: {s}", .{ file_name, err_loc.line + 1, err_loc.column + 1, rendered_err.items });
442 ast.renderError(err, &rendered_err.writer) catch |e| switch (e) {
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 });
444448 }
445449 return Ast.parse(gpa, "", .zig);
446450 }
lib/std/Io/Writer.zig+6
......@@ -2481,6 +2481,12 @@ pub const Allocating = struct {
24812481 return list.ensureUnusedCapacity(a.allocator, additional_count);
24822482 }
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
24842490 pub fn toOwnedSlice(a: *Allocating) error{OutOfMemory}![]u8 {
24852491 var list = a.toArrayList();
24862492 defer a.setArrayList(list);
lib/std/zig.zig+2-9
......@@ -530,18 +530,11 @@ test isUnderscore {
530530 try std.testing.expect(!isUnderscore("\\x5f"));
531531}
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 {
534534 var buffer: std.ArrayListAlignedUnmanaged(u8, .@"2") = .empty;
535535 defer buffer.deinit(gpa);
536536
537 try buffer.ensureUnusedCapacity(gpa, size_hint);
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 };
537 try file_reader.interface.appendRemaining(gpa, .@"2", &buffer, .limited(max_src_size));
545538
546539 // Detect unsupported file types with their Byte Order Mark
547540 const unsupported_boms = [_][]const u8{
lib/std/zig/AstGen.zig+28-22
......@@ -11278,10 +11278,14 @@ fn parseStrLit(
1127811278 offset: u32,
1127911279) InnerError!void {
1128011280 const raw_string = bytes[offset..];
11281 var buf_managed = buf.toManaged(astgen.gpa);
11282 const result = std.zig.string_literal.parseWrite(buf_managed.writer(), raw_string);
11283 buf.* = buf_managed.moveToUnmanaged();
11284 switch (try result) {
11281 const result = r: {
11282 var aw: std.io.Writer.Allocating = .fromArrayList(astgen.gpa, buf);
11283 defer buf.* = aw.toArrayList();
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) {
1128511289 .success => return,
1128611290 .failure => |err| return astgen.failWithStrLitError(err, token, bytes, offset),
1128711291 }
......@@ -11324,17 +11328,18 @@ fn appendErrorNodeNotes(
1132411328 notes: []const u32,
1132511329) Allocator.Error!void {
1132611330 @branchHint(.cold);
11331 const gpa = astgen.gpa;
1132711332 const string_bytes = &astgen.string_bytes;
1132811333 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);
1133011335 const notes_index: u32 = if (notes.len != 0) blk: {
1133111336 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);
1133311338 astgen.extra.appendAssumeCapacity(@intCast(notes.len));
1133411339 astgen.extra.appendSliceAssumeCapacity(notes);
1133511340 break :blk @intCast(notes_start);
1133611341 } else 0;
11337 try astgen.compile_errors.append(astgen.gpa, .{
11342 try astgen.compile_errors.append(gpa, .{
1133811343 .msg = msg,
1133911344 .node = node.toOptional(),
1134011345 .token = .none,
......@@ -11418,7 +11423,7 @@ fn appendErrorTokNotesOff(
1141811423 const gpa = astgen.gpa;
1141911424 const string_bytes = &astgen.string_bytes;
1142011425 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);
1142211427 const notes_index: u32 = if (notes.len != 0) blk: {
1142311428 const notes_start = astgen.extra.items.len;
1142411429 try astgen.extra.ensureTotalCapacity(gpa, notes_start + 1 + notes.len);
......@@ -11454,7 +11459,7 @@ fn errNoteTokOff(
1145411459 @branchHint(.cold);
1145511460 const string_bytes = &astgen.string_bytes;
1145611461 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);
1145811463 return astgen.addExtra(Zir.Inst.CompileErrors.Item{
1145911464 .msg = msg,
1146011465 .node = .none,
......@@ -11473,7 +11478,7 @@ fn errNoteNode(
1147311478 @branchHint(.cold);
1147411479 const string_bytes = &astgen.string_bytes;
1147511480 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);
1147711482 return astgen.addExtra(Zir.Inst.CompileErrors.Item{
1147811483 .msg = msg,
1147911484 .node = node.toOptional(),
......@@ -13715,13 +13720,14 @@ fn emitDbgStmtForceCurrentIndex(gz: *GenZir, lc: LineColumn) !void {
1371513720 } });
1371613721}
1371713722
13718fn lowerAstErrors(astgen: *AstGen) !void {
13723fn lowerAstErrors(astgen: *AstGen) error{OutOfMemory}!void {
1371913724 const gpa = astgen.gpa;
1372013725 const tree = astgen.tree;
1372113726 assert(tree.errors.len > 0);
1372213727
13723 var msg: std.ArrayListUnmanaged(u8) = .empty;
13724 defer msg.deinit(gpa);
13728 var msg: std.io.Writer.Allocating = .init(gpa);
13729 defer msg.deinit();
13730 const msg_w = &msg.writer;
1372513731
1372613732 var notes: std.ArrayListUnmanaged(u32) = .empty;
1372713733 defer notes.deinit(gpa);
......@@ -13749,26 +13755,26 @@ fn lowerAstErrors(astgen: *AstGen) !void {
1374913755 break :blk idx - tok_start;
1375013756 };
1375113757
13752 const err: Ast.Error = .{
13758 const ast_err: Ast.Error = .{
1375313759 .tag = Ast.Error.Tag.invalid_byte,
1375413760 .token = tok,
1375513761 .extra = .{ .offset = bad_off },
1375613762 };
1375713763 msg.clearRetainingCapacity();
13758 try tree.renderError(err, msg.writer(gpa));
13759 return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.items}, notes.items);
13764 tree.renderError(ast_err, msg_w) catch return error.OutOfMemory;
13765 return try astgen.appendErrorTokNotesOff(tok, bad_off, "{s}", .{msg.getWritten()}, notes.items);
1376013766 }
1376113767
1376213768 var cur_err = tree.errors[0];
1376313769 for (tree.errors[1..]) |err| {
1376413770 if (err.is_note) {
13765 try tree.renderError(err, msg.writer(gpa));
13766 try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.items}));
13771 tree.renderError(err, msg_w) catch return error.OutOfMemory;
13772 try notes.append(gpa, try astgen.errNoteTok(err.token, "{s}", .{msg.getWritten()}));
1376713773 } else {
1376813774 // Flush error
1376913775 const extra_offset = tree.errorOffset(cur_err);
13770 try tree.renderError(cur_err, msg.writer(gpa));
13771 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);
13776 tree.renderError(cur_err, msg_w) catch return error.OutOfMemory;
13777 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
1377213778 notes.clearRetainingCapacity();
1377313779 cur_err = err;
1377413780
......@@ -13781,8 +13787,8 @@ fn lowerAstErrors(astgen: *AstGen) !void {
1378113787
1378213788 // Flush error
1378313789 const extra_offset = tree.errorOffset(cur_err);
13784 try tree.renderError(cur_err, msg.writer(gpa));
13785 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.items}, notes.items);
13790 tree.renderError(cur_err, msg_w) catch return error.OutOfMemory;
13791 try astgen.appendErrorTokNotesOff(cur_err.token, extra_offset, "{s}", .{msg.getWritten()}, notes.items);
1378613792}
1378713793
1378813794const 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
53285328 var out_zig_file = try o_dir.createFile(cimport_zig_basename, .{});
53295329 defer out_zig_file.close();
53305330
5331 const formatted = try tree.render(comp.gpa);
5331 const formatted = try tree.renderAlloc(comp.gpa);
53325332 defer comp.gpa.free(formatted);
53335333
53345334 try out_zig_file.writeAll(formatted);
src/Package/Manifest.zig+8-4
......@@ -471,10 +471,14 @@ const Parse = struct {
471471 offset: u32,
472472 ) InnerError!void {
473473 const raw_string = bytes[offset..];
474 var buf_managed = buf.toManaged(p.gpa);
475 const result = std.zig.string_literal.parseWrite(buf_managed.writer(), raw_string);
476 buf.* = buf_managed.moveToUnmanaged();
477 switch (try result) {
474 const result = r: {
475 var aw: std.io.Writer.Allocating = .fromArrayList(p.gpa, buf);
476 defer buf.* = aw.toArrayList();
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) {
478482 .success => {},
479483 .failure => |err| try p.appendStrLitError(err, token, bytes, offset),
480484 }
src/fmt.zig+23-13
......@@ -34,7 +34,7 @@ const Fmt = struct {
3434 color: Color,
3535 gpa: Allocator,
3636 arena: Allocator,
37 out_buffer: std.ArrayList(u8),
37 out_buffer: std.Io.Writer.Allocating,
3838
3939 const SeenMap = std.AutoHashMap(fs.File.INode, void);
4040};
......@@ -102,7 +102,9 @@ pub fn run(
102102 }
103103
104104 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| {
106108 fatal("unable to read stdin: {}", .{err});
107109 };
108110 defer gpa.free(source_code);
......@@ -146,7 +148,7 @@ pub fn run(
146148 try std.zig.printAstErrorsToStderr(gpa, tree, "<stdin>", color);
147149 process.exit(2);
148150 }
149 const formatted = try tree.render(gpa);
151 const formatted = try tree.renderAlloc(gpa);
150152 defer gpa.free(formatted);
151153
152154 if (check_flag) {
......@@ -169,7 +171,7 @@ pub fn run(
169171 .check_ast = check_ast_flag,
170172 .force_zon = force_zon,
171173 .color = color,
172 .out_buffer = std.ArrayList(u8).init(gpa),
174 .out_buffer = .init(gpa),
173175 };
174176 defer fmt.seen.deinit();
175177 defer fmt.out_buffer.deinit();
......@@ -230,6 +232,9 @@ const FmtError = error{
230232 NetNameDeleted,
231233 InvalidArgument,
232234 ProcessNotFound,
235 ConnectionTimedOut,
236 NotOpenForReading,
237 StreamTooLong,
233238} || fs.File.OpenError;
234239
235240fn 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(
295300 if (stat.kind == .directory)
296301 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
298307 const gpa = fmt.gpa;
299 const source_code = try std.zig.readSourceFileToEndAlloc(
300 gpa,
301 source_file,
302 std.math.cast(usize, stat.size) orelse return error.FileTooBig,
303 );
308 const source_code = std.zig.readSourceFileToEndAlloc(gpa, &file_reader) catch |err| switch (err) {
309 error.ReadFailed => return file_reader.err.?,
310 else => |e| return e,
311 };
304312 defer gpa.free(source_code);
305313
306314 source_file.close();
......@@ -363,11 +371,13 @@ fn fmtPathFile(
363371 }
364372
365373 // 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();
367375 try fmt.out_buffer.ensureTotalCapacity(source_code.len);
368376
369 try tree.renderToArrayList(&fmt.out_buffer, .{});
370 if (mem.eql(u8, fmt.out_buffer.items, source_code))
377 tree.render(gpa, &fmt.out_buffer.writer, .{}) catch |err| switch (err) {
378 error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
379 };
380 if (mem.eql(u8, fmt.out_buffer.getWritten(), source_code))
371381 return;
372382
373383 if (check_mode) {
......@@ -378,7 +388,7 @@ fn fmtPathFile(
378388 var af = try dir.atomicFile(sub_path, .{ .mode = stat.mode });
379389 defer af.deinit();
380390
381 try af.file.writeAll(fmt.out_buffer.items);
391 try af.file.writeAll(fmt.out_buffer.getWritten());
382392 try af.finish();
383393 const stdout = std.fs.File.stdout().deprecatedWriter();
384394 try stdout.print("{s}\n", .{file_path});
src/main.zig+14-10
......@@ -4550,7 +4550,7 @@ fn cmdTranslateC(
45504550 error.SemanticAnalyzeFail => break :f .{ .error_bundle = errors },
45514551 };
45524552 defer tree.deinit(comp.gpa);
4553 break :f .{ .success = try tree.render(arena) };
4553 break :f .{ .success = try tree.renderAlloc(arena) };
45544554 },
45554555 };
45564556
......@@ -6058,7 +6058,8 @@ fn cmdAstCheck(
60586058 };
60596059 } else fs.File.stdin();
60606060 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| {
60626063 fatal("unable to load file '{s}' for ast-check: {s}", .{ display_path, @errorName(err) });
60636064 };
60646065 };
......@@ -6416,14 +6417,16 @@ fn cmdChangelist(
64166417 var f = fs.cwd().openFile(old_source_path, .{}) catch |err|
64176418 fatal("unable to open old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
64186419 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|
64206422 fatal("unable to read old source file '{s}': {s}", .{ old_source_path, @errorName(err) });
64216423 };
64226424 const new_source = source: {
64236425 var f = fs.cwd().openFile(new_source_path, .{}) catch |err|
64246426 fatal("unable to open new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
64256427 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|
64276430 fatal("unable to read new source file '{s}': {s}", .{ new_source_path, @errorName(err) });
64286431 };
64296432
......@@ -6946,7 +6949,7 @@ fn cmdFetch(
69466949 ast.deinit(gpa);
69476950 }
69486951
6949 var fixups: Ast.Fixups = .{};
6952 var fixups: Ast.Render.Fixups = .{};
69506953 defer fixups.deinit(gpa);
69516954
69526955 var saved_path_or_url = path_or_url;
......@@ -7047,12 +7050,13 @@ fn cmdFetch(
70477050 try fixups.append_string_after_node.put(gpa, manifest.version_node, dependencies_text);
70487051 }
70497052
7050 var rendered = std.ArrayList(u8).init(gpa);
7051 defer rendered.deinit();
7052 try ast.renderToArrayList(&rendered, fixups);
7053 var aw: std.Io.Writer.Allocating = .init(gpa);
7054 defer aw.deinit();
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| {
7055 fatal("unable to write {s} file: {s}", .{ Package.Manifest.basename, @errorName(err) });
7058 build_root.directory.handle.writeFile(.{ .sub_path = Package.Manifest.basename, .data = rendered }) catch |err| {
7059 fatal("unable to write {s} file: {t}", .{ Package.Manifest.basename, err });
70567060 };
70577061
70587062 return cleanExit();
tools/gen_spirv_spec.zig+1-1
......@@ -120,7 +120,7 @@ pub fn main() !void {
120120 error_bundle.renderToStdErr(color.renderOptions());
121121 }
122122
123 const formatted_output = try tree.render(allocator);
123 const formatted_output = try tree.renderAlloc(allocator);
124124 _ = try std.fs.File.stdout().write(formatted_output);
125125}
126126