From 87528630ddf4182594f6f3554d9d6c1fd550e261 Mon Sep 17 00:00:00 2001 From: Masa Bence Date: Wed, 21 Oct 2026 23:47:04 +0200 Subject: [PATCH] std: update more ArrayList usages to unmanaged --- lib/std/debug/Dwarf.zig | 6 +++--- lib/std/hash_map.zig | 12 ++++++------ lib/std/http/test.zig | 18 +++++++++--------- lib/std/priority_dequeue.zig | 8 ++++---- lib/std/zig.zig | 24 ++++++++++++------------ lib/std/zig/AstGen.zig | 6 +++--- lib/std/zig/LibCDirs.zig | 4 ++-- lib/std/zig/llvm/Builder.zig | 32 ++++++++++++++++---------------- 8 files changed, 55 insertions(+), 55 deletions(-) diff --git a/lib/std/debug/Dwarf.zig b/lib/std/debug/Dwarf.zig index 44d4f488a58c9239c68561539c0240b8e250d415..f9d43e8b1bc38d4b6a648aeb27420ec5ed7a8827 100644 --- a/lib/std/debug/Dwarf.zig +++ b/lib/std/debug/Dwarf.zig @@ -571,8 +571,8 @@ fn scanAllCompileUnits(di: *Dwarf, gpa: Allocator, endian: Endian) ScanError!voi var fr: Reader = .fixed(di.section(.debug_info).?); var this_unit_offset: u64 = 0; - var attrs_buf = std.array_list.Managed(Die.Attr).init(gpa); - defer attrs_buf.deinit(); + var attrs_buf: std.ArrayList(Die.Attr) = .empty; + defer attrs_buf.deinit(gpa); while (this_unit_offset < fr.buffer.len) { fr.seek = @intCast(this_unit_offset); @@ -603,7 +603,7 @@ fn scanAllCompileUnits(di: *Dwarf, gpa: Allocator, endian: Endian) ScanError!voi for (abbrev_table.abbrevs) |abbrev| { max_attrs = @max(max_attrs, abbrev.attrs.len); } - try attrs_buf.resize(max_attrs); + try attrs_buf.resize(gpa, max_attrs); var compile_unit_die = (try parseDie( &fr, diff --git a/lib/std/hash_map.zig b/lib/std/hash_map.zig index 58dc8524e8ac07e960a47186eb6d8dd3a49d3efd..90de819a28d26e38a46b25dab2af2812a27a9b64 100644 --- a/lib/std/hash_map.zig +++ b/lib/std/hash_map.zig @@ -1802,15 +1802,15 @@ test "put and remove loop in random order" { var map = AutoHashMap(u32, u32).init(std.testing.allocator); defer map.deinit(); - var keys = std.array_list.Managed(u32).init(std.testing.allocator); - defer keys.deinit(); + var keys: std.ArrayList(u32) = .empty; + defer keys.deinit(std.testing.allocator); const size = 32; const iterations = 100; var i: u32 = 0; while (i < size) : (i += 1) { - try keys.append(i); + try keys.append(std.testing.allocator, i); } var prng = std.Random.DefaultPrng.init(std.testing.random_seed); const random = prng.random(); @@ -1836,12 +1836,12 @@ test "remove many elements in random order" { var map = Map.init(std.heap.page_allocator); defer map.deinit(); - var keys = std.array_list.Managed(u32).init(std.heap.page_allocator); - defer keys.deinit(); + var keys: std.ArrayList(u32) = .empty; + defer keys.deinit(std.heap.page_allocator); var i: u32 = 0; while (i < n) : (i += 1) { - keys.append(i) catch unreachable; + keys.append(std.heap.page_allocator, i) catch unreachable; } var prng = std.Random.DefaultPrng.init(std.testing.random_seed); diff --git a/lib/std/http/test.zig b/lib/std/http/test.zig index 92ced35bc0d00fe29eda578239bfd4e9b654db31..78b049ffa9bd304ac68ee6dd0d1bd2aef34aa7f2 100644 --- a/lib/std/http/test.zig +++ b/lib/std/http/test.zig @@ -336,17 +336,17 @@ test "Server.Request.respondStreaming non-chunked, unknown content-length" { const response = try stream_reader.interface.allocRemaining(gpa, .unlimited); defer gpa.free(response); - var expected_response = std.array_list.Managed(u8).init(gpa); - defer expected_response.deinit(); + var expected_response: std.ArrayList(u8) = .empty; + defer expected_response.deinit(gpa); - try expected_response.appendSlice("HTTP/1.1 200 OK\r\nconnection: close\r\n\r\n"); + try expected_response.appendSlice(gpa, "HTTP/1.1 200 OK\r\nconnection: close\r\n\r\n"); { var total: usize = 0; for (0..500) |i| { var buf: [30]u8 = undefined; const line = try std.mem.print(&buf, "{d}, ah ha ha!\n", .{i}); - try expected_response.appendSlice(line); + try expected_response.appendSlice(gpa, line); total += line.len; } try expectEqual(7390, total); @@ -411,12 +411,12 @@ test "receiving arbitrary http headers from the client" { const response = try stream_reader.interface.allocRemaining(gpa, .unlimited); defer gpa.free(response); - var expected_response = std.array_list.Managed(u8).init(gpa); - defer expected_response.deinit(); + var expected_response: std.ArrayList(u8) = .empty; + defer expected_response.deinit(gpa); - try expected_response.appendSlice("HTTP/1.1 200 OK\r\n"); - try expected_response.appendSlice("connection: close\r\n"); - try expected_response.appendSlice("content-length: 0\r\n\r\n"); + try expected_response.appendSlice(gpa, "HTTP/1.1 200 OK\r\n"); + try expected_response.appendSlice(gpa, "connection: close\r\n"); + try expected_response.appendSlice(gpa, "content-length: 0\r\n\r\n"); try expectEqualStrings(expected_response.items, response); } diff --git a/lib/std/priority_dequeue.zig b/lib/std/priority_dequeue.zig index 83b9aedf005bf2ebb56b51329ca173d56092f575..49d0c6f840ba37eaa4765a7172a7fba003dba32e 100644 --- a/lib/std/priority_dequeue.zig +++ b/lib/std/priority_dequeue.zig @@ -1020,16 +1020,16 @@ fn fuzzTestMinMax(rng: std.Random, queue_size: usize) !void { } fn generateRandomSlice(allocator: std.mem.Allocator, rng: std.Random, size: usize) ![]u32 { - var array = std.array_list.Managed(u32).init(allocator); - try array.ensureTotalCapacity(size); + var array: std.ArrayList(u32) = .empty; + try array.ensureTotalCapacity(allocator, size); var i: usize = 0; while (i < size) : (i += 1) { const elem = rng.int(u32); - try array.append(elem); + try array.append(allocator, elem); } - return array.toOwnedSlice(); + return array.toOwnedSlice(allocator); } fn contextLessThanComparison(context: []const u32, a: usize, b: usize) Order { diff --git a/lib/std/zig.zig b/lib/std/zig.zig index db8fa41d8c48651220bb676d1540838d67b80dba..a2d9a7792b802f7a7dc0a9bb1e977ff547a4af06 100644 --- a/lib/std/zig.zig +++ b/lib/std/zig.zig @@ -900,10 +900,10 @@ pub fn parseTargetQueryOrReportFatalError( return std.Target.Query.parse(opts_with_diags) catch |err| switch (err) { error.UnknownCpuModel => { help: { - var help_text = std.array_list.Managed(u8).init(allocator); - defer help_text.deinit(); + var help_text: std.ArrayList(u8) = .empty; + defer help_text.deinit(allocator); for (diags.arch.?.allCpuModels()) |cpu| { - help_text.print(" {s}\n", .{cpu.name}) catch break :help; + help_text.print(allocator, " {s}\n", .{cpu.name}) catch break :help; } log.info("available CPUs for architecture '{s}':\n{s}", .{ @tagName(diags.arch.?), help_text.items, @@ -913,10 +913,10 @@ pub fn parseTargetQueryOrReportFatalError( }, error.UnknownCpuFeature => { help: { - var help_text = std.array_list.Managed(u8).init(allocator); - defer help_text.deinit(); + var help_text: std.ArrayList(u8) = .empty; + defer help_text.deinit(allocator); for (diags.arch.?.allFeaturesList()) |feature| { - help_text.print(" {s}: {s}\n", .{ feature.name, feature.description }) catch break :help; + help_text.print(allocator, " {s}: {s}\n", .{ feature.name, feature.description }) catch break :help; } log.info("available CPU features for architecture '{s}':\n{s}", .{ @tagName(diags.arch.?), help_text.items, @@ -926,10 +926,10 @@ pub fn parseTargetQueryOrReportFatalError( }, error.UnknownObjectFormat => { help: { - var help_text = std.array_list.Managed(u8).init(allocator); - defer help_text.deinit(); + var help_text: std.ArrayList(u8) = .empty; + defer help_text.deinit(allocator); inline for (@typeInfo(std.Target.ObjectFormat).@"enum".field_names) |field_name| { - help_text.print(" {s}\n", .{field_name}) catch break :help; + help_text.print(allocator, " {s}\n", .{field_name}) catch break :help; } log.info("available object formats:\n{s}", .{help_text.items}); } @@ -937,10 +937,10 @@ pub fn parseTargetQueryOrReportFatalError( }, error.UnknownArchitecture => { help: { - var help_text = std.array_list.Managed(u8).init(allocator); - defer help_text.deinit(); + var help_text: std.ArrayList(u8) = .empty; + defer help_text.deinit(allocator); inline for (@typeInfo(std.Target.Cpu.Arch).@"enum".field_names) |field_name| { - help_text.print(" {s}\n", .{field_name}) catch break :help; + help_text.print(allocator, " {s}\n", .{field_name}) catch break :help; } log.info("available architectures:\n{s} native\n", .{help_text.items}); } diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig index d29faf0747dcef2aa1b0ae828c94b947bc00ca64..927fc8eca9315dcdb07fa6a60bb1ae4490ee97ad 100644 --- a/lib/std/zig/AstGen.zig +++ b/lib/std/zig/AstGen.zig @@ -1802,13 +1802,13 @@ fn structInitExpr( while (it.next()) |entry| { const record = entry.value_ptr.*; if (record.items.len > 1) { - var error_notes = std.array_list.Managed(u32).init(astgen.arena); + var error_notes: std.ArrayList(u32) = .empty; for (record.items[1..]) |duplicate| { - try error_notes.append(try astgen.errNoteTok(duplicate, "duplicate name here", .{})); + try error_notes.append(astgen.arena, try astgen.errNoteTok(duplicate, "duplicate name here", .{})); } - try error_notes.append(try astgen.errNoteNode(node, "struct declared here", .{})); + try error_notes.append(astgen.arena, try astgen.errNoteNode(node, "struct declared here", .{})); try astgen.appendErrorTokNotes( record.items[0], diff --git a/lib/std/zig/LibCDirs.zig b/lib/std/zig/LibCDirs.zig index f0f27b5d65ffc7424e99813bfa91afa22ab8e4ff..8ed96415c66eb55f3c6c793d7418289b3d3ee60d 100644 --- a/lib/std/zig/LibCDirs.zig +++ b/lib/std/zig/LibCDirs.zig @@ -96,7 +96,7 @@ pub fn detect( } fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *const LibCInstallation) !LibCDirs { - var list = try std.array_list.Managed([]const u8).initCapacity(arena, 5); + var list: std.ArrayList([]const u8) = try .initCapacity(arena, 5); list.appendAssumeCapacity(lci.include_dir.?); @@ -133,7 +133,7 @@ fn detectFromInstallation(arena: Allocator, target: *const std.Target, lci: *con }; for (subdirs) |subdir| { const path = try std.fs.path.join(arena, &[_][]const u8{ include_dir_path, subdir }); - try list.append(path); + try list.append(arena, path); } } diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig index 16a4f283ce6ccf976af56428e5ac996c94138bdf..2f19045433a6952b8c04f0e50291292d05e67521 100644 --- a/lib/std/zig/llvm/Builder.zig +++ b/lib/std/zig/llvm/Builder.zig @@ -95,8 +95,8 @@ fn subArchName(target: *const std.Target, comptime family: std.Target.Cpu.Arch.F } pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const u8 { - var llvm_triple = std.array_list.Managed(u8).init(allocator); - defer llvm_triple.deinit(); + var llvm_triple: std.ArrayList(u8) = .empty; + defer llvm_triple.deinit(allocator); const llvm_arch = switch (target.cpu.arch) { .arm => "arm", @@ -168,7 +168,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const => unreachable, // Gated by hasLlvmSupport(). }; - try llvm_triple.appendSlice(llvm_arch); + try llvm_triple.appendSlice(allocator, llvm_arch); const llvm_sub_arch: ?[]const u8 = switch (target.cpu.arch) { .arm, .armeb, .thumb, .thumbeb => subArchName(target, .arm, .{ @@ -223,10 +223,10 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const else => null, }; - if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub); - try llvm_triple.append('-'); + if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(allocator, sub); + try llvm_triple.append(allocator, '-'); - try llvm_triple.appendSlice(switch (target.os.tag) { + try llvm_triple.appendSlice(allocator, switch (target.os.tag) { .driverkit, .ios, .maccatalyst, @@ -248,7 +248,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const => "mesa", else => "unknown", }); - try llvm_triple.append('-'); + try llvm_triple.append(allocator, '-'); const llvm_os = switch (target.os.tag) { .dragonfly => "dragonfly", @@ -298,28 +298,28 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const .ashetos, => "unknown", }; - try llvm_triple.appendSlice(llvm_os); + try llvm_triple.appendSlice(allocator, llvm_os); switch (target.os.versionRange()) { .none, .windows, => {}, .semver => |ver| if (target.os.tag == .wasi and ver.min.major == 0) { - try llvm_triple.print("p{d}", .{ver.min.minor}); + try llvm_triple.print(allocator, "p{d}", .{ver.min.minor}); } else if (target.os.tag != .amdhsa) { - try llvm_triple.print("{d}.{d}.{d}", .{ + try llvm_triple.print(allocator, "{d}.{d}.{d}", .{ ver.min.major, ver.min.minor, ver.min.patch, }); }, - inline .linux, .hurd => |ver| try llvm_triple.print("{d}.{d}.{d}", .{ + inline .linux, .hurd => |ver| try llvm_triple.print(allocator, "{d}.{d}.{d}", .{ ver.range.min.major, ver.range.min.minor, ver.range.min.patch, }), } - try llvm_triple.append('-'); + try llvm_triple.append(allocator, '-'); const llvm_abi = switch (target.abi) { .none => if (target.os.tag == .maccatalyst) "macabi" else "unknown", @@ -357,7 +357,7 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const .ohos, .ohoseabi => "ohos", .call0 => "unknown", }; - try llvm_triple.appendSlice(llvm_abi); + try llvm_triple.appendSlice(allocator, llvm_abi); switch (target.os.versionRange()) { .none, @@ -365,17 +365,17 @@ pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const .windows, => {}, inline .hurd, .linux => |ver| if (target.abi.isGnu()) { - try llvm_triple.print("{d}.{d}.{d}", .{ + try llvm_triple.print(allocator, "{d}.{d}.{d}", .{ ver.glibc.major, ver.glibc.minor, ver.glibc.patch, }); } else if (@TypeOf(ver) == std.Target.Os.LinuxVersionRange and target.abi.isAndroid()) { - try llvm_triple.print("{d}", .{ver.android}); + try llvm_triple.print(allocator, "{d}", .{ver.android}); }, } - return llvm_triple.toOwnedSlice(); + return llvm_triple.toOwnedSlice(allocator); } pub const DataLayout = struct { -- 2.54.0