authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-10-16 12:23:38-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2026-10-17 09:29:32+02:00
log0bb017791401030e3a9e26755f9397e4dedb4fcd
tree7650992417840be7e1be58a2ae146103031281bb
parentcf12b653f1e9e62e1038f338652ce268f7f8e478

std: update some ArrayList to unmanaged

2 files changed, 40 insertions(+), 39 deletions(-)

lib/std/fs/test.zig+35-36
......@@ -536,24 +536,24 @@ test "Dir.Iterator" {
536536
537537 try tmp_dir.dir.createDir(io, "some_dir", .default_dir);
538538
539 var arena = ArenaAllocator.init(testing.allocator);
540 defer arena.deinit();
541 const allocator = arena.allocator();
539 var arena_instance = ArenaAllocator.init(testing.allocator);
540 defer arena_instance.deinit();
541 const arena = arena_instance.allocator();
542542
543 var entries = std.array_list.Managed(Dir.Entry).init(allocator);
543 var entries: std.ArrayList(Dir.Entry) = .empty;
544544
545545 // Create iterator.
546546 var iter = tmp_dir.dir.iterate();
547547 while (try iter.next(io)) |entry| {
548548 // We cannot just store `entry` as on Windows, we're re-using the name buffer
549549 // which means we'll actually share the `name` pointer between entries!
550 const name = try allocator.dupe(u8, entry.name);
551 try entries.append(Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
550 const name = try arena.dupe(u8, entry.name);
551 try entries.append(arena, Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
552552 }
553553
554554 try expectEqual(@as(usize, 2), entries.items.len); // note that the Iterator skips '.' and '..'
555 try expect(contains(&entries, .{ .name = "some_file", .kind = .file, .inode = 0 }));
556 try expect(contains(&entries, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
555 try expect(contains(entries.items, .{ .name = "some_file", .kind = .file, .inode = 0 }));
556 try expect(contains(entries.items, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
557557}
558558
559559test "Dir.Iterator many entries" {
......@@ -571,25 +571,25 @@ test "Dir.Iterator many entries" {
571571 file.close(io);
572572 }
573573
574 var arena = ArenaAllocator.init(testing.allocator);
575 defer arena.deinit();
576 const allocator = arena.allocator();
574 var arena_instance = ArenaAllocator.init(testing.allocator);
575 defer arena_instance.deinit();
576 const arena = arena_instance.allocator();
577577
578 var entries = std.array_list.Managed(Dir.Entry).init(allocator);
578 var entries: std.ArrayList(Dir.Entry) = .empty;
579579
580580 // Create iterator.
581581 var iter = tmp_dir.dir.iterate();
582582 while (try iter.next(io)) |entry| {
583583 // We cannot just store `entry` as on Windows, we're re-using the name buffer
584584 // which means we'll actually share the `name` pointer between entries!
585 const name = try allocator.dupe(u8, entry.name);
586 try entries.append(.{ .name = name, .kind = entry.kind, .inode = 0 });
585 const name = try arena.dupe(u8, entry.name);
586 try entries.append(arena, .{ .name = name, .kind = entry.kind, .inode = 0 });
587587 }
588588
589589 i = 0;
590590 while (i < num) : (i += 1) {
591591 const name = try std.mem.print(&buf, "{}", .{i});
592 try expect(contains(&entries, .{ .name = name, .kind = .file, .inode = 0 }));
592 try expect(contains(entries.items, .{ .name = name, .kind = .file, .inode = 0 }));
593593 }
594594}
595595
......@@ -605,26 +605,26 @@ test "Dir.Iterator twice" {
605605
606606 try tmp_dir.dir.createDir(io, "some_dir", .default_dir);
607607
608 var arena = ArenaAllocator.init(testing.allocator);
609 defer arena.deinit();
610 const allocator = arena.allocator();
608 var arena_instance = ArenaAllocator.init(testing.allocator);
609 defer arena_instance.deinit();
610 const arena = arena_instance.allocator();
611611
612612 var i: u8 = 0;
613613 while (i < 2) : (i += 1) {
614 var entries = std.array_list.Managed(Dir.Entry).init(allocator);
614 var entries: std.ArrayList(Dir.Entry) = .empty;
615615
616616 // Create iterator.
617617 var iter = tmp_dir.dir.iterate();
618618 while (try iter.next(io)) |entry| {
619619 // We cannot just store `entry` as on Windows, we're re-using the name buffer
620620 // which means we'll actually share the `name` pointer between entries!
621 const name = try allocator.dupe(u8, entry.name);
622 try entries.append(Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
621 const name = try arena.dupe(u8, entry.name);
622 try entries.append(arena, Dir.Entry{ .name = name, .kind = entry.kind, .inode = 0 });
623623 }
624624
625625 try expectEqual(@as(usize, 2), entries.items.len); // note that the Iterator skips '.' and '..'
626 try expect(contains(&entries, .{ .name = "some_file", .kind = .file, .inode = 0 }));
627 try expect(contains(&entries, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
626 try expect(contains(entries.items, .{ .name = "some_file", .kind = .file, .inode = 0 }));
627 try expect(contains(entries.items, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
628628 }
629629}
630630
......@@ -640,27 +640,27 @@ test "Dir.Iterator reset" {
640640
641641 try tmp_dir.dir.createDir(io, "some_dir", .default_dir);
642642
643 var arena = ArenaAllocator.init(testing.allocator);
644 defer arena.deinit();
645 const allocator = arena.allocator();
643 var arena_instance = ArenaAllocator.init(testing.allocator);
644 defer arena_instance.deinit();
645 const arena = arena_instance.allocator();
646646
647647 // Create iterator.
648648 var iter = tmp_dir.dir.iterate();
649649
650650 var i: u8 = 0;
651651 while (i < 2) : (i += 1) {
652 var entries = std.array_list.Managed(Dir.Entry).init(allocator);
652 var entries: std.ArrayList(Dir.Entry) = .empty;
653653
654654 while (try iter.next(io)) |entry| {
655655 // We cannot just store `entry` as on Windows, we're re-using the name buffer
656656 // which means we'll actually share the `name` pointer between entries!
657 const name = try allocator.dupe(u8, entry.name);
658 try entries.append(.{ .name = name, .kind = entry.kind, .inode = 0 });
657 const name = try arena.dupe(u8, entry.name);
658 try entries.append(arena, .{ .name = name, .kind = entry.kind, .inode = 0 });
659659 }
660660
661661 try expectEqual(@as(usize, 2), entries.items.len); // note that the Iterator skips '.' and '..'
662 try expect(contains(&entries, .{ .name = "some_file", .kind = .file, .inode = 0 }));
663 try expect(contains(&entries, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
662 try expect(contains(entries.items, .{ .name = "some_file", .kind = .file, .inode = 0 }));
663 try expect(contains(entries.items, .{ .name = "some_dir", .kind = .directory, .inode = 0 }));
664664
665665 iter.reader.reset();
666666 }
......@@ -696,11 +696,10 @@ fn entryEql(lhs: Dir.Entry, rhs: Dir.Entry) bool {
696696 return mem.eql(u8, lhs.name, rhs.name) and lhs.kind == rhs.kind;
697697}
698698
699fn contains(entries: *const std.array_list.Managed(Dir.Entry), el: Dir.Entry) bool {
700 for (entries.items) |entry| {
701 if (entryEql(entry, el)) return true;
702 }
703 return false;
699fn contains(entries: []const Dir.Entry, el: Dir.Entry) bool {
700 return for (entries) |entry| {
701 if (entryEql(entry, el)) break true;
702 } else false;
704703}
705704
706705test "Dir.realPath smoke test" {
lib/std/treap.zig+5-3
......@@ -635,14 +635,16 @@ fn testOrderedArrayAndTreapConsistency(array: []u64, treap: *TestTreap) !void {
635635}
636636
637637test "node.{prev(),next()} with random data" {
638 const gpa = std.testing.allocator;
639
638640 var nodes: [100]TestNode = undefined;
639641 var prng = std.Random.DefaultPrng.init(0xdeadbeef);
640642 var iter = SliceIterRandomOrder(TestNode).init(&nodes, prng.random());
641643
642644 var treap = TestTreap{};
643645 // A slow, stupid but correct reference. Ordered.
644 var golden = std.array_list.Managed(u64).init(std.testing.allocator);
645 defer golden.deinit();
646 var golden: std.ArrayList(u64) = .empty;
647 defer golden.deinit(gpa);
646648
647649 // Insert.
648650 iter.reset();
......@@ -653,7 +655,7 @@ test "node.{prev(),next()} with random data" {
653655 const i = findFirstGreaterOrEqual(golden.items, key);
654656 // Ensure not found. If found: `prng`'s fault.
655657 try testing.expect(i == golden.items.len or golden.items[i] > key);
656 try golden.insert(i, key);
658 try golden.insert(gpa, i, key);
657659
658660 // Insert into `treap`.
659661 var entry = treap.getEntryFor(key);