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 aa67d22466d73754401603bb9a2b6c6cedde1d5d..7989601b7e564362d1cc62cd7c4a79cce71ce2d3 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();
@@ -1833,15 +1833,15 @@ test "put and remove loop in random order" {
 test "remove many elements in random order" {
     const Map = AutoHashMap(u32, u32);
     const n = 1000 * 100;
-    var map = Map.init(std.heap.page_allocator);
+    var map = Map.init(std.testing.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.testing.allocator);
 
     var i: u32 = 0;
     while (i < n) : (i += 1) {
-        keys.append(i) catch unreachable;
+        keys.append(std.testing.allocator, i) catch unreachable;
     }
 
     var prng = std.Random.DefaultPrng.init(std.testing.random_seed);
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 33d6036166c55939a5031ed09b532ee01be6c64a..c3250d425dff2d01f31d0b6d259a6dc52ed41d23 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 f01d3444cad29721bdc41ef49ed7784ad87a4066..dd7cba43a0f467b94e1856532a8b4169c9e0e4c4 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, .{
@@ -237,10 +237,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,
@@ -262,7 +262,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",
@@ -312,28 +312,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",
@@ -371,7 +371,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,
@@ -379,17 +379,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 {