authorgravatar for bence.masa@gmail.comMasa Bence <bence.masa@gmail.com> 2026-10-21 23:47:04+02:00
committergravatar for alex@alexrp.comAlex Rønne Petersen <alex@alexrp.com> 2026-10-22 20:09:32+02:00
log87528630ddf4182594f6f3554d9d6c1fd550e261
treef383a038179f9366058f93bdfa1a11d8494f04d3
parent8d6eb13c725f409270fc34c104da4c206b70c376

std: update more ArrayList usages to unmanaged

8 files changed, 55 insertions(+), 55 deletions(-)

lib/std/debug/Dwarf.zig+3-3
......@@ -571,8 +571,8 @@ fn scanAllCompileUnits(di: *Dwarf, gpa: Allocator, endian: Endian) ScanError!voi
571571 var fr: Reader = .fixed(di.section(.debug_info).?);
572572 var this_unit_offset: u64 = 0;
573573
574 var attrs_buf = std.array_list.Managed(Die.Attr).init(gpa);
575 defer attrs_buf.deinit();
574 var attrs_buf: std.ArrayList(Die.Attr) = .empty;
575 defer attrs_buf.deinit(gpa);
576576
577577 while (this_unit_offset < fr.buffer.len) {
578578 fr.seek = @intCast(this_unit_offset);
......@@ -603,7 +603,7 @@ fn scanAllCompileUnits(di: *Dwarf, gpa: Allocator, endian: Endian) ScanError!voi
603603 for (abbrev_table.abbrevs) |abbrev| {
604604 max_attrs = @max(max_attrs, abbrev.attrs.len);
605605 }
606 try attrs_buf.resize(max_attrs);
606 try attrs_buf.resize(gpa, max_attrs);
607607
608608 var compile_unit_die = (try parseDie(
609609 &fr,
lib/std/hash_map.zig+6-6
......@@ -1802,15 +1802,15 @@ test "put and remove loop in random order" {
18021802 var map = AutoHashMap(u32, u32).init(std.testing.allocator);
18031803 defer map.deinit();
18041804
1805 var keys = std.array_list.Managed(u32).init(std.testing.allocator);
1806 defer keys.deinit();
1805 var keys: std.ArrayList(u32) = .empty;
1806 defer keys.deinit(std.testing.allocator);
18071807
18081808 const size = 32;
18091809 const iterations = 100;
18101810
18111811 var i: u32 = 0;
18121812 while (i < size) : (i += 1) {
1813 try keys.append(i);
1813 try keys.append(std.testing.allocator, i);
18141814 }
18151815 var prng = std.Random.DefaultPrng.init(std.testing.random_seed);
18161816 const random = prng.random();
......@@ -1836,12 +1836,12 @@ test "remove many elements in random order" {
18361836 var map = Map.init(std.heap.page_allocator);
18371837 defer map.deinit();
18381838
1839 var keys = std.array_list.Managed(u32).init(std.heap.page_allocator);
1840 defer keys.deinit();
1839 var keys: std.ArrayList(u32) = .empty;
1840 defer keys.deinit(std.heap.page_allocator);
18411841
18421842 var i: u32 = 0;
18431843 while (i < n) : (i += 1) {
1844 keys.append(i) catch unreachable;
1844 keys.append(std.heap.page_allocator, i) catch unreachable;
18451845 }
18461846
18471847 var prng = std.Random.DefaultPrng.init(std.testing.random_seed);
lib/std/http/test.zig+9-9
......@@ -336,17 +336,17 @@ test "Server.Request.respondStreaming non-chunked, unknown content-length" {
336336 const response = try stream_reader.interface.allocRemaining(gpa, .unlimited);
337337 defer gpa.free(response);
338338
339 var expected_response = std.array_list.Managed(u8).init(gpa);
340 defer expected_response.deinit();
339 var expected_response: std.ArrayList(u8) = .empty;
340 defer expected_response.deinit(gpa);
341341
342 try expected_response.appendSlice("HTTP/1.1 200 OK\r\nconnection: close\r\n\r\n");
342 try expected_response.appendSlice(gpa, "HTTP/1.1 200 OK\r\nconnection: close\r\n\r\n");
343343
344344 {
345345 var total: usize = 0;
346346 for (0..500) |i| {
347347 var buf: [30]u8 = undefined;
348348 const line = try std.mem.print(&buf, "{d}, ah ha ha!\n", .{i});
349 try expected_response.appendSlice(line);
349 try expected_response.appendSlice(gpa, line);
350350 total += line.len;
351351 }
352352 try expectEqual(7390, total);
......@@ -411,12 +411,12 @@ test "receiving arbitrary http headers from the client" {
411411 const response = try stream_reader.interface.allocRemaining(gpa, .unlimited);
412412 defer gpa.free(response);
413413
414 var expected_response = std.array_list.Managed(u8).init(gpa);
415 defer expected_response.deinit();
414 var expected_response: std.ArrayList(u8) = .empty;
415 defer expected_response.deinit(gpa);
416416
417 try expected_response.appendSlice("HTTP/1.1 200 OK\r\n");
418 try expected_response.appendSlice("connection: close\r\n");
419 try expected_response.appendSlice("content-length: 0\r\n\r\n");
417 try expected_response.appendSlice(gpa, "HTTP/1.1 200 OK\r\n");
418 try expected_response.appendSlice(gpa, "connection: close\r\n");
419 try expected_response.appendSlice(gpa, "content-length: 0\r\n\r\n");
420420 try expectEqualStrings(expected_response.items, response);
421421}
422422
lib/std/priority_dequeue.zig+4-4
......@@ -1020,16 +1020,16 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void {
10201020}
10211021
10221022fn generateRandomSlice(allocator: std.mem.Allocator, rng: std.Random, size: usize) ![]u32 {
1023 var array = std.array_list.Managed(u32).init(allocator);
1024 try array.ensureTotalCapacity(size);
1023 var array: std.ArrayList(u32) = .empty;
1024 try array.ensureTotalCapacity(allocator, size);
10251025
10261026 var i: usize = 0;
10271027 while (i < size) : (i += 1) {
10281028 const elem = rng.int(u32);
1029 try array.append(elem);
1029 try array.append(allocator, elem);
10301030 }
10311031
1032 return array.toOwnedSlice();
1032 return array.toOwnedSlice(allocator);
10331033}
10341034
10351035fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order {
lib/std/zig.zig+12-12
......@@ -900,10 +900,10 @@ pub fn parseTargetQueryOrReportFatalError(
900900 return std.Target.Query.parse(opts_with_diags) catch |err| switch (err) {
901901 error.UnknownCpuModel => {
902902 help: {
903 var help_text = std.array_list.Managed(u8).init(allocator);
904 defer help_text.deinit();
903 var help_text: std.ArrayList(u8) = .empty;
904 defer help_text.deinit(allocator);
905905 for (diags.arch.?.allCpuModels()) |cpu| {
906 help_text.print(" {s}\n", .{cpu.name}) catch break :help;
906 help_text.print(allocator, " {s}\n", .{cpu.name}) catch break :help;
907907 }
908908 log.info("available CPUs for architecture '{s}':\n{s}", .{
909909 @tagName(diags.arch.?), help_text.items,
......@@ -913,10 +913,10 @@ pub fn parseTargetQueryOrReportFatalError(
913913 },
914914 error.UnknownCpuFeature => {
915915 help: {
916 var help_text = std.array_list.Managed(u8).init(allocator);
917 defer help_text.deinit();
916 var help_text: std.ArrayList(u8) = .empty;
917 defer help_text.deinit(allocator);
918918 for (diags.arch.?.allFeaturesList()) |feature| {
919 help_text.print(" {s}: {s}\n", .{ feature.name, feature.description }) catch break :help;
919 help_text.print(allocator, " {s}: {s}\n", .{ feature.name, feature.description }) catch break :help;
920920 }
921921 log.info("available CPU features for architecture '{s}':\n{s}", .{
922922 @tagName(diags.arch.?), help_text.items,
......@@ -926,10 +926,10 @@ pub fn parseTargetQueryOrReportFatalError(
926926 },
927927 error.UnknownObjectFormat => {
928928 help: {
929 var help_text = std.array_list.Managed(u8).init(allocator);
930 defer help_text.deinit();
929 var help_text: std.ArrayList(u8) = .empty;
930 defer help_text.deinit(allocator);
931931 inline for (@typeInfo(std.Target.ObjectFormat).@"enum".field_names) |field_name| {
932 help_text.print(" {s}\n", .{field_name}) catch break :help;
932 help_text.print(allocator, " {s}\n", .{field_name}) catch break :help;
933933 }
934934 log.info("available object formats:\n{s}", .{help_text.items});
935935 }
......@@ -937,10 +937,10 @@ pub fn parseTargetQueryOrReportFatalError(
937937 },
938938 error.UnknownArchitecture => {
939939 help: {
940 var help_text = std.array_list.Managed(u8).init(allocator);
941 defer help_text.deinit();
940 var help_text: std.ArrayList(u8) = .empty;
941 defer help_text.deinit(allocator);
942942 inline for (@typeInfo(std.Target.Cpu.Arch).@"enum".field_names) |field_name| {
943 help_text.print(" {s}\n", .{field_name}) catch break :help;
943 help_text.print(allocator, " {s}\n", .{field_name}) catch break :help;
944944 }
945945 log.info("available architectures:\n{s} native\n", .{help_text.items});
946946 }
lib/std/zig/AstGen.zig+3-3
......@@ -1802,13 +1802,13 @@ fn structInitExpr(
18021802 while (it.next()) |entry| {
18031803 const record = entry.value_ptr.*;
18041804 if (record.items.len > 1) {
1805 var error_notes = std.array_list.Managed(u32).init(astgen.arena);
1805 var error_notes: std.ArrayList(u32) = .empty;
18061806
18071807 for (record.items[1..]) |duplicate| {
1808 try error_notes.append(try astgen.errNoteTok(duplicate, "duplicate name here", .{}));
1808 try error_notes.append(astgen.arena, try astgen.errNoteTok(duplicate, "duplicate name here", .{}));
18091809 }
18101810
1811 try error_notes.append(try astgen.errNoteNode(node, "struct declared here", .{}));
1811 try error_notes.append(astgen.arena, try astgen.errNoteNode(node, "struct declared here", .{}));
18121812
18131813 try astgen.appendErrorTokNotes(
18141814 record.items[0],
lib/std/zig/LibCDirs.zig+2-2
......@@ -96,7 +96,7 @@ pub fn detect(
9696}
9797
9898fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *const LibCInstallation) !LibCDirs {
99 var list = try std.array_list.Managed([]const u8).initCapacity(arena, 5);
99 var list: std.ArrayList([]const u8) = try .initCapacity(arena, 5);
100100
101101 list.appendAssumeCapacity(lci.include_dir.?);
102102
......@@ -133,7 +133,7 @@ fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *con
133133 };
134134 for (subdirs) |subdir| {
135135 const path = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, subdir });
136 try list.append(path);
136 try list.append(arena, path);
137137 }
138138 }
139139
lib/std/zig/llvm/Builder.zig+16-16
......@@ -95,8 +95,8 @@ fn subArchName(target: *const std.Target, comptime family: std.Target.Cpu.Arch.F
9595}
9696
9797pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const u8 {
98 var llvm_triple = std.array_list.Managed(u8).init(allocator);
99 defer llvm_triple.deinit();
98 var llvm_triple: std.ArrayList(u8) = .empty;
99 defer llvm_triple.deinit(allocator);
100100
101101 const llvm_arch = switch (target.cpu.arch) {
102102 .arm => "arm",
......@@ -168,7 +168,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
168168 => unreachable, // Gated by hasLlvmSupport().
169169 };
170170
171 try llvm_triple.appendSlice(llvm_arch);
171 try llvm_triple.appendSlice(allocator, llvm_arch);
172172
173173 const llvm_sub_arch: ?[]const u8 = switch (target.cpu.arch) {
174174 .arm, .armeb, .thumb, .thumbeb => subArchName(target, .arm, .{
......@@ -223,10 +223,10 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
223223 else => null,
224224 };
225225
226 if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub);
227 try llvm_triple.append('-');
226 if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(allocator, sub);
227 try llvm_triple.append(allocator, '-');
228228
229 try llvm_triple.appendSlice(switch (target.os.tag) {
229 try llvm_triple.appendSlice(allocator, switch (target.os.tag) {
230230 .driverkit,
231231 .ios,
232232 .maccatalyst,
......@@ -248,7 +248,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
248248 => "mesa",
249249 else => "unknown",
250250 });
251 try llvm_triple.append('-');
251 try llvm_triple.append(allocator, '-');
252252
253253 const llvm_os = switch (target.os.tag) {
254254 .dragonfly => "dragonfly",
......@@ -298,28 +298,28 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
298298 .ashetos,
299299 => "unknown",
300300 };
301 try llvm_triple.appendSlice(llvm_os);
301 try llvm_triple.appendSlice(allocator, llvm_os);
302302
303303 switch (target.os.versionRange()) {
304304 .none,
305305 .windows,
306306 => {},
307307 .semver => |ver| if (target.os.tag == .wasi and ver.min.major == 0) {
308 try llvm_triple.print("p{d}", .{ver.min.minor});
308 try llvm_triple.print(allocator, "p{d}", .{ver.min.minor});
309309 } else if (target.os.tag != .amdhsa) {
310 try llvm_triple.print("{d}.{d}.{d}", .{
310 try llvm_triple.print(allocator, "{d}.{d}.{d}", .{
311311 ver.min.major,
312312 ver.min.minor,
313313 ver.min.patch,
314314 });
315315 },
316 inline .linux, .hurd => |ver| try llvm_triple.print("{d}.{d}.{d}", .{
316 inline .linux, .hurd => |ver| try llvm_triple.print(allocator, "{d}.{d}.{d}", .{
317317 ver.range.min.major,
318318 ver.range.min.minor,
319319 ver.range.min.patch,
320320 }),
321321 }
322 try llvm_triple.append('-');
322 try llvm_triple.append(allocator, '-');
323323
324324 const llvm_abi = switch (target.abi) {
325325 .none => if (target.os.tag == .maccatalyst) "macabi" else "unknown",
......@@ -357,7 +357,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
357357 .ohos, .ohoseabi => "ohos",
358358 .call0 => "unknown",
359359 };
360 try llvm_triple.appendSlice(llvm_abi);
360 try llvm_triple.appendSlice(allocator, llvm_abi);
361361
362362 switch (target.os.versionRange()) {
363363 .none,
......@@ -365,17 +365,17 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const
365365 .windows,
366366 => {},
367367 inline .hurd, .linux => |ver| if (target.abi.isGnu()) {
368 try llvm_triple.print("{d}.{d}.{d}", .{
368 try llvm_triple.print(allocator, "{d}.{d}.{d}", .{
369369 ver.glibc.major,
370370 ver.glibc.minor,
371371 ver.glibc.patch,
372372 });
373373 } else if (@TypeOf(ver) == std.Target.Os.LinuxVersionRange and target.abi.isAndroid()) {
374 try llvm_triple.print("{d}", .{ver.android});
374 try llvm_triple.print(allocator, "{d}", .{ver.android});
375375 },
376376 }
377377
378 return llvm_triple.toOwnedSlice();
378 return llvm_triple.toOwnedSlice(allocator);
379379}
380380
381381pub const DataLayout = struct {