authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-16 18:57:55-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-16 18:57:55-07:00
logfbf8b16ae61ae81ca14027973f3f9366b39a2389
treec30bf2207be569563331dd676a41c6298188c595
parent51ebebcea36bcc960e8f0f7ef17d795eb46ce1ce

sync

7 files changed, 63 insertions(+), 63 deletions(-)

lib/std/zig.zig+6-8
......@@ -530,18 +530,16 @@ 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);
537 if (file_reader.getSize()) |size| {
538 const casted_size = std.math.cast(u32, size) orelse return error.StreamTooLong;
539 try buffer.ensureTotalCapacityPrecise(gpa, casted_size);
540 } else |_| {}
538541
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 };
542 try file_reader.interface.appendRemaining(gpa, .@"2", &buffer, .limited(max_src_size));
545543
546544 // Detect unsupported file types with their Byte Order Mark
547545 const unsupported_boms = [_][]const u8{
lib/std/zig/Ast.zig+2-2
......@@ -207,7 +207,7 @@ pub fn renderAlloc(tree: Ast, gpa: Allocator) error{OutOfMemory}![]u8 {
207207 var aw: std.io.Writer.Allocating = .init(gpa);
208208 defer aw.deinit();
209209 render(tree, gpa, &aw.writer, .{}) catch |err| switch (err) {
210 error.WriteFailed => return error.OutOfMemory,
210 error.WriteFailed, error.OutOfMemory => return error.OutOfMemory,
211211 };
212212 return aw.toOwnedSlice();
213213}
......@@ -215,7 +215,7 @@ pub fn renderAlloc(tree: Ast, gpa: Allocator) error{OutOfMemory}![]u8 {
215215pub const Render = @import("Ast/Render.zig");
216216
217217pub fn render(tree: Ast, gpa: Allocator, w: *Writer, fixups: Render.Fixups) Render.Error!void {
218 return Render.tree(gpa, w, tree, fixups);
218 return Render.renderTree(gpa, w, tree, fixups);
219219}
220220
221221/// Returns an extra offset for column and byte offset of errors that
lib/std/zig/Ast/Render.zig+16-16
......@@ -2399,24 +2399,24 @@ fn renderAsmLegacy(
23992399 try renderToken(r, first_clobber - 2, .none);
24002400 try renderToken(r, first_clobber - 1, .space);
24012401
2402 try ais.writer().writeAll(".{ ");
2402 try ais.writeAll(".{ ");
24032403
24042404 var tok_i = first_clobber;
24052405 while (true) : (tok_i += 1) {
2406 try ais.writer().writeByte('.');
2406 try ais.writeByte('.');
24072407 _ = try writeStringLiteralAsIdentifier(r, tok_i);
2408 try ais.writer().writeAll(" = true");
2408 try ais.writeAll(" = true");
24092409
24102410 tok_i += 1;
24112411 switch (tree.tokenTag(tok_i)) {
24122412 .r_paren => {
2413 try ais.writer().writeAll(" }");
2413 try ais.writeAll(" }");
24142414 ais.popIndent();
24152415 return renderToken(r, tok_i, space);
24162416 },
24172417 .comma => {
24182418 if (tree.tokenTag(tok_i + 1) == .r_paren) {
2419 try ais.writer().writeAll(" }");
2419 try ais.writeAll(" }");
24202420 ais.popIndent();
24212421 return renderToken(r, tok_i + 1, space);
24222422 } else {
......@@ -2511,16 +2511,16 @@ fn renderAsmLegacy(
25112511 };
25122512
25132513 try renderToken(r, colon3, .space); // :
2514 try ais.writer().writeAll(".{ ");
2514 try ais.writeAll(".{ ");
25152515 const first_clobber = asm_node.first_clobber.?;
25162516 var tok_i = first_clobber;
25172517 while (true) {
25182518 switch (tree.tokenTag(tok_i + 1)) {
25192519 .r_paren => {
25202520 ais.setIndentDelta(indent_delta);
2521 try ais.writer().writeByte('.');
2521 try ais.writeByte('.');
25222522 const lexeme_len = try writeStringLiteralAsIdentifier(r, tok_i);
2523 try ais.writer().writeAll(" = true }");
2523 try ais.writeAll(" = true }");
25242524 try renderSpace(r, tok_i, lexeme_len, .newline);
25252525 ais.popIndent();
25262526 return renderToken(r, tok_i + 1, space);
......@@ -2529,17 +2529,17 @@ fn renderAsmLegacy(
25292529 switch (tree.tokenTag(tok_i + 2)) {
25302530 .r_paren => {
25312531 ais.setIndentDelta(indent_delta);
2532 try ais.writer().writeByte('.');
2532 try ais.writeByte('.');
25332533 const lexeme_len = try writeStringLiteralAsIdentifier(r, tok_i);
2534 try ais.writer().writeAll(" = true }");
2534 try ais.writeAll(" = true }");
25352535 try renderSpace(r, tok_i, lexeme_len, .newline);
25362536 ais.popIndent();
25372537 return renderToken(r, tok_i + 2, space);
25382538 },
25392539 else => {
2540 try ais.writer().writeByte('.');
2540 try ais.writeByte('.');
25412541 _ = try writeStringLiteralAsIdentifier(r, tok_i);
2542 try ais.writer().writeAll(" = true");
2542 try ais.writeAll(" = true");
25432543 try renderToken(r, tok_i + 1, .space);
25442544 tok_i += 2;
25452545 },
......@@ -2827,7 +2827,7 @@ fn renderSpace(r: *Render, token_index: Ast.TokenIndex, lexeme_len: usize, space
28272827 if (space == .skip) return;
28282828
28292829 if (space == .comma and next_token_tag != .comma) {
2830 try ais.underlying_writer.writeByte(',');
2830 try ais.writeByte(',');
28312831 }
28322832 if (space == .semicolon or space == .comma) ais.enableSpaceMode(space);
28332833 defer ais.disableSpaceMode();
......@@ -3242,11 +3242,11 @@ fn writeStringLiteralAsIdentifier(r: *Render, token_index: Ast.TokenIndex) !usiz
32423242 const lexeme = tokenSliceForRender(tree, token_index);
32433243 const unquoted = lexeme[1..][0 .. lexeme.len - 2];
32443244 if (std.zig.isValidId(unquoted)) {
3245 try ais.writer().writeAll(unquoted);
3245 try ais.writeAll(unquoted);
32463246 return unquoted.len;
32473247 } else {
3248 try ais.writer().writeByte('@');
3249 try ais.writer().writeAll(lexeme);
3248 try ais.writeByte('@');
3249 try ais.writeAll(lexeme);
32503250 return lexeme.len + 1;
32513251 }
32523252}
lib/std/zig/Server.zig+18-16
......@@ -1,4 +1,19 @@
1in: *std.io.Reader,
1const Server = @This();
2
3const builtin = @import("builtin");
4
5const std = @import("std");
6const Allocator = std.mem.Allocator;
7const assert = std.debug.assert;
8const native_endian = builtin.target.cpu.arch.endian();
9const need_bswap = native_endian != .little;
10const Cache = std.Build.Cache;
11const OutMessage = std.zig.Server.Message;
12const InMessage = std.zig.Client.Message;
13const Reader = std.Io.Reader;
14const Writer = std.Io.Writer;
15
16in: *Reader,
217out: *Writer,
318
419pub const Message = struct {
......@@ -93,7 +108,7 @@ pub const Message = struct {
93108};
94109
95110pub const Options = struct {
96 in: *std.io.Reader,
111 in: *Reader,
97112 out: *Writer,
98113 zig_version: []const u8,
99114};
......@@ -108,7 +123,7 @@ pub fn init(options: Options) !Server {
108123}
109124
110125pub fn receiveMessage(s: *Server) !InMessage.Header {
111 return try s.in.takeStructEndian(InMessage.Header, .little);
126 return s.in.takeStruct(InMessage.Header, .little);
112127}
113128
114129pub fn receiveBody_u32(s: *Server) !u32 {
......@@ -203,16 +218,3 @@ pub fn serveTestMetadata(s: *Server, test_metadata: TestMetadata) !void {
203218 try s.out.writeAll(test_metadata.string_bytes);
204219 try s.out.flush();
205220}
206
207const OutMessage = std.zig.Server.Message;
208const InMessage = std.zig.Client.Message;
209
210const Server = @This();
211const builtin = @import("builtin");
212const std = @import("std");
213const Allocator = std.mem.Allocator;
214const assert = std.debug.assert;
215const native_endian = builtin.target.cpu.arch.endian();
216const need_bswap = native_endian != .little;
217const Cache = std.Build.Cache;
218const Writer = std.io.Writer;
lib/std/zig/llvm/BitcodeReader.zig+9-9
......@@ -1,6 +1,11 @@
1const BitcodeReader = @This();
2
3const std = @import("../../std.zig");
4const assert = std.debug.assert;
5
16allocator: std.mem.Allocator,
27record_arena: std.heap.ArenaAllocator.State,
3reader: *std.io.Reader,
8reader: *std.Io.Reader,
49keep_names: bool,
510bit_buffer: u32,
611bit_offset: u5,
......@@ -93,7 +98,7 @@ pub const Record = struct {
9398};
9499
95100pub const InitOptions = struct {
96 reader: *std.io.Reader,
101 reader: *std.Io.Reader,
97102 keep_names: bool = false,
98103};
99104pub fn init(allocator: std.mem.Allocator, options: InitOptions) BitcodeReader {
......@@ -376,12 +381,12 @@ fn read32Bits(bc: *BitcodeReader) !u32 {
376381
377382fn readBytes(bc: *BitcodeReader, bytes: []u8) !void {
378383 assert(bc.bit_offset == 0);
379 try bc.reader.read(bytes);
384 try bc.reader.readSliceAll(bytes);
380385
381386 const trailing_bytes = bytes.len % 4;
382387 if (trailing_bytes > 0) {
383388 var bit_buffer: [4]u8 = @splat(0);
384 try bc.reader.read(bit_buffer[trailing_bytes..]);
389 try bc.reader.readSliceAll(bit_buffer[trailing_bytes..]);
385390 bc.bit_buffer = std.mem.readInt(u32, &bit_buffer, .little);
386391 bc.bit_offset = @intCast(8 * trailing_bytes);
387392 }
......@@ -508,8 +513,3 @@ const Abbrev = struct {
508513 }
509514 };
510515};
511
512const assert = std.debug.assert;
513const std = @import("../../std.zig");
514
515const BitcodeReader = @This();
lib/std/zig/parser_test.zig+10-9
......@@ -6367,31 +6367,32 @@ test "ampersand" {
63676367var fixed_buffer_mem: [100 * 1024]u8 = undefined;
63686368
63696369fn testParse(source: [:0]const u8, allocator: mem.Allocator, anything_changed: *bool) ![]u8 {
6370 const stderr: std.fs.File = .stderr();
6371 const stderr_writer = stderr.writer().unbuffered();
6370 var buffer: [64]u8 = undefined;
6371 const stderr = std.debug.lockStderrWriter(&buffer);
6372 defer std.debug.unlockStderrWriter();
63726373
63736374 var tree = try std.zig.Ast.parse(allocator, source, .zig);
63746375 defer tree.deinit(allocator);
63756376
63766377 for (tree.errors) |parse_error| {
63776378 const loc = tree.tokenLocation(0, parse_error.token);
6378 try stderr_writer.print("(memory buffer):{d}:{d}: error: ", .{ loc.line + 1, loc.column + 1 });
6379 try tree.renderError(parse_error, stderr_writer);
6380 try stderr_writer.print("\n{s}\n", .{source[loc.line_start..loc.line_end]});
6379 try stderr.print("(memory buffer):{d}:{d}: error: ", .{ loc.line + 1, loc.column + 1 });
6380 try tree.renderError(parse_error, stderr);
6381 try stderr.print("\n{s}\n", .{source[loc.line_start..loc.line_end]});
63816382 {
63826383 var i: usize = 0;
63836384 while (i < loc.column) : (i += 1) {
6384 try stderr_writer.writeAll(" ");
6385 try stderr.writeAll(" ");
63856386 }
6386 try stderr_writer.writeAll("^");
6387 try stderr.writeAll("^");
63876388 }
6388 try stderr_writer.writeAll("\n");
6389 try stderr.writeAll("\n");
63896390 }
63906391 if (tree.errors.len != 0) {
63916392 return error.ParseError;
63926393 }
63936394
6394 const formatted = try tree.render(allocator);
6395 const formatted = try tree.renderAlloc(allocator);
63956396 anything_changed.* = !mem.eql(u8, formatted, source);
63966397 return formatted;
63976398}
lib/std/zig/system/linux.zig+2-3
......@@ -1,7 +1,6 @@
11const std = @import("std");
22const builtin = @import("builtin");
33const mem = std.mem;
4const io = std.io;
54const fs = std.fs;
65const fmt = std.fmt;
76const testing = std.testing;
......@@ -344,7 +343,7 @@ fn testParser(
344343 expected_model: *const Target.Cpu.Model,
345344 input: []const u8,
346345) !void {
347 var r: std.io.Reader = .fixed(input);
346 var r: std.Io.Reader = .fixed(input);
348347 const result = try parser.parse(arch, &r);
349348 try testing.expectEqual(expected_model, result.?.model);
350349 try testing.expect(expected_model.features.eql(result.?.features));
......@@ -357,7 +356,7 @@ fn testParser(
357356// When all the lines have been analyzed the finalize method is called.
358357fn CpuinfoParser(comptime impl: anytype) type {
359358 return struct {
360 fn parse(arch: Target.Cpu.Arch, reader: *std.io.Reader) !?Target.Cpu {
359 fn parse(arch: Target.Cpu.Arch, reader: *std.Io.Reader) !?Target.Cpu {
361360 var obj: impl = .{};
362361 while (reader.takeDelimiterExclusive('\n')) |line| {
363362 const colon_pos = mem.indexOfScalar(u8, line, ':') orelse continue;