@zigc/lib 0.16.0-test.1 → 0.16.0

package/std/array_hash_map.zig

@@ -12,27 +12,15 @@ const hash_map = @This();
 /// An `ArrayHashMap` with default hash and equal functions.
 ///
 /// See `AutoContext` for a description of the hash and equal implementations.
-pub fn AutoArrayHashMap(comptime K: type, comptime V: type) type {
+pub fn Auto(comptime K: type, comptime V: type) type {
     return ArrayHashMap(K, V, AutoContext(K), !autoEqlIsCheap(K));
 }
 
-/// An `ArrayHashMapUnmanaged` with default hash and equal functions.
-///
-/// See `AutoContext` for a description of the hash and equal implementations.
-pub fn AutoArrayHashMapUnmanaged(comptime K: type, comptime V: type) type {
-    return ArrayHashMapUnmanaged(K, V, AutoContext(K), !autoEqlIsCheap(K));
-}
-
 /// An `ArrayHashMap` with strings as keys.
-pub fn StringArrayHashMap(comptime V: type) type {
+pub fn String(comptime V: type) type {
     return ArrayHashMap([]const u8, V, StringContext, true);
 }
 
-/// An `ArrayHashMapUnmanaged` with strings as keys.
-pub fn StringArrayHashMapUnmanaged(comptime V: type) type {
-    return ArrayHashMapUnmanaged([]const u8, V, StringContext, true);
-}
-
 pub const StringContext = struct {
     pub fn hash(self: @This(), s: []const u8) u32 {
         _ = self;
@@ -53,454 +41,8 @@ pub fn hashString(s: []const u8) u32 {
     return @truncate(std.hash.Wyhash.hash(0, s));
 }
 
-/// Deprecated in favor of `ArrayHashMapWithAllocator` (no code changes needed)
-/// or `ArrayHashMapUnmanaged` (will need to update callsites to pass an
-/// allocator). After Zig 0.14.0 is released, `ArrayHashMapWithAllocator` will
-/// be removed and `ArrayHashMapUnmanaged` will be a deprecated alias. After
-/// Zig 0.15.0 is released, the deprecated alias `ArrayHashMapUnmanaged` will
-/// be removed.
-pub const ArrayHashMap = ArrayHashMapWithAllocator;
-
-/// A hash table of keys and values, each stored sequentially.
-///
-/// Insertion order is preserved. In general, this data structure supports the same
-/// operations as `std.ArrayList`.
-///
-/// Deletion operations:
-/// * `swapRemove` - O(1)
-/// * `orderedRemove` - O(N)
-///
-/// Modifying the hash map while iterating is allowed, however, one must understand
-/// the (well defined) behavior when mixing insertions and deletions with iteration.
-///
-/// See `ArrayHashMapUnmanaged` for a variant of this data structure that accepts an
-/// `Allocator` as a parameter when needed rather than storing it.
-pub fn ArrayHashMapWithAllocator(
-    comptime K: type,
-    comptime V: type,
-    /// A namespace that provides these two functions:
-    /// * `pub fn hash(self, K) u32`
-    /// * `pub fn eql(self, K, K, usize) bool`
-    ///
-    /// The final `usize` in the `eql` function represents the index of the key
-    /// that's already inside the map.
-    comptime Context: type,
-    /// When `false`, this data structure is biased towards cheap `eql`
-    /// functions and avoids storing each key's hash in the table. Setting
-    /// `store_hash` to `true` incurs more memory cost but limits `eql` to
-    /// being called only once per insertion/deletion (provided there are no
-    /// hash collisions).
-    comptime store_hash: bool,
-) type {
-    return struct {
-        unmanaged: Unmanaged,
-        allocator: Allocator,
-        ctx: Context,
-
-        /// The ArrayHashMapUnmanaged type using the same settings as this managed map.
-        pub const Unmanaged = ArrayHashMapUnmanaged(K, V, Context, store_hash);
-
-        /// Pointers to a key and value in the backing store of this map.
-        /// Modifying the key is allowed only if it does not change the hash.
-        /// Modifying the value is allowed.
-        /// Entry pointers become invalid whenever this ArrayHashMap is modified,
-        /// unless `ensureTotalCapacity`/`ensureUnusedCapacity` was previously used.
-        pub const Entry = Unmanaged.Entry;
-
-        /// A KV pair which has been copied out of the backing store
-        pub const KV = Unmanaged.KV;
-
-        /// The Data type used for the MultiArrayList backing this map
-        pub const Data = Unmanaged.Data;
-        /// The MultiArrayList type backing this map
-        pub const DataList = Unmanaged.DataList;
-
-        /// The stored hash type, either u32 or void.
-        pub const Hash = Unmanaged.Hash;
-
-        /// getOrPut variants return this structure, with pointers
-        /// to the backing store and a flag to indicate whether an
-        /// existing entry was found.
-        /// Modifying the key is allowed only if it does not change the hash.
-        /// Modifying the value is allowed.
-        /// Entry pointers become invalid whenever this ArrayHashMap is modified,
-        /// unless `ensureTotalCapacity`/`ensureUnusedCapacity` was previously used.
-        pub const GetOrPutResult = Unmanaged.GetOrPutResult;
-
-        /// An Iterator over Entry pointers.
-        pub const Iterator = Unmanaged.Iterator;
-
-        const Self = @This();
-
-        /// Create an ArrayHashMap instance which will use a specified allocator.
-        pub fn init(allocator: Allocator) Self {
-            if (@sizeOf(Context) != 0)
-                @compileError("Cannot infer context " ++ @typeName(Context) ++ ", call initContext instead.");
-            return initContext(allocator, undefined);
-        }
-        pub fn initContext(allocator: Allocator, ctx: Context) Self {
-            return .{
-                .unmanaged = .empty,
-                .allocator = allocator,
-                .ctx = ctx,
-            };
-        }
-
-        /// Frees the backing allocation and leaves the map in an undefined state.
-        /// Note that this does not free keys or values.  You must take care of that
-        /// before calling this function, if it is needed.
-        pub fn deinit(self: *Self) void {
-            self.unmanaged.deinit(self.allocator);
-            self.* = undefined;
-        }
-
-        /// Puts the hash map into a state where any method call that would
-        /// cause an existing key or value pointer to become invalidated will
-        /// instead trigger an assertion.
-        ///
-        /// An additional call to `lockPointers` in such state also triggers an
-        /// assertion.
-        ///
-        /// `unlockPointers` returns the hash map to the previous state.
-        pub fn lockPointers(self: *Self) void {
-            self.unmanaged.lockPointers();
-        }
-
-        /// Undoes a call to `lockPointers`.
-        pub fn unlockPointers(self: *Self) void {
-            self.unmanaged.unlockPointers();
-        }
-
-        /// Clears the map but retains the backing allocation for future use.
-        pub fn clearRetainingCapacity(self: *Self) void {
-            return self.unmanaged.clearRetainingCapacity();
-        }
-
-        /// Clears the map and releases the backing allocation
-        pub fn clearAndFree(self: *Self) void {
-            return self.unmanaged.clearAndFree(self.allocator);
-        }
-
-        /// Returns the number of KV pairs stored in this map.
-        pub fn count(self: Self) usize {
-            return self.unmanaged.count();
-        }
-
-        /// Returns the backing array of keys in this map. Modifying the map may
-        /// invalidate this array. Modifying this array in a way that changes
-        /// key hashes or key equality puts the map into an unusable state until
-        /// `reIndex` is called.
-        pub fn keys(self: Self) []K {
-            return self.unmanaged.keys();
-        }
-        /// Returns the backing array of values in this map. Modifying the map
-        /// may invalidate this array. It is permitted to modify the values in
-        /// this array.
-        pub fn values(self: Self) []V {
-            return self.unmanaged.values();
-        }
-
-        /// Returns an iterator over the pairs in this map.
-        /// Modifying the map may invalidate this iterator.
-        pub fn iterator(self: *const Self) Iterator {
-            return self.unmanaged.iterator();
-        }
-
-        /// If key exists this function cannot fail.
-        /// If there is an existing item with `key`, then the result
-        /// `Entry` pointer points to it, and found_existing is true.
-        /// Otherwise, puts a new item with undefined value, and
-        /// the `Entry` pointer points to it. Caller should then initialize
-        /// the value (but not the key).
-        pub fn getOrPut(self: *Self, key: K) !GetOrPutResult {
-            return self.unmanaged.getOrPutContext(self.allocator, key, self.ctx);
-        }
-        pub fn getOrPutAdapted(self: *Self, key: anytype, ctx: anytype) !GetOrPutResult {
-            return self.unmanaged.getOrPutContextAdapted(self.allocator, key, ctx, self.ctx);
-        }
-
-        /// If there is an existing item with `key`, then the result
-        /// `Entry` pointer points to it, and found_existing is true.
-        /// Otherwise, puts a new item with undefined value, and
-        /// the `Entry` pointer points to it. Caller should then initialize
-        /// the value (but not the key).
-        /// If a new entry needs to be stored, this function asserts there
-        /// is enough capacity to store it.
-        pub fn getOrPutAssumeCapacity(self: *Self, key: K) GetOrPutResult {
-            return self.unmanaged.getOrPutAssumeCapacityContext(key, self.ctx);
-        }
-        pub fn getOrPutAssumeCapacityAdapted(self: *Self, key: anytype, ctx: anytype) GetOrPutResult {
-            return self.unmanaged.getOrPutAssumeCapacityAdapted(key, ctx);
-        }
-        pub fn getOrPutValue(self: *Self, key: K, value: V) !GetOrPutResult {
-            return self.unmanaged.getOrPutValueContext(self.allocator, key, value, self.ctx);
-        }
-
-        /// Increases capacity, guaranteeing that insertions up until the
-        /// `expected_count` will not cause an allocation, and therefore cannot fail.
-        pub fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
-            return self.unmanaged.ensureTotalCapacityContext(self.allocator, new_capacity, self.ctx);
-        }
-
-        /// Increases capacity, guaranteeing that insertions up until
-        /// `additional_count` **more** items will not cause an allocation, and
-        /// therefore cannot fail.
-        pub fn ensureUnusedCapacity(self: *Self, additional_count: usize) !void {
-            return self.unmanaged.ensureUnusedCapacityContext(self.allocator, additional_count, self.ctx);
-        }
-
-        /// Returns the number of total elements which may be present before it is
-        /// no longer guaranteed that no allocations will be performed.
-        pub fn capacity(self: Self) usize {
-            return self.unmanaged.capacity();
-        }
-
-        /// Clobbers any existing data. To detect if a put would clobber
-        /// existing data, see `getOrPut`.
-        pub fn put(self: *Self, key: K, value: V) !void {
-            return self.unmanaged.putContext(self.allocator, key, value, self.ctx);
-        }
-
-        /// Inserts a key-value pair into the hash map, asserting that no previous
-        /// entry with the same key is already present
-        pub fn putNoClobber(self: *Self, key: K, value: V) !void {
-            return self.unmanaged.putNoClobberContext(self.allocator, key, value, self.ctx);
-        }
-
-        /// Asserts there is enough capacity to store the new key-value pair.
-        /// Clobbers any existing data. To detect if a put would clobber
-        /// existing data, see `getOrPutAssumeCapacity`.
-        pub fn putAssumeCapacity(self: *Self, key: K, value: V) void {
-            return self.unmanaged.putAssumeCapacityContext(key, value, self.ctx);
-        }
-
-        /// Asserts there is enough capacity to store the new key-value pair.
-        /// Asserts that it does not clobber any existing data.
-        /// To detect if a put would clobber existing data, see `getOrPutAssumeCapacity`.
-        pub fn putAssumeCapacityNoClobber(self: *Self, key: K, value: V) void {
-            return self.unmanaged.putAssumeCapacityNoClobberContext(key, value, self.ctx);
-        }
-
-        /// Inserts a new `Entry` into the hash map, returning the previous one, if any.
-        pub fn fetchPut(self: *Self, key: K, value: V) !?KV {
-            return self.unmanaged.fetchPutContext(self.allocator, key, value, self.ctx);
-        }
-
-        /// Inserts a new `Entry` into the hash map, returning the previous one, if any.
-        /// If insertion happuns, asserts there is enough capacity without allocating.
-        pub fn fetchPutAssumeCapacity(self: *Self, key: K, value: V) ?KV {
-            return self.unmanaged.fetchPutAssumeCapacityContext(key, value, self.ctx);
-        }
-
-        /// Finds pointers to the key and value storage associated with a key.
-        pub fn getEntry(self: Self, key: K) ?Entry {
-            return self.unmanaged.getEntryContext(key, self.ctx);
-        }
-        pub fn getEntryAdapted(self: Self, key: anytype, ctx: anytype) ?Entry {
-            return self.unmanaged.getEntryAdapted(key, ctx);
-        }
-
-        /// Finds the index in the `entries` array where a key is stored
-        pub fn getIndex(self: Self, key: K) ?usize {
-            return self.unmanaged.getIndexContext(key, self.ctx);
-        }
-        pub fn getIndexAdapted(self: Self, key: anytype, ctx: anytype) ?usize {
-            return self.unmanaged.getIndexAdapted(key, ctx);
-        }
-
-        /// Find the value associated with a key
-        pub fn get(self: Self, key: K) ?V {
-            return self.unmanaged.getContext(key, self.ctx);
-        }
-        pub fn getAdapted(self: Self, key: anytype, ctx: anytype) ?V {
-            return self.unmanaged.getAdapted(key, ctx);
-        }
-
-        /// Find a pointer to the value associated with a key
-        pub fn getPtr(self: Self, key: K) ?*V {
-            return self.unmanaged.getPtrContext(key, self.ctx);
-        }
-        pub fn getPtrAdapted(self: Self, key: anytype, ctx: anytype) ?*V {
-            return self.unmanaged.getPtrAdapted(key, ctx);
-        }
-
-        /// Find the actual key associated with an adapted key
-        pub fn getKey(self: Self, key: K) ?K {
-            return self.unmanaged.getKeyContext(key, self.ctx);
-        }
-        pub fn getKeyAdapted(self: Self, key: anytype, ctx: anytype) ?K {
-            return self.unmanaged.getKeyAdapted(key, ctx);
-        }
-
-        /// Find a pointer to the actual key associated with an adapted key
-        pub fn getKeyPtr(self: Self, key: K) ?*K {
-            return self.unmanaged.getKeyPtrContext(key, self.ctx);
-        }
-        pub fn getKeyPtrAdapted(self: Self, key: anytype, ctx: anytype) ?*K {
-            return self.unmanaged.getKeyPtrAdapted(key, ctx);
-        }
-
-        /// Check whether a key is stored in the map
-        pub fn contains(self: Self, key: K) bool {
-            return self.unmanaged.containsContext(key, self.ctx);
-        }
-        pub fn containsAdapted(self: Self, key: anytype, ctx: anytype) bool {
-            return self.unmanaged.containsAdapted(key, ctx);
-        }
-
-        /// If there is an `Entry` with a matching key, it is deleted from
-        /// the hash map, and then returned from this function. The entry is
-        /// removed from the underlying array by swapping it with the last
-        /// element.
-        pub fn fetchSwapRemove(self: *Self, key: K) ?KV {
-            return self.unmanaged.fetchSwapRemoveContext(key, self.ctx);
-        }
-        pub fn fetchSwapRemoveAdapted(self: *Self, key: anytype, ctx: anytype) ?KV {
-            return self.unmanaged.fetchSwapRemoveContextAdapted(key, ctx, self.ctx);
-        }
-
-        /// If there is an `Entry` with a matching key, it is deleted from
-        /// the hash map, and then returned from this function. The entry is
-        /// removed from the underlying array by shifting all elements forward
-        /// thereby maintaining the current ordering.
-        pub fn fetchOrderedRemove(self: *Self, key: K) ?KV {
-            return self.unmanaged.fetchOrderedRemoveContext(key, self.ctx);
-        }
-        pub fn fetchOrderedRemoveAdapted(self: *Self, key: anytype, ctx: anytype) ?KV {
-            return self.unmanaged.fetchOrderedRemoveContextAdapted(key, ctx, self.ctx);
-        }
-
-        /// If there is an `Entry` with a matching key, it is deleted from
-        /// the hash map. The entry is removed from the underlying array
-        /// by swapping it with the last element.  Returns true if an entry
-        /// was removed, false otherwise.
-        pub fn swapRemove(self: *Self, key: K) bool {
-            return self.unmanaged.swapRemoveContext(key, self.ctx);
-        }
-        pub fn swapRemoveAdapted(self: *Self, key: anytype, ctx: anytype) bool {
-            return self.unmanaged.swapRemoveContextAdapted(key, ctx, self.ctx);
-        }
-
-        /// If there is an `Entry` with a matching key, it is deleted from
-        /// the hash map. The entry is removed from the underlying array
-        /// by shifting all elements forward, thereby maintaining the
-        /// current ordering.  Returns true if an entry was removed, false otherwise.
-        pub fn orderedRemove(self: *Self, key: K) bool {
-            return self.unmanaged.orderedRemoveContext(key, self.ctx);
-        }
-        pub fn orderedRemoveAdapted(self: *Self, key: anytype, ctx: anytype) bool {
-            return self.unmanaged.orderedRemoveContextAdapted(key, ctx, self.ctx);
-        }
-
-        /// Deletes the item at the specified index in `entries` from
-        /// the hash map. The entry is removed from the underlying array
-        /// by swapping it with the last element.
-        pub fn swapRemoveAt(self: *Self, index: usize) void {
-            self.unmanaged.swapRemoveAtContext(index, self.ctx);
-        }
-
-        /// Deletes the item at the specified index in `entries` from
-        /// the hash map. The entry is removed from the underlying array
-        /// by shifting all elements forward, thereby maintaining the
-        /// current ordering.
-        pub fn orderedRemoveAt(self: *Self, index: usize) void {
-            self.unmanaged.orderedRemoveAtContext(index, self.ctx);
-        }
-
-        /// Create a copy of the hash map which can be modified separately.
-        /// The copy uses the same context and allocator as this instance.
-        pub fn clone(self: Self) !Self {
-            var other = try self.unmanaged.cloneContext(self.allocator, self.ctx);
-            return other.promoteContext(self.allocator, self.ctx);
-        }
-        /// Create a copy of the hash map which can be modified separately.
-        /// The copy uses the same context as this instance, but the specified
-        /// allocator.
-        pub fn cloneWithAllocator(self: Self, allocator: Allocator) !Self {
-            var other = try self.unmanaged.cloneContext(allocator, self.ctx);
-            return other.promoteContext(allocator, self.ctx);
-        }
-        /// Create a copy of the hash map which can be modified separately.
-        /// The copy uses the same allocator as this instance, but the
-        /// specified context.
-        pub fn cloneWithContext(self: Self, ctx: anytype) !ArrayHashMap(K, V, @TypeOf(ctx), store_hash) {
-            var other = try self.unmanaged.cloneContext(self.allocator, ctx);
-            return other.promoteContext(self.allocator, ctx);
-        }
-        /// Create a copy of the hash map which can be modified separately.
-        /// The copy uses the specified allocator and context.
-        pub fn cloneWithAllocatorAndContext(self: Self, allocator: Allocator, ctx: anytype) !ArrayHashMap(K, V, @TypeOf(ctx), store_hash) {
-            var other = try self.unmanaged.cloneContext(allocator, ctx);
-            return other.promoteContext(allocator, ctx);
-        }
-
-        /// Set the map to an empty state, making deinitialization a no-op, and
-        /// returning a copy of the original.
-        pub fn move(self: *Self) Self {
-            self.unmanaged.pointer_stability.assertUnlocked();
-            const result = self.*;
-            self.unmanaged = .empty;
-            return result;
-        }
-
-        /// Recomputes stored hashes and rebuilds the key indexes. If the
-        /// underlying keys have been modified directly, call this method to
-        /// recompute the denormalized metadata necessary for the operation of
-        /// the methods of this map that lookup entries by key.
-        ///
-        /// One use case for this is directly calling `entries.resize()` to grow
-        /// the underlying storage, and then setting the `keys` and `values`
-        /// directly without going through the methods of this map.
-        ///
-        /// The time complexity of this operation is O(n).
-        pub fn reIndex(self: *Self) !void {
-            return self.unmanaged.reIndexContext(self.allocator, self.ctx);
-        }
-
-        /// Sorts the entries and then rebuilds the index.
-        /// `sort_ctx` must have this method:
-        /// `fn lessThan(ctx: @TypeOf(ctx), a_index: usize, b_index: usize) bool`
-        /// Uses a stable sorting algorithm.
-        pub fn sort(self: *Self, sort_ctx: anytype) void {
-            return self.unmanaged.sortContext(sort_ctx, self.ctx);
-        }
-
-        /// Sorts the entries and then rebuilds the index.
-        /// `sort_ctx` must have this method:
-        /// `fn lessThan(ctx: @TypeOf(ctx), a_index: usize, b_index: usize) bool`
-        /// Uses an unstable sorting algorithm.
-        pub fn sortUnstable(self: *Self, sort_ctx: anytype) void {
-            return self.unmanaged.sortUnstableContext(sort_ctx, self.ctx);
-        }
-
-        /// Shrinks the underlying `Entry` array to `new_len` elements and
-        /// discards any associated index entries. Keeps capacity the same.
-        ///
-        /// Asserts the discarded entries remain initialized and capable of
-        /// performing hash and equality checks. Any deinitialization of
-        /// discarded entries must take place *after* calling this function.
-        pub fn shrinkRetainingCapacity(self: *Self, new_len: usize) void {
-            return self.unmanaged.shrinkRetainingCapacityContext(new_len, self.ctx);
-        }
-
-        /// Shrinks the underlying `Entry` array to `new_len` elements and
-        /// discards any associated index entries. Reduces allocated capacity.
-        ///
-        /// Asserts the discarded entries remain initialized and capable of
-        /// performing hash and equality checks. It is a bug to call this
-        /// function if the discarded entries require deinitialization. For
-        /// that use case, `shrinkRetainingCapacity` can be used instead.
-        pub fn shrinkAndFree(self: *Self, new_len: usize) void {
-            return self.unmanaged.shrinkAndFreeContext(self.allocator, new_len, self.ctx);
-        }
-
-        /// Removes the last inserted `Entry` in the hash map and returns it if count is nonzero.
-        /// Otherwise returns null.
-        pub fn pop(self: *Self) ?KV {
-            return self.unmanaged.popContext(self.ctx);
-        }
-    };
-}
+/// Deprecated; use `Custom`.
+pub const ArrayHashMap = Custom;
 
 /// A hash table of keys and values, each stored sequentially.
 ///
@@ -522,11 +64,11 @@ pub fn ArrayHashMapWithAllocator(
 ///
 /// This type is designed to have low overhead for small numbers of entries. When
 /// `store_hash` is `false` and the number of entries in the map is less than 9,
-/// the overhead cost of using `ArrayHashMapUnmanaged` rather than `std.ArrayList` is
+/// the overhead cost of using `ArrayHashMap` rather than `std.ArrayList` is
 /// only a single pointer-sized integer.
 ///
 /// Default initialization of this struct is deprecated; use `.empty` instead.
-pub fn ArrayHashMapUnmanaged(
+pub fn Custom(
     comptime K: type,
     comptime V: type,
     /// A namespace that provides these two functions:
@@ -605,9 +147,6 @@ pub fn ArrayHashMapUnmanaged(
             index: usize,
         };
 
-        /// The ArrayHashMap type using the same settings as this managed map.
-        pub const Managed = ArrayHashMap(K, V, Context, store_hash);
-
         /// Some functions require a context only if hashes are not stored.
         /// To keep the api simple, this type is only used internally.
         const ByIndexContext = if (store_hash) void else Context;
@@ -626,21 +165,6 @@ pub fn ArrayHashMapUnmanaged(
 
         const Oom = Allocator.Error;
 
-        /// Convert from an unmanaged map to a managed map.  After calling this,
-        /// the promoted map should no longer be used.
-        pub fn promote(self: Self, gpa: Allocator) Managed {
-            if (@sizeOf(Context) != 0)
-                @compileError("Cannot infer context " ++ @typeName(Context) ++ ", call promoteContext instead.");
-            return self.promoteContext(gpa, undefined);
-        }
-        pub fn promoteContext(self: Self, gpa: Allocator, ctx: Context) Managed {
-            return .{
-                .unmanaged = self,
-                .allocator = gpa,
-                .ctx = ctx,
-            };
-        }
-
         pub fn init(gpa: Allocator, key_list: []const K, value_list: []const V) Oom!Self {
             var self: Self = .{};
             errdefer self.deinit(gpa);
@@ -2189,35 +1713,37 @@ const IndexHeader = struct {
 };
 
 test "basic hash map usage" {
-    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
 
-    try testing.expect((try map.fetchPut(1, 11)) == null);
-    try testing.expect((try map.fetchPut(2, 22)) == null);
-    try testing.expect((try map.fetchPut(3, 33)) == null);
-    try testing.expect((try map.fetchPut(4, 44)) == null);
+    var map: Auto(i32, i32) = .empty;
+    defer map.deinit(gpa);
+
+    try testing.expect((try map.fetchPut(gpa, 1, 11)) == null);
+    try testing.expect((try map.fetchPut(gpa, 2, 22)) == null);
+    try testing.expect((try map.fetchPut(gpa, 3, 33)) == null);
+    try testing.expect((try map.fetchPut(gpa, 4, 44)) == null);
 
-    try map.putNoClobber(5, 55);
-    try testing.expect((try map.fetchPut(5, 66)).?.value == 55);
-    try testing.expect((try map.fetchPut(5, 55)).?.value == 66);
+    try map.putNoClobber(gpa, 5, 55);
+    try testing.expect((try map.fetchPut(gpa, 5, 66)).?.value == 55);
+    try testing.expect((try map.fetchPut(gpa, 5, 55)).?.value == 66);
 
-    const gop1 = try map.getOrPut(5);
+    const gop1 = try map.getOrPut(gpa, 5);
     try testing.expect(gop1.found_existing == true);
     try testing.expect(gop1.value_ptr.* == 55);
     try testing.expect(gop1.index == 4);
     gop1.value_ptr.* = 77;
     try testing.expect(map.getEntry(5).?.value_ptr.* == 77);
 
-    const gop2 = try map.getOrPut(99);
+    const gop2 = try map.getOrPut(gpa, 99);
     try testing.expect(gop2.found_existing == false);
     try testing.expect(gop2.index == 5);
     gop2.value_ptr.* = 42;
     try testing.expect(map.getEntry(99).?.value_ptr.* == 42);
 
-    const gop3 = try map.getOrPutValue(5, 5);
+    const gop3 = try map.getOrPutValue(gpa, 5, 5);
     try testing.expect(gop3.value_ptr.* == 77);
 
-    const gop4 = try map.getOrPutValue(100, 41);
+    const gop4 = try map.getOrPutValue(gpa, 100, 41);
     try testing.expect(gop4.value_ptr.* == 41);
 
     try testing.expect(map.contains(2));
@@ -2234,7 +1760,7 @@ test "basic hash map usage" {
 
     // Since we've used `swapRemove` above, the index of this entry should remain unchanged.
     try testing.expect(map.getIndex(100).? == 1);
-    const gop5 = try map.getOrPut(5);
+    const gop5 = try map.getOrPut(gpa, 5);
     try testing.expect(gop5.found_existing == true);
     try testing.expect(gop5.value_ptr.* == 77);
     try testing.expect(gop5.index == 4);
@@ -2247,7 +1773,7 @@ test "basic hash map usage" {
     try testing.expect(map.orderedRemove(100) == false);
     try testing.expect(map.getEntry(100) == null);
     try testing.expect(map.get(100) == null);
-    const gop6 = try map.getOrPut(5);
+    const gop6 = try map.getOrPut(gpa, 5);
     try testing.expect(gop6.found_existing == true);
     try testing.expect(gop6.value_ptr.* == 77);
     try testing.expect(gop6.index == 3);
@@ -2256,15 +1782,17 @@ test "basic hash map usage" {
 }
 
 test "iterator hash map" {
-    var reset_map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer reset_map.deinit();
+    const gpa = testing.allocator;
+
+    var reset_map: Auto(i32, i32) = .empty;
+    defer reset_map.deinit(gpa);
 
     // test ensureTotalCapacity with a 0 parameter
-    try reset_map.ensureTotalCapacity(0);
+    try reset_map.ensureTotalCapacity(gpa, 0);
 
-    try reset_map.putNoClobber(0, 11);
-    try reset_map.putNoClobber(1, 22);
-    try reset_map.putNoClobber(2, 33);
+    try reset_map.putNoClobber(gpa, 0, 11);
+    try reset_map.putNoClobber(gpa, 1, 22);
+    try reset_map.putNoClobber(gpa, 2, 33);
 
     const keys = [_]i32{
         0, 2, 1,
@@ -2312,10 +1840,12 @@ test "iterator hash map" {
 }
 
 test "ensure capacity" {
-    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
 
-    try map.ensureTotalCapacity(20);
+    var map: Auto(i32, i32) = .empty;
+    defer map.deinit(gpa);
+
+    try map.ensureTotalCapacity(gpa, 20);
     const initial_capacity = map.capacity();
     try testing.expect(initial_capacity >= 20);
     var i: i32 = 0;
@@ -2329,23 +1859,25 @@ test "ensure capacity" {
 test "ensure capacity leak" {
     try testing.checkAllAllocationFailures(std.testing.allocator, struct {
         pub fn f(allocator: Allocator) !void {
-            var map = AutoArrayHashMap(i32, i32).init(allocator);
-            defer map.deinit();
+            var map: Auto(i32, i32) = .empty;
+            defer map.deinit(allocator);
 
             var i: i32 = 0;
             // put more than `linear_scan_max` in so index_header gets allocated.
-            while (i <= 20) : (i += 1) try map.put(i, i);
+            while (i <= 20) : (i += 1) try map.put(allocator, i, i);
         }
     }.f, .{});
 }
 
 test "big map" {
-    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Auto(i32, i32) = .empty;
+    defer map.deinit(gpa);
 
     var i: i32 = 0;
     while (i < 8) : (i += 1) {
-        try map.put(i, i + 10);
+        try map.put(gpa, i, i + 10);
     }
 
     i = 0;
@@ -2358,7 +1890,7 @@ test "big map" {
 
     i = 4;
     while (i < 12) : (i += 1) {
-        try map.put(i, i + 12);
+        try map.put(gpa, i, i + 12);
     }
 
     i = 0;
@@ -2393,17 +1925,19 @@ test "big map" {
 }
 
 test "clone" {
-    var original = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer original.deinit();
+    const gpa = testing.allocator;
+
+    var original: Auto(i32, i32) = .empty;
+    defer original.deinit(gpa);
 
     // put more than `linear_scan_max` so we can test that the index header is properly cloned
     var i: u8 = 0;
     while (i < 10) : (i += 1) {
-        try original.putNoClobber(i, i * 10);
+        try original.putNoClobber(gpa, i, i * 10);
     }
 
-    var copy = try original.clone();
-    defer copy.deinit();
+    var copy = try original.clone(gpa);
+    defer copy.deinit(gpa);
 
     i = 0;
     while (i < 10) : (i += 1) {
@@ -2419,16 +1953,18 @@ test "clone" {
 }
 
 test "shrink" {
-    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Auto(i32, i32) = .empty;
+    defer map.deinit(gpa);
 
     // This test is more interesting if we insert enough entries to allocate the index header.
     const num_entries = 200;
     var i: i32 = 0;
     while (i < num_entries) : (i += 1)
-        try testing.expect((try map.fetchPut(i, i * 10)) == null);
+        try testing.expect((try map.fetchPut(gpa, i, i * 10)) == null);
 
-    try testing.expect(map.unmanaged.index_header != null);
+    try testing.expect(map.index_header != null);
     try testing.expect(map.count() == num_entries);
 
     // Test `shrinkRetainingCapacity`.
@@ -2437,7 +1973,7 @@ test "shrink" {
     try testing.expect(map.capacity() >= num_entries);
     i = 0;
     while (i < num_entries) : (i += 1) {
-        const gop = try map.getOrPut(i);
+        const gop = try map.getOrPut(gpa, i);
         if (i < 17) {
             try testing.expect(gop.found_existing == true);
             try testing.expect(gop.value_ptr.* == i * 10);
@@ -2445,12 +1981,12 @@ test "shrink" {
     }
 
     // Test `shrinkAndFree`.
-    map.shrinkAndFree(15);
+    map.shrinkAndFree(gpa, 15);
     try testing.expect(map.count() == 15);
     try testing.expect(map.capacity() == 15);
     i = 0;
     while (i < num_entries) : (i += 1) {
-        const gop = try map.getOrPut(i);
+        const gop = try map.getOrPut(gpa, i);
         if (i < 15) {
             try testing.expect(gop.found_existing == true);
             try testing.expect(gop.value_ptr.* == i * 10);
@@ -2459,15 +1995,17 @@ test "shrink" {
 }
 
 test "pop()" {
-    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Auto(i32, i32) = .empty;
+    defer map.deinit(gpa);
 
     // Insert just enough entries so that the map expands. Afterwards,
     // pop all entries out of the map.
 
     var i: i32 = 0;
     while (i < 9) : (i += 1) {
-        try testing.expect((try map.fetchPut(i, i)) == null);
+        try testing.expect((try map.fetchPut(gpa, i, i)) == null);
     }
 
     while (map.pop()) |pop| {
@@ -2479,31 +2017,33 @@ test "pop()" {
 }
 
 test "reIndex" {
-    var map = ArrayHashMap(i32, i32, AutoContext(i32), true).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Custom(i32, i32, AutoContext(i32), true) = .empty;
+    defer map.deinit(gpa);
 
     // Populate via the API.
     const num_indexed_entries = 200;
     var i: i32 = 0;
     while (i < num_indexed_entries) : (i += 1)
-        try testing.expect((try map.fetchPut(i, i * 10)) == null);
+        try testing.expect((try map.fetchPut(gpa, i, i * 10)) == null);
 
     // Make sure we allocated an index header.
-    try testing.expect(map.unmanaged.index_header != null);
+    try testing.expect(map.index_header != null);
 
     // Now write to the arrays directly.
     const num_unindexed_entries = 20;
-    try map.unmanaged.entries.resize(std.testing.allocator, num_indexed_entries + num_unindexed_entries);
+    try map.entries.resize(std.testing.allocator, num_indexed_entries + num_unindexed_entries);
     for (map.keys()[num_indexed_entries..], map.values()[num_indexed_entries..], num_indexed_entries..) |*key, *value, j| {
         key.* = @intCast(j);
         value.* = @intCast(j * 10);
     }
 
     // After reindexing, we should see everything.
-    try map.reIndex();
+    try map.reIndex(gpa);
     i = 0;
     while (i < num_indexed_entries + num_unindexed_entries) : (i += 1) {
-        const gop = try map.getOrPut(i);
+        const gop = try map.getOrPut(gpa, i);
         try testing.expect(gop.found_existing == true);
         try testing.expect(gop.value_ptr.* == i * 10);
         try testing.expect(gop.index == i);
@@ -2511,23 +2051,20 @@ test "reIndex" {
 }
 
 test "auto store_hash" {
-    const HasCheapEql = AutoArrayHashMap(i32, i32);
-    const HasExpensiveEql = AutoArrayHashMap([32]i32, i32);
+    const HasCheapEql = Auto(i32, i32);
+    const HasExpensiveEql = Auto([32]i32, i32);
     try testing.expect(@FieldType(HasCheapEql.Data, "hash") == void);
     try testing.expect(@FieldType(HasExpensiveEql.Data, "hash") != void);
-
-    const HasCheapEqlUn = AutoArrayHashMapUnmanaged(i32, i32);
-    const HasExpensiveEqlUn = AutoArrayHashMapUnmanaged([32]i32, i32);
-    try testing.expect(@FieldType(HasCheapEqlUn.Data, "hash") == void);
-    try testing.expect(@FieldType(HasExpensiveEqlUn.Data, "hash") != void);
 }
 
 test "sort" {
-    var map = AutoArrayHashMap(i32, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Auto(i32, i32) = .empty;
+    defer map.deinit(gpa);
 
     for ([_]i32{ 8, 3, 12, 10, 2, 4, 9, 5, 6, 13, 14, 15, 16, 1, 11, 17, 7 }) |x| {
-        try map.put(x, x * 3);
+        try map.put(gpa, x, x * 3);
     }
 
     const C = struct {
@@ -2549,15 +2086,17 @@ test "sort" {
 }
 
 test "0 sized key" {
-    var map = AutoArrayHashMap(u0, i32).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Auto(u0, i32) = .empty;
+    defer map.deinit(gpa);
 
     try testing.expectEqual(map.get(0), null);
 
-    try map.put(0, 5);
+    try map.put(gpa, 0, 5);
     try testing.expectEqual(map.get(0), 5);
 
-    try map.put(0, 10);
+    try map.put(gpa, 0, 10);
     try testing.expectEqual(map.get(0), 10);
 
     try testing.expectEqual(map.swapRemove(0), true);
@@ -2565,12 +2104,14 @@ test "0 sized key" {
 }
 
 test "0 sized key and 0 sized value" {
-    var map = AutoArrayHashMap(u0, u0).init(std.testing.allocator);
-    defer map.deinit();
+    const gpa = testing.allocator;
+
+    var map: Auto(u0, u0) = .empty;
+    defer map.deinit(gpa);
 
     try testing.expectEqual(map.get(0), null);
 
-    try map.put(0, 0);
+    try map.put(gpa, 0, 0);
     try testing.expectEqual(map.get(0), 0);
 
     try testing.expectEqual(map.swapRemove(0), true);
@@ -2580,7 +2121,7 @@ test "0 sized key and 0 sized value" {
 test "setKey storehash true" {
     const gpa = std.testing.allocator;
 
-    var map: ArrayHashMapUnmanaged(i32, i32, AutoContext(i32), true) = .empty;
+    var map: ArrayHashMap(i32, i32, AutoContext(i32), true) = .empty;
     defer map.deinit(gpa);
 
     try map.put(gpa, 12, 34);
@@ -2596,7 +2137,7 @@ test "setKey storehash true" {
 test "setKey storehash false" {
     const gpa = std.testing.allocator;
 
-    var map: ArrayHashMapUnmanaged(i32, i32, AutoContext(i32), false) = .empty;
+    var map: ArrayHashMap(i32, i32, AutoContext(i32), false) = .empty;
     defer map.deinit(gpa);
 
     try map.put(gpa, 12, 34);
@@ -2691,7 +2232,7 @@ pub fn getAutoHashStratFn(comptime K: type, comptime Context: type, comptime str
 test "orderedRemoveAtMany" {
     const gpa = testing.allocator;
 
-    var map: AutoArrayHashMapUnmanaged(usize, void) = .empty;
+    var map: Auto(usize, void) = .empty;
     defer map.deinit(gpa);
 
     for (0..10) |n| {