diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index a1bddd0bf6c33ffa1e071719af767a01acfb9b50..c654aa1ae9d234122f7acf702c9dd25b9fb8216c 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -536,24 +536,24 @@ test "Dir.Iterator" {
 
     try tmp_dir.dir.createDir(io, "some_dir", .default_dir);
 
-    var arena = ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
+    var arena_instance = ArenaAllocator.init(testing.allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
 
-    var entries = std.array_list.Managed(Dir.Entry).init(allocator);
+    var entries: std.ArrayList(Dir.Entry) = .empty;
 
     // Create iterator.
     var iter = tmp_dir.dir.iterate();
     while (try iter.next(io)) |entry| {
         // We cannot just store `entry` as on Windows, we're re-using the name buffer
         // which means we'll actually share the `name` pointer between entries!
-        const name = try allocator.dupe(u8, entry.name);
-        try entries.append(Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
+        const name = try arena.dupe(u8, entry.name);
+        try entries.append(arena, Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
     }
 
     try expectEqual(@as(usize, 2), entries.items.len); // note that the Iterator skips '.' and '..'
-    try expect(contains(&entries, .{ .name = "some_file", .kind = .file, .inode = 0 }));
-    try expect(contains(&entries, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
+    try expect(contains(entries.items, .{ .name = "some_file", .kind = .file, .inode = 0 }));
+    try expect(contains(entries.items, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
 }
 
 test "Dir.Iterator many entries" {
@@ -571,25 +571,25 @@ test "Dir.Iterator many entries" {
         file.close(io);
     }
 
-    var arena = ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
+    var arena_instance = ArenaAllocator.init(testing.allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
 
-    var entries = std.array_list.Managed(Dir.Entry).init(allocator);
+    var entries: std.ArrayList(Dir.Entry) = .empty;
 
     // Create iterator.
     var iter = tmp_dir.dir.iterate();
     while (try iter.next(io)) |entry| {
         // We cannot just store `entry` as on Windows, we're re-using the name buffer
         // which means we'll actually share the `name` pointer between entries!
-        const name = try allocator.dupe(u8, entry.name);
-        try entries.append(.{ .name = name, .kind = entry.kind, .inode = 0 });
+        const name = try arena.dupe(u8, entry.name);
+        try entries.append(arena, .{ .name = name, .kind = entry.kind, .inode = 0 });
     }
 
     i = 0;
     while (i < num) : (i += 1) {
         const name = try std.mem.print(&buf, "{}", .{i});
-        try expect(contains(&entries, .{ .name = name, .kind = .file, .inode = 0 }));
+        try expect(contains(entries.items, .{ .name = name, .kind = .file, .inode = 0 }));
     }
 }
 
@@ -605,26 +605,26 @@ test "Dir.Iterator twice" {
 
     try tmp_dir.dir.createDir(io, "some_dir", .default_dir);
 
-    var arena = ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
+    var arena_instance = ArenaAllocator.init(testing.allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
 
     var i: u8 = 0;
     while (i < 2) : (i += 1) {
-        var entries = std.array_list.Managed(Dir.Entry).init(allocator);
+        var entries: std.ArrayList(Dir.Entry) = .empty;
 
         // Create iterator.
         var iter = tmp_dir.dir.iterate();
         while (try iter.next(io)) |entry| {
             // We cannot just store `entry` as on Windows, we're re-using the name buffer
             // which means we'll actually share the `name` pointer between entries!
-            const name = try allocator.dupe(u8, entry.name);
-            try entries.append(Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
+            const name = try arena.dupe(u8, entry.name);
+            try entries.append(arena, Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
         }
 
         try expectEqual(@as(usize, 2), entries.items.len); // note that the Iterator skips '.' and '..'
-        try expect(contains(&entries, .{ .name = "some_file", .kind = .file, .inode = 0 }));
-        try expect(contains(&entries, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
+        try expect(contains(entries.items, .{ .name = "some_file", .kind = .file, .inode = 0 }));
+        try expect(contains(entries.items, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
     }
 }
 
@@ -640,27 +640,27 @@ test "Dir.Iterator reset" {
 
     try tmp_dir.dir.createDir(io, "some_dir", .default_dir);
 
-    var arena = ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
+    var arena_instance = ArenaAllocator.init(testing.allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
 
     // Create iterator.
     var iter = tmp_dir.dir.iterate();
 
     var i: u8 = 0;
     while (i < 2) : (i += 1) {
-        var entries = std.array_list.Managed(Dir.Entry).init(allocator);
+        var entries: std.ArrayList(Dir.Entry) = .empty;
 
         while (try iter.next(io)) |entry| {
             // We cannot just store `entry` as on Windows, we're re-using the name buffer
             // which means we'll actually share the `name` pointer between entries!
-            const name = try allocator.dupe(u8, entry.name);
-            try entries.append(.{ .name = name, .kind = entry.kind, .inode = 0 });
+            const name = try arena.dupe(u8, entry.name);
+            try entries.append(arena, .{ .name = name, .kind = entry.kind, .inode = 0 });
         }
 
         try expectEqual(@as(usize, 2), entries.items.len); // note that the Iterator skips '.' and '..'
-        try expect(contains(&entries, .{ .name = "some_file", .kind = .file, .inode = 0 }));
-        try expect(contains(&entries, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
+        try expect(contains(entries.items, .{ .name = "some_file", .kind = .file, .inode = 0 }));
+        try expect(contains(entries.items, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
 
         iter.reader.reset();
     }
@@ -696,11 +696,10 @@ fn entryEql(lhs: Dir.Entry, rhs: Dir.Entry) bool {
     return mem.eql(u8, lhs.name, rhs.name) and lhs.kind == rhs.kind;
 }
 
-fn contains(entries: *const std.array_list.Managed(Dir.Entry), el: Dir.Entry) bool {
-    for (entries.items) |entry| {
-        if (entryEql(entry, el)) return true;
-    }
-    return false;
+fn contains(entries: []const Dir.Entry, el: Dir.Entry) bool {
+    return for (entries) |entry| {
+        if (entryEql(entry, el)) break true;
+    } else false;
 }
 
 test "Dir.realPath smoke test" {
diff --git a/lib/std/treap.zig b/lib/std/treap.zig
index 36201e8a5879a2d213d1c741c3d4fbec0748bb52..84bd7549a69c9bbfb86e8c2a304b4b1124ac6c64 100644
--- a/lib/std/treap.zig
+++ b/lib/std/treap.zig
@@ -635,14 +635,16 @@ fn testOrderedArrayAndTreapConsistency(array: []u64, treap: *TestTreap) !void {
 }
 
 test "node.{prev(),next()} with random data" {
+    const gpa = std.testing.allocator;
+
     var nodes: [100]TestNode = undefined;
     var prng = std.Random.DefaultPrng.init(0xdeadbeef);
     var iter = SliceIterRandomOrder(TestNode).init(&nodes, prng.random());
 
     var treap = TestTreap{};
     // A slow, stupid but correct reference. Ordered.
-    var golden = std.array_list.Managed(u64).init(std.testing.allocator);
-    defer golden.deinit();
+    var golden: std.ArrayList(u64) = .empty;
+    defer golden.deinit(gpa);
 
     // Insert.
     iter.reset();
@@ -653,7 +655,7 @@ test "node.{prev(),next()} with random data" {
         const i = findFirstGreaterOrEqual(golden.items, key);
         // Ensure not found. If found: `prng`'s fault.
         try testing.expect(i == golden.items.len or golden.items[i] > key);
-        try golden.insert(i, key);
+        try golden.insert(gpa, i, key);
 
         // Insert into `treap`.
         var entry = treap.getEntryFor(key);