Commit b28460b499847151f3b62a87cb3ddf5f1e73093c | zig

author	Andrew Kelley <andrew@ziglang.org> 2026-06-11 05:59:44+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-06-11 05:59:44+02:00
log	b28460b499847151f3b62a87cb3ddf5f1e73093c
tree	6a386ce03e8507a171255612fab077cb302d3e94
parent	6ae46c1bc8c55db2207bc32183a62607a80ee642
parent	c91727108ec70019b0e1940e719bbf795ebf26c8

Merge pull request 'Rename usages of all deprecated `ArrayHashMapUnmanaged` to `array_hash_map`' (#35470) from kada49/zig:array_hash_map_deprecation_rename into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/35470
Reviewed-by: Andrew Kelley <andrew@ziglang.org>

79 files changed, 389 insertions(+), 389 deletions(-)

lib
- compiler
  - Maker.zig
  - Maker
    Fuzz.zig
    ScannedConfig.zig
    Step.zig
    Step
    Compile.zig
    TranslateC.zig
    Watch.zig
  - aro
    aro
    Compilation.zig
    DepFile.zig
    Preprocessor.zig
    StringInterner.zig
    backend
    Interner.zig
    Ir.zig
  - configurer.zig
  - reduce
    Walk.zig
  - resinator
    cli.zig
    compile.zig
    cvtres.zig
  - translate-c
    Scope.zig
    Translator.zig
- docs
  - wasm
    Walk.zig
    main.zig
- fuzzer.zig
- std
  - Build.zig
  - Build
    Cache.zig
    Module.zig
    Step
    Compile.zig
  - Io
    Kqueue.zig
  - debug
    Coverage.zig
    Dwarf.zig
    MachOFile.zig
    SelfInfo
    MachO.zig
  - json
    hashmap.zig
  - process
    Environ.zig
    Preopens.zig
  - zig
    Ast
    Render.zig
    AstGen.zig
    llvm
    Builder.zig
src
- Compilation.zig
- InternPool.zig
- Package
- Sema.zig
- Type.zig
- Zcu.zig
- Zcu
  - PerThread.zig
- codegen
  - aarch64
    Select.zig
  - c.zig
  - c
    type.zig
  - llvm
    FuncGen.zig
  - riscv64
    CodeGen.zig
  - sparc64
    CodeGen.zig
  - spirv
    Assembler.zig
    Module.zig
  - wasm
    CodeGen.zig
    Mir.zig
  - x86_64
    CodeGen.zig
- libs
  - mingw
    implib.zig
- link.zig
- link
  - C.zig
  - Coff.zig
  - ConstPool.zig
  - Dwarf.zig
  - Elf.zig
  - Elf
    AtomList.zig
    Thunk.zig
    ZigObject.zig
  - Elf2.zig
  - MachO.zig
  - MachO
    Dylib.zig
    Thunk.zig
    ZigObject.zig
  - SpirV
    lower_invocation_globals.zig
  - Wasm.zig
  - Wasm
    Archive.zig
    Flush.zig
- main.zig
tools
- dump-cov.zig

lib/compiler/Maker.zig+4-4

...	...	@@ -49,7 +49,7 @@ web_server: if (!builtin.single_threaded) ?WebServer else ?noreturn,
49	49	/// Allocated into `gpa`.
50	50	memory_blocked_steps: std.ArrayList(Configuration.Step.Index),
51	51	/// Allocated into `gpa`.
52		step_stack: std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, void),
	52	step_stack: std.array_hash_map.Auto(Configuration.Step.Index, void),
53	53	pkg_config: PkgConfig,
54	54
55	55	error_style: ErrorStyle,
...	...	@@ -481,7 +481,7 @@ pub fn main(init: process.Init.Minimal) !void {
481	481	// maker process fails or crashes and it's helpful to be able to repeat
482	482	// execution of the command line or otherwise inspect the configuration file.
483	483	const c = &configuration;
484		var top_level_steps: std.StringArrayHashMapUnmanaged(Configuration.Step.Index) = .empty;
	484	var top_level_steps: std.array_hash_map.String(Configuration.Step.Index) = .empty;
485	485	for (configuration.steps, 0..) \|*conf_step, step_index_usize\| {
486	486	if (conf_step.owner != .root) continue;
487	487	const step_index: Configuration.Step.Index = @enumFromInt(step_index_usize);
...	...	@@ -1217,7 +1217,7 @@ fn printTreeStep(
1217	1217	step_index: Configuration.Step.Index,
1218	1218	stderr: Io.Terminal,
1219	1219	parent_node: *PrintNode,
1220		step_stack: *std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, void),
	1220	step_stack: *std.array_hash_map.Auto(Configuration.Step.Index, void),
1221	1221	) !void {
1222	1222	const writer = stderr.writer;
1223	1223	const first = step_stack.swapRemove(step_index);
...	...	@@ -1502,7 +1502,7 @@ fn printChildNodePrefix(stderr: Io.Terminal) !void {
1502	1502	fn constructGraphAndCheckForDependencyLoop(
1503	1503	maker: *Maker,
1504	1504	step_index: Configuration.Step.Index,
1505		step_stack: *std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, void),
	1505	step_stack: *std.array_hash_map.Auto(Configuration.Step.Index, void),
1506	1506	rand: std.Random,
1507	1507	) error{ DependencyLoopDetected, OutOfMemory }!void {
1508	1508	const c = &maker.scanned_config.configuration;

lib/compiler/Maker/Fuzz.zig+2-2

...	...	@@ -27,7 +27,7 @@ prog_node: std.Progress.Node,
27	27
28	28	/// Protects `coverage_files`.
29	29	coverage_mutex: Io.Mutex,
30		coverage_files: std.AutoArrayHashMapUnmanaged(u64, CoverageMap),
	30	coverage_files: std.array_hash_map.Auto(u64, CoverageMap),
31	31
32	32	queue_mutex: Io.Mutex,
33	33	queue_cond: Io.Condition,
...	...	@@ -273,7 +273,7 @@ pub fn serveSourcesTar(fuzz: Fuzz, req: std.http.Server.Request) !void {
273	273	defer arena_state.deinit();
274	274	const arena = arena_state.allocator();
275	275
276		const DedupTable = std.ArrayHashMapUnmanaged(Build.Cache.Path, void, Build.Cache.Path.TableAdapter, false);
	276	const DedupTable = std.array_hash_map.Custom(Build.Cache.Path, void, Build.Cache.Path.TableAdapter, false);
277	277	var dedup_table: DedupTable = .empty;
278	278	defer dedup_table.deinit(gpa);
279	279

lib/compiler/Maker/ScannedConfig.zig+1-1

...	...	@@ -8,7 +8,7 @@ const Serializer = std.zon.Serializer;
8	8	const Graph = @import("Graph.zig");
9	9
10	10	configuration: Configuration,
11		top_level_steps: std.StringArrayHashMapUnmanaged(Configuration.Step.Index),
	11	top_level_steps: std.array_hash_map.String(Configuration.Step.Index),
12	12	path: []const u8,
13	13
14	14	pub fn print(sc: const ScannedConfig, w: Writer) Writer.Error!void {

lib/compiler/Maker/Step.zig+1-1

...	...	@@ -180,7 +180,7 @@ pub const Inputs = struct {
180	180	.table = .{},
181	181	};
182	182
183		pub const Table = std.ArrayHashMapUnmanaged(Path, Files, Path.TableAdapter, false);
	183	pub const Table = std.array_hash_map.Custom(Path, Files, Path.TableAdapter, false);
184	184	/// The special file name "." means any changes inside the directory.
185	185	pub const Files = std.ArrayList([]const u8);
186	186

lib/compiler/Maker/Step/Compile.zig+7-7

...	...	@@ -119,9 +119,9 @@ fn updateGeneratedFile(
119	119
120	120	/// List of importable modules in a compilation's module graph, including
121	121	/// the root module. The root module is guaranteed to be first.
122		const ModuleList = std.AutoArrayHashMapUnmanaged(Configuration.Module.Index, Configuration.String);
	122	const ModuleList = std.array_hash_map.Auto(Configuration.Module.Index, Configuration.String);
123	123	/// Keyed on the first key in the module list.
124		pub const ModuleGraph = std.ArrayHashMapUnmanaged(ModuleList, void, ModuleListContext, false);
	124	pub const ModuleGraph = std.array_hash_map.Custom(ModuleList, void, ModuleListContext, false);
125	125
126	126	const ModuleListContext = struct {
127	127	pub fn eql(ctx: @This(), a: ModuleList, b: ModuleList) bool {
...	...	@@ -221,8 +221,8 @@ fn lowerZigArgs(
221	221	// module, along with any C compiler arguments that need to be passed
222	222	// to the compiler for each module individually as reported by
223	223	// pkg-config.
224		var seen_system_libs: std.AutoArrayHashMapUnmanaged(Configuration.String, []const []const u8) = .empty;
225		var frameworks: std.AutoArrayHashMapUnmanaged(Configuration.String, Configuration.Module.Framework.Flags) = .empty;
	224	var seen_system_libs: std.array_hash_map.Auto(Configuration.String, []const []const u8) = .empty;
	225	var frameworks: std.array_hash_map.Auto(Configuration.String, Configuration.Module.Framework.Flags) = .empty;
226	226	var module_graph: ModuleGraph = .empty;
227	227
228	228	var prev_has_cflags = false;
...	...	@@ -1126,8 +1126,8 @@ fn moduleNeedsCliArg(mod: const Configuration.Module, conf: const Configuratio
1126	1126	}
1127	1127
1128	1128	const CliNamedModules = struct {
1129		modules: std.AutoArrayHashMapUnmanaged(Configuration.Module.Index, void),
1130		names: std.StringArrayHashMapUnmanaged(void),
	1129	modules: std.array_hash_map.Auto(Configuration.Module.Index, void),
	1130	names: std.array_hash_map.String(void),
1131	1131
1132	1132	/// Traverse the whole dependency graph and give every module a unique
1133	1133	/// name, ideally one named after what it's called somewhere in the graph.
...	...	@@ -1177,7 +1177,7 @@ pub fn getCompileDependencies(
1177	1177	start: Configuration.Step.Index,
1178	1178	chase_dynamic: bool,
1179	1179	) ![]const Configuration.Step.Index {
1180		var compiles: std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, void) = .empty;
	1180	var compiles: std.array_hash_map.Auto(Configuration.Step.Index, void) = .empty;
1181	1181	var compiles_i: usize = 0;
1182	1182
1183	1183	try compiles.putNoClobber(arena, start, {});

lib/compiler/Maker/Step/TranslateC.zig+1-1

...	...	@@ -66,7 +66,7 @@ pub fn make(
66	66
67	67	var prev_search_strategy: std.Build.Module.SystemLib.SearchStrategy = .paths_first;
68	68	var prev_preferred_link_mode: std.builtin.LinkMode = .dynamic;
69		var seen_system_libs: std.AutoArrayHashMapUnmanaged(Configuration.String, []const []const u8) = .empty;
	69	var seen_system_libs: std.array_hash_map.Auto(Configuration.String, []const []const u8) = .empty;
70	70
71	71	for (conf_tc.system_libs.slice) \|system_lib_index\| {
72	72	const system_lib = system_lib_index.get(conf);

lib/compiler/Maker/Watch.zig+6-6

...	...	@@ -27,11 +27,11 @@ pub const have_impl = Os != void;
27	27	/// interested in noticing changes to.
28	28	///
29	29	/// Value is generation.
30		const DirTable = std.ArrayHashMapUnmanaged(Cache.Path, void, Cache.Path.TableAdapter, false);
	30	const DirTable = std.array_hash_map.Custom(Cache.Path, void, Cache.Path.TableAdapter, false);
31	31
32	32	/// Special key of "." means any changes in this directory trigger the steps.
33		const ReactionSet = std.StringArrayHashMapUnmanaged(StepSet);
34		const StepSet = std.AutoArrayHashMapUnmanaged(Configuration.Step.Index, Generation);
	33	const ReactionSet = std.array_hash_map.String(StepSet);
	34	const StepSet = std.array_hash_map.Auto(Configuration.Step.Index, Generation);
35	35
36	36	const Generation = u8;
37	37
...	...	@@ -46,10 +46,10 @@ const Os = switch (builtin.os.tag) {
46	46	handle_table: HandleTable,
47	47	/// fanotify file descriptors are keyed by mount id since marks
48	48	/// are limited to a single filesystem.
49		poll_fds: std.AutoArrayHashMapUnmanaged(MountId, posix.pollfd),
	49	poll_fds: std.array_hash_map.Auto(MountId, posix.pollfd),
50	50
51	51	const MountId = i32;
52		const HandleTable = std.ArrayHashMapUnmanaged(FileHandle, struct { mount_id: MountId, reaction_set: ReactionSet }, FileHandle.Adapter, false);
	52	const HandleTable = std.array_hash_map.Custom(FileHandle, struct { mount_id: MountId, reaction_set: ReactionSet }, FileHandle.Adapter, false);
53	53
54	54	const fan_mask: std.os.linux.fanotify.MarkMask = .{
55	55	.CLOSE_WRITE = true,
...	...	@@ -314,7 +314,7 @@ const Os = switch (builtin.os.tag) {
314	314	const windows = std.os.windows;
315	315
316	316	/// Keyed differently but indexes correspond 1:1 with `dir_table`.
317		handle_table: std.ArrayHashMapUnmanaged(*Directory, void, Directory.TableAdapter, false),
	317	handle_table: std.array_hash_map.Custom(*Directory, void, Directory.TableAdapter, false),
318	318	ready_dirs: std.DoublyLinkedList,
319	319
320	320	const FileId = struct {

lib/compiler/aro/aro/Compilation.zig+2-2

...	...	@@ -140,7 +140,7 @@ io: Io,
140	140	cwd: std.Io.Dir,
141	141	diagnostics: *Diagnostics,
142	142
143		sources: std.StringArrayHashMapUnmanaged(Source) = .empty,
	143	sources: std.array_hash_map.String(Source) = .empty,
144	144	source_aliases: std.ArrayList(Source) = .empty,
145	145	/// Allocated into `gpa`, but keys are externally managed.
146	146	search_path: std.ArrayList(Include) = .empty,
...	...	@@ -159,7 +159,7 @@ builtins: Builtins = .{},
159	159	string_interner: StringInterner = .{},
160	160	interner: Interner = .{},
161	161	type_store: TypeStore = .{},
162		pragma_handlers: std.StringArrayHashMapUnmanaged(*Pragma) = .empty,
	162	pragma_handlers: std.array_hash_map.String(*Pragma) = .empty,
163	163	/// If this is not null, the directory containing the specified Source will be searched for includes
164	164	/// Used by MS extensions which allow searching for includes relative to the directory of the main source file.
165	165	ms_cwd_source_id: ?Source.Id = null,

lib/compiler/aro/aro/DepFile.zig+1-1

...	...	@@ -6,7 +6,7 @@ pub const Format = enum { make, nmake };
6	6	const DepFile = @This();
7	7
8	8	target: []const u8,
9		deps: std.StringArrayHashMapUnmanaged(void) = .empty,
	9	deps: std.array_hash_map.String(void) = .empty,
10	10	format: Format,
11	11
12	12	pub fn deinit(d: *DepFile, gpa: Allocator) void {

lib/compiler/aro/aro/Preprocessor.zig+1-1

...	...	@@ -23,7 +23,7 @@ const Tree = @import("Tree.zig");
23	23	const Token = Tree.Token;
24	24	const TokenWithExpansionLocs = Tree.TokenWithExpansionLocs;
25	25
26		const DefineMap = std.StringArrayHashMapUnmanaged(Macro);
	26	const DefineMap = std.array_hash_map.String(Macro);
27	27	const RawTokenList = std.ArrayList(RawToken);
28	28	const max_include_depth = 200;
29	29

lib/compiler/aro/aro/StringInterner.zig+1-1

...	...	@@ -19,7 +19,7 @@ pub const StringId = enum(u32) {
19	19	}
20	20	};
21	21
22		table: std.StringArrayHashMapUnmanaged(void) = .empty,
	22	table: std.array_hash_map.String(void) = .empty,
23	23
24	24	pub fn deinit(si: *StringInterner, allocator: mem.Allocator) void {
25	25	si.table.deinit(allocator);

lib/compiler/aro/backend/Interner.zig+1-1

...	...	@@ -8,7 +8,7 @@ const Limb = std.math.big.Limb;
8	8
9	9	const Interner = @This();
10	10
11		map: std.AutoArrayHashMapUnmanaged(void, void) = .empty,
	11	map: std.array_hash_map.Auto(void, void) = .empty,
12	12	items: std.MultiArrayList(struct {
13	13	tag: Tag,
14	14	data: u32,

lib/compiler/aro/backend/Ir.zig+4-4

...	...	@@ -7,7 +7,7 @@ const Object = @import("Object.zig");
7	7	const Ir = @This();
8	8
9	9	interner: *Interner,
10		decls: std.StringArrayHashMapUnmanaged(Decl),
	10	decls: std.array_hash_map.String(Decl),
11	11
12	12	pub const Decl = struct {
13	13	instructions: std.MultiArrayList(Inst),
...	...	@@ -26,7 +26,7 @@ pub const Builder = struct {
26	26	arena: std.heap.ArenaAllocator,
27	27	interner: *Interner,
28	28
29		decls: std.StringArrayHashMapUnmanaged(Decl) = .empty,
	29	decls: std.array_hash_map.String(Decl) = .empty,
30	30	instructions: std.MultiArrayList(Ir.Inst) = .empty,
31	31	body: std.ArrayList(Ref) = .empty,
32	32	alloc_count: u32 = 0,
...	...	@@ -181,7 +181,7 @@ pub const Renderer = struct {
181	181	ir: *const Ir,
182	182	errors: ErrorList = .{},
183	183
184		pub const ErrorList = std.StringArrayHashMapUnmanaged([]const u8);
	184	pub const ErrorList = std.array_hash_map.String([]const u8);
185	185
186	186	pub const Error = Allocator.Error \|\| error{LowerFail};
187	187
...	...	@@ -380,7 +380,7 @@ const REF = std.Io.Terminal.Color.bright_blue;
380	380	const LITERAL = std.Io.Terminal.Color.bright_green;
381	381	const ATTRIBUTE = std.Io.Terminal.Color.bright_yellow;
382	382
383		const RefMap = std.AutoArrayHashMapUnmanaged(Ref, void);
	383	const RefMap = std.array_hash_map.Auto(Ref, void);
384	384
385	385	pub const DumpError = std.Io.Terminal.SetColorError \|\| std.mem.Allocator.Error;
386	386

lib/compiler/configurer.zig+3-3

...	...	@@ -160,10 +160,10 @@ pub fn main(init: process.Init.Minimal) !void {
160	160	const Serialize = struct {
161	161	arena: Allocator,
162	162	wc: *Configuration.Wip,
163		module_map: std.AutoArrayHashMapUnmanaged(*std.Build.Module, Configuration.Module.Index) = .empty,
164		package_map: std.AutoArrayHashMapUnmanaged(*std.Build, Configuration.Package.Index) = .empty,
	163	module_map: std.array_hash_map.Auto(*std.Build.Module, Configuration.Module.Index) = .empty,
	164	package_map: std.array_hash_map.Auto(*std.Build, Configuration.Package.Index) = .empty,
165	165	/// Index corresponds to `Configuration.steps` index.
166		step_map: std.AutoArrayHashMapUnmanaged(*Step, void) = .empty,
	166	step_map: std.array_hash_map.Auto(*Step, void) = .empty,
167	167
168	168	fn builderToPackage(s: Serialize, b: std.Build) !Configuration.Package.Index {
169	169	if (b.pkg_hash.len == 0) return .root;

lib/compiler/reduce/Walk.zig+2-2

...	...	@@ -44,7 +44,7 @@ pub const Transformation = union(enum) {
44	44	imported_string: []const u8,
45	45	/// Identifier names that must be renamed in the inlined code or else
46	46	/// will cause ambiguous reference errors.
47		in_scope_names: std.StringArrayHashMapUnmanaged(void),
	47	in_scope_names: std.array_hash_map.String(void),
48	48	};
49	49	};
50	50
...	...	@@ -723,7 +723,7 @@ fn walkBuiltinCall(
723	723	try w.transformations.append(.{ .inline_imported_file = .{
724	724	.builtin_call_node = call_node,
725	725	.imported_string = imported_string,
726		.in_scope_names = try std.StringArrayHashMapUnmanaged(void).init(
	726	.in_scope_names = try std.array_hash_map.String(void).init(
727	727	w.arena,
728	728	w.in_scope_names.keys(),
729	729	&.{},

lib/compiler/resinator/cli.zig+1-1

...	...	@@ -159,7 +159,7 @@ pub const Options = struct {
159	159	default_language_id: ?u16 = null,
160	160	default_code_page: ?SupportedCodePage = null,
161	161	verbose: bool = false,
162		symbols: std.StringArrayHashMapUnmanaged(SymbolValue) = .empty,
	162	symbols: std.array_hash_map.String(SymbolValue) = .empty,
163	163	null_terminate_string_table_strings: bool = false,
164	164	max_string_literal_codepoints: u15 = lex.default_max_string_literal_codepoints,
165	165	silent_duplicate_control_ids: bool = false,

lib/compiler/resinator/compile.zig+2-2

...	...	@@ -3049,7 +3049,7 @@ pub const StringTablesByLanguage = struct {
3049	3049	/// when the first STRINGTABLE for the language was defined, and all blocks for a given
3050	3050	/// language are written contiguously.
3051	3051	/// Using an ArrayHashMap here gives us this property for free.
3052		tables: std.AutoArrayHashMapUnmanaged(res.Language, StringTable) = .empty,
	3052	tables: std.array_hash_map.Auto(res.Language, StringTable) = .empty,
3053	3053
3054	3054	pub fn deinit(self: *StringTablesByLanguage, allocator: Allocator) void {
3055	3055	self.tables.deinit(allocator);
...	...	@@ -3080,7 +3080,7 @@ pub const StringTable = struct {
3080	3080	/// was added to the block (i.e. `STRINGTABLE { 16 "b" 0 "a" }` would then get written
3081	3081	/// with block ID 2 (the one with "b") first and block ID 1 (the one with "a") second).
3082	3082	/// Using an ArrayHashMap here gives us this property for free.
3083		blocks: std.AutoArrayHashMapUnmanaged(u16, Block) = .empty,
	3083	blocks: std.array_hash_map.Auto(u16, Block) = .empty,
3084	3084
3085	3085	pub const Block = struct {
3086	3086	strings: std.ArrayList(Token) = .empty,

lib/compiler/resinator/cvtres.zig+5-5

...	...	@@ -439,9 +439,9 @@ pub const ResourceDataEntry = extern struct {
439	439
440	440	/// type -> name -> language
441	441	const ResourceTree = struct {
442		type_to_name_map: std.ArrayHashMapUnmanaged(NameOrOrdinal, NameToLanguageMap, NameOrOrdinalHashContext, true),
443		rsrc_string_table: std.ArrayHashMapUnmanaged(NameOrOrdinal, void, NameOrOrdinalHashContext, true),
444		deduplicated_data: std.StringArrayHashMapUnmanaged(u32),
	442	type_to_name_map: std.array_hash_map.Custom(NameOrOrdinal, NameToLanguageMap, NameOrOrdinalHashContext, true),
	443	rsrc_string_table: std.array_hash_map.Custom(NameOrOrdinal, void, NameOrOrdinalHashContext, true),
	444	deduplicated_data: std.array_hash_map.String(u32),
445	445	data_offsets: std.ArrayList(u32),
446	446	rsrc02_len: u32,
447	447	coff_options: CoffOptions,
...	...	@@ -451,8 +451,8 @@ const ResourceTree = struct {
451	451	resource: *const Resource,
452	452	original_index: usize,
453	453	};
454		const LanguageToResourceMap = std.AutoArrayHashMapUnmanaged(Language, RelocatableResource);
455		const NameToLanguageMap = std.ArrayHashMapUnmanaged(NameOrOrdinal, LanguageToResourceMap, NameOrOrdinalHashContext, true);
	454	const LanguageToResourceMap = std.array_hash_map.Auto(Language, RelocatableResource);
	455	const NameToLanguageMap = std.array_hash_map.Custom(NameOrOrdinal, LanguageToResourceMap, NameOrOrdinalHashContext, true);
456	456
457	457	const NameOrOrdinalHashContext = struct {
458	458	pub fn hash(self: @This(), v: NameOrOrdinal) u32 {

lib/compiler/translate-c/Scope.zig+5-5

...	...	@@ -7,7 +7,7 @@ const Translator = @import("Translator.zig");
7	7
8	8	const Scope = @This();
9	9
10		pub const SymbolTable = std.StringArrayHashMapUnmanaged(ast.Node);
	10	pub const SymbolTable = std.array_hash_map.String(ast.Node);
11	11	pub const AliasList = std.ArrayList(struct {
12	12	alias: []const u8,
13	13	name: []const u8,
...	...	@@ -18,7 +18,7 @@ pub const ContainerMemberFns = struct {
18	18	container_decl_ptr: *ast.Node,
19	19	member_fns: std.ArrayList(*ast.Payload.Func) = .empty,
20	20	};
21		pub const ContainerMemberFnsHashMap = std.ArrayHashMapUnmanaged(
	21	pub const ContainerMemberFnsHashMap = std.array_hash_map.Custom(
22	22	aro.QualType,
23	23	ContainerMemberFns,
24	24	struct {
...	...	@@ -79,7 +79,7 @@ pub const Block = struct {
79	79	/// will be used. This maps the variable's name to the Discard payload, so that if
80	80	/// the variable is subsequently referenced we can indicate that the discard should
81	81	/// be skipped during the intermediate AST -> Zig AST render step.
82		variable_discards: std.StringArrayHashMapUnmanaged(*ast.Payload.Discard),
	82	variable_discards: std.array_hash_map.String(*ast.Payload.Discard),
83	83
84	84	/// When the block corresponds to a function, keep track of the return type
85	85	/// so that the return expression can be cast, if necessary
...	...	@@ -209,7 +209,7 @@ pub const Root = struct {
209	209	base: Scope,
210	210	translator: *Translator,
211	211	sym_table: SymbolTable,
212		blank_macros: std.StringArrayHashMapUnmanaged(void),
	212	blank_macros: std.array_hash_map.String(void),
213	213	nodes: std.ArrayList(ast.Node),
214	214	container_member_fns_map: ContainerMemberFnsHashMap,
215	215
...	...	@@ -267,7 +267,7 @@ pub const Root = struct {
267	267	const gpa = root.translator.gpa;
268	268	const arena = root.translator.arena;
269	269
270		var member_names: std.StringArrayHashMapUnmanaged(void) = .empty;
	270	var member_names: std.array_hash_map.String(void) = .empty;
271	271	defer member_names.deinit(gpa);
272	272	for (root.container_member_fns_map.keys(), root.container_member_fns_map.values()) \|container_qt, members\| {
273	273	// Get the container name

lib/compiler/translate-c/Translator.zig+4-4

...	...	@@ -106,7 +106,7 @@ global_scope: *Scope.Root,
106	106	mangle_count: u32 = 0,
107	107
108	108	/// Table of declarations for enum, struct, union and typedef types.
109		type_decls: std.AutoArrayHashMapUnmanaged(Node.Index, []const u8) = .empty,
	109	type_decls: std.array_hash_map.Auto(Node.Index, []const u8) = .empty,
110	110	/// Table of record decls that have been demoted to opaques.
111	111	opaque_demotes: std.HashMapUnmanaged(QualType, void, QualTypeHashContext, std.hash_map.default_max_load_percentage) = .empty,
112	112	/// Table of unnamed enums and records that are child types of typedefs.
...	...	@@ -123,7 +123,7 @@ anonymous_record_field_names: std.HashMapUnmanaged(
123	123	/// a list of names that we found by visiting all the top level decls without
124	124	/// translating them. The other maps are updated as we translate; this one is updated
125	125	/// up front in a pre-processing step.
126		global_names: std.StringArrayHashMapUnmanaged(void) = .empty,
	126	global_names: std.array_hash_map.String(void) = .empty,
127	127
128	128	/// This is similar to `global_names`, but contains names which we would
129	129	/// like to use, but do not strictly have to if they are unavailable.
...	...	@@ -132,11 +132,11 @@ global_names: std.StringArrayHashMapUnmanaged(void) = .empty,
132	132	/// may be mangled.
133	133	/// This is distinct from `global_names` so we can detect at a type
134	134	/// declaration whether or not the name is available.
135		weak_global_names: std.StringArrayHashMapUnmanaged(void) = .empty,
	135	weak_global_names: std.array_hash_map.String(void) = .empty,
136	136
137	137	/// Set of identifiers known to refer to typedef declarations.
138	138	/// Used when parsing macros.
139		typedefs: std.StringArrayHashMapUnmanaged(void) = .empty,
	139	typedefs: std.array_hash_map.String(void) = .empty,
140	140
141	141	/// The lhs lval of a compound assignment expression.
142	142	compound_assign_dummy: ?ZigNode = null,

lib/docs/wasm/Walk.zig+9-9

...	...	@@ -10,9 +10,9 @@ const Oom = error{OutOfMemory};
10	10
11	11	pub const Decl = @import("Decl.zig");
12	12
13		pub var files: std.StringArrayHashMapUnmanaged(File) = .empty;
	13	pub var files: std.array_hash_map.String(File) = .empty;
14	14	pub var decls: std.ArrayList(Decl) = .empty;
15		pub var modules: std.StringArrayHashMapUnmanaged(File.Index) = .empty;
	15	pub var modules: std.array_hash_map.String(File.Index) = .empty;
16	16
17	17	file: File.Index,
18	18
...	...	@@ -42,17 +42,17 @@ pub const Category = union(enum(u8)) {
42	42	pub const File = struct {
43	43	ast: Ast,
44	44	/// Maps identifiers to the declarations they point to.
45		ident_decls: std.AutoArrayHashMapUnmanaged(Ast.TokenIndex, Ast.Node.Index) = .empty,
	45	ident_decls: std.array_hash_map.Auto(Ast.TokenIndex, Ast.Node.Index) = .empty,
46	46	/// Maps field access identifiers to the containing field access node.
47		token_parents: std.AutoArrayHashMapUnmanaged(Ast.TokenIndex, Ast.Node.Index) = .empty,
	47	token_parents: std.array_hash_map.Auto(Ast.TokenIndex, Ast.Node.Index) = .empty,
48	48	/// Maps declarations to their global index.
49		node_decls: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, Decl.Index) = .empty,
	49	node_decls: std.array_hash_map.Auto(Ast.Node.Index, Decl.Index) = .empty,
50	50	/// Maps function declarations to doctests.
51		doctests: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, Ast.Node.Index) = .empty,
	51	doctests: std.array_hash_map.Auto(Ast.Node.Index, Ast.Node.Index) = .empty,
52	52	/// root node => its namespace scope
53	53	/// struct/union/enum/opaque decl node => its namespace scope
54	54	/// local var decl node => its local variable scope
55		scopes: std.AutoArrayHashMapUnmanaged(Ast.Node.Index, *Scope) = .empty,
	55	scopes: std.array_hash_map.Auto(Ast.Node.Index, *Scope) = .empty,
56	56
57	57	pub fn lookup_token(file: *File, token: Ast.TokenIndex) Decl.Index {
58	58	const decl_node = file.ident_decls.get(token) orelse return .none;
...	...	@@ -465,8 +465,8 @@ pub const Scope = struct {
465	465	const Namespace = struct {
466	466	base: Scope = .{ .tag = .namespace },
467	467	parent: *Scope,
468		names: std.StringArrayHashMapUnmanaged(Ast.Node.Index) = .empty,
469		doctests: std.StringArrayHashMapUnmanaged(Ast.Node.Index) = .empty,
	468	names: std.array_hash_map.String(Ast.Node.Index) = .empty,
	469	doctests: std.array_hash_map.String(Ast.Node.Index) = .empty,
470	470	decl_index: Decl.Index,
471	471	};
472	472

lib/docs/wasm/main.zig+4-4

...	...	@@ -264,7 +264,7 @@ const ErrorIdentifier = packed struct(u64) {
264	264	};
265	265
266	266	var string_result: ArrayList(u8) = .empty;
267		var error_set_result: std.StringArrayHashMapUnmanaged(ErrorIdentifier) = .empty;
	267	var error_set_result: std.array_hash_map.String(ErrorIdentifier) = .empty;
268	268
269	269	export fn decl_error_set(decl_index: Decl.Index) Slice(ErrorIdentifier) {
270	270	return Slice(ErrorIdentifier).init(decl_error_set_fallible(decl_index) catch @panic("OOM"));
...	...	@@ -305,7 +305,7 @@ fn sort_error_set_result() void {
305	305
306	306	fn addErrorsFromDecl(
307	307	decl_index: Decl.Index,
308		out: *std.StringArrayHashMapUnmanaged(ErrorIdentifier),
	308	out: *std.array_hash_map.String(ErrorIdentifier),
309	309	) Oom!void {
310	310	switch (decl_index.get().categorize()) {
311	311	.error_set => \|node\| try addErrorsFromExpr(decl_index, out, node),
...	...	@@ -316,7 +316,7 @@ fn addErrorsFromDecl(
316	316
317	317	fn addErrorsFromExpr(
318	318	decl_index: Decl.Index,
319		out: *std.StringArrayHashMapUnmanaged(ErrorIdentifier),
	319	out: *std.array_hash_map.String(ErrorIdentifier),
320	320	node: Ast.Node.Index,
321	321	) Oom!void {
322	322	const decl = decl_index.get();
...	...	@@ -343,7 +343,7 @@ fn addErrorsFromExpr(
343	343
344	344	fn addErrorsFromNode(
345	345	decl_index: Decl.Index,
346		out: *std.StringArrayHashMapUnmanaged(ErrorIdentifier),
	346	out: *std.array_hash_map.String(ErrorIdentifier),
347	347	node: Ast.Node.Index,
348	348	) Oom!void {
349	349	const decl = decl_index.get();

lib/fuzzer.zig+3-3

...	...	@@ -340,7 +340,7 @@ const Fuzzer = struct {
340	340	quality_buf: []Input.Best,
341	341	input_buf: []Input.Best.Map,
342	342	},
343		seen_uids: std.ArrayHashMapUnmanaged(Uid, struct {
	343	seen_uids: std.array_hash_map.Custom(Uid, struct {
344	344	slices: union {
345	345	ints: std.ArrayList([]u64),
346	346	bytes: std.ArrayList(Input.Data.Bytes),
...	...	@@ -505,7 +505,7 @@ const Fuzzer = struct {
505	505	}
506	506	};
507	507
508		pub const UidSlices = std.ArrayHashMapUnmanaged(Uid, struct {
	508	pub const UidSlices = std.array_hash_map.Custom(Uid, struct {
509	509	base: u32,
510	510	len: u32,
511	511	}, Uid.hashmap_ctx, false);
...	...	@@ -584,7 +584,7 @@ const Fuzzer = struct {
584	584	};
585	585
586	586	pub const Builder = struct {
587		uid_slices: std.ArrayHashMapUnmanaged(Uid, union {
	587	uid_slices: std.array_hash_map.Custom(Uid, union {
588	588	ints: std.MultiArrayList(struct {
589	589	value: u64,
590	590	order_i: u32,

lib/std/Build.zig+3-3

...	...	@@ -33,7 +33,7 @@ user_input_options: UserInputOptionsMap,
33	33	available_options_map: std.array_hash_map.String(AvailableOption) = .empty,
34	34	invalid_user_input: bool,
35	35	default_step: *Step,
36		top_level_steps: std.StringArrayHashMapUnmanaged(*Step.TopLevel),
	36	top_level_steps: std.array_hash_map.String(*Step.TopLevel),
37	37	/// Path to the directory containing build.zig.
38	38	root: Cache.Path,
39	39	debug_log_scopes: []const []const u8 = &.{},
...	...	@@ -78,11 +78,11 @@ pub const Graph = struct {
78	78	io: Io,
79	79	/// Process lifetime.
80	80	arena: Allocator,
81		system_integration_options: std.StringArrayHashMapUnmanaged(SystemLibraryMode) = .empty,
	81	system_integration_options: std.array_hash_map.String(SystemLibraryMode) = .empty,
82	82	system_package_mode: bool = false,
83	83	zig_exe: []const u8,
84	84	environ_map: process.Environ.Map,
85		needed_lazy_dependencies: std.StringArrayHashMapUnmanaged(void) = .empty,
	85	needed_lazy_dependencies: std.array_hash_map.String(void) = .empty,
86	86	/// Information about the native target. Computed before build() is invoked.
87	87	host: ResolvedTarget,
88	88	dependency_cache: InitializedDepMap = .empty,

lib/std/Build/Cache.zig+1-1

...	...	@@ -351,7 +351,7 @@ pub const Manifest = struct {
351	351	};
352	352	};
353	353
354		pub const Files = std.ArrayHashMapUnmanaged(File, void, FilesContext, false);
	354	pub const Files = std.array_hash_map.Custom(File, void, FilesContext, false);
355	355
356	356	pub const FilesContext = struct {
357	357	pub fn hash(fc: FilesContext, file: File) u32 {

lib/std/Build/Module.zig+3-3

...	...	@@ -12,7 +12,7 @@ root_source_file: ?LazyPath,
12	12	/// The modules that are mapped into this module's import table.
13	13	/// Use `addImport` rather than modifying this field directly in order to
14	14	/// maintain step dependency edges.
15		import_table: std.StringArrayHashMapUnmanaged(*Module),
	15	import_table: std.array_hash_map.String(*Module),
16	16
17	17	resolved_target: ?std.Build.ResolvedTarget = null,
18	18	optimize: ?std.builtin.OptimizeMode = null,
...	...	@@ -22,7 +22,7 @@ c_macros: ArrayList([]const u8),
22	22	include_dirs: ArrayList(IncludeDir),
23	23	lib_paths: ArrayList(LazyPath),
24	24	rpaths: ArrayList(RPath),
25		frameworks: std.StringArrayHashMapUnmanaged(LinkFrameworkOptions),
	25	frameworks: std.array_hash_map.String(LinkFrameworkOptions),
26	26	link_objects: ArrayList(LinkObject),
27	27
28	28	strip: ?bool,
...	...	@@ -563,7 +563,7 @@ pub fn getGraph(root: *Module) Graph {
563	563
564	564	const arena = root.owner.graph.arena;
565	565
566		var modules: std.AutoArrayHashMapUnmanaged(*std.Build.Module, []const u8) = .empty;
	566	var modules: std.array_hash_map.Auto(*std.Build.Module, []const u8) = .empty;
567	567	var next_idx: usize = 0;
568	568
569	569	modules.putNoClobber(arena, root, "root") catch @panic("OOM");

lib/std/Build/Step/Compile.zig+2-2

...	...	@@ -187,7 +187,7 @@ entry: Entry = .default,
187	187	/// List of symbols forced as undefined in the symbol table
188	188	/// thus forcing their resolution by the linker.
189	189	/// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.
190		force_undefined_symbols: std.StringArrayHashMapUnmanaged(void),
	190	force_undefined_symbols: std.array_hash_map.String(void),
191	191
192	192	/// Overrides the default stack size
193	193	stack_size: ?u64 = null,
...	...	@@ -759,7 +759,7 @@ pub fn rootModuleTarget(c: *Compile) std.Target {
759	759	pub fn getCompileDependencies(start: Compile, chase_dynamic: bool) []const Compile {
760	760	const arena = start.step.owner.graph.arena;
761	761
762		var compiles: std.AutoArrayHashMapUnmanaged(*Compile, void) = .empty;
	762	var compiles: std.array_hash_map.Auto(*Compile, void) = .empty;
763	763	var next_idx: usize = 0;
764	764
765	765	compiles.putNoClobber(arena, start, {}) catch @panic("OOM");

lib/std/Io/Kqueue.zig+1-1

...	...	@@ -40,7 +40,7 @@ const Thread = struct {
40	40	steal_ready_search_index: u32,
41	41	/// For ensuring multiple fibers waiting on the same file descriptor and
42	42	/// filter use the same kevent.
43		wait_queues: std.AutoArrayHashMapUnmanaged(WaitQueueKey, *Fiber),
	43	wait_queues: std.array_hash_map.Auto(WaitQueueKey, *Fiber),
44	44
45	45	const WaitQueueKey = struct {
46	46	ident: usize,

lib/std/debug/Coverage.zig+2-2

...	...	@@ -15,13 +15,13 @@ const assert = std.debug.assert;
15	15	/// String memory references the memory-mapped debug information.
16	16	///
17	17	/// Protected by `mutex`.
18		directories: std.ArrayHashMapUnmanaged(String, void, String.MapContext, false),
	18	directories: std.array_hash_map.Custom(String, void, String.MapContext, false),
19	19	/// Provides a globally-scoped integer index for files.
20	20	///
21	21	/// String memory references the memory-mapped debug information.
22	22	///
23	23	/// Protected by `mutex`.
24		files: std.ArrayHashMapUnmanaged(File, void, File.MapContext, false),
	24	files: std.array_hash_map.Custom(File, void, File.MapContext, false),
25	25	string_bytes: std.ArrayList(u8),
26	26	/// Protects the other fields.
27	27	mutex: Io.Mutex,

lib/std/debug/Dwarf.zig+1-1

...	...	@@ -134,7 +134,7 @@ pub const CompileUnit = struct {
134	134	files: []FileEntry,
135	135	version: u16,
136	136
137		pub const LineTable = std.AutoArrayHashMapUnmanaged(u64, LineEntry);
	137	pub const LineTable = std.array_hash_map.Auto(u64, LineEntry);
138	138
139	139	pub const LineEntry = struct {
140	140	line: u32,

lib/std/debug/MachOFile.zig+5-5

...	...	@@ -4,7 +4,7 @@ strings: []const u8,
4	4	text_vmaddr: u64,
5	5
6	6	/// Key is index into `strings` of the file path.
7		ofiles: std.AutoArrayHashMapUnmanaged(u32, Error!OFile),
	7	ofiles: std.array_hash_map.Auto(u32, Error!OFile),
8	8
9	9	pub const Error = error{
10	10	InvalidMachO,
...	...	@@ -115,7 +115,7 @@ pub fn load(gpa: Allocator, io: Io, path: []const u8, arch: std.Target.Cpu.Arch)
115	115	// necessary because we prefer to use STAB ("symbolic debugging table") symbols,
116	116	// but they might not be present, so we track normal symbols too.
117	117	// Indices match 1-1 with those of `symbols`.
118		var symbol_names: std.StringArrayHashMapUnmanaged(void) = .empty;
	118	var symbol_names: std.array_hash_map.String(void) = .empty;
119	119	defer symbol_names.deinit(gpa);
120	120	try symbol_names.ensureUnusedCapacity(gpa, symtab.nsyms);
121	121
...	...	@@ -305,7 +305,7 @@ const OFile = struct {
305	305	symtab_raw: []align(1) const macho.nlist_64,
306	306	/// All named symbols in `symtab_raw`. Stored `u32` key is the index into `symtab_raw`. Accessed
307	307	/// through `SymbolAdapter`, so that the symbol name is used as the logical key.
308		symbols_by_name: std.ArrayHashMapUnmanaged(u32, void, void, true),
	308	symbols_by_name: std.array_hash_map.Custom(u32, void, void, true),
309	309
310	310	const SymbolAdapter = struct {
311	311	strtab: []const u8,
...	...	@@ -380,7 +380,7 @@ test {
380	380
381	381	fn appendStabSymbol(
382	382	symbols: *std.ArrayList(Symbol),
383		symbol_names: *std.StringArrayHashMapUnmanaged(void),
	383	symbol_names: *std.array_hash_map.String(void),
384	384	strings: []const u8,
385	385	last_sym: Symbol,
386	386	) void {
...	...	@@ -476,7 +476,7 @@ fn loadOFile(gpa: Allocator, io: Io, o_file_name: []const u8) !OFile {
476	476	const symtab_raw: []align(1) const macho.nlist_64 = @ptrCast(mapped_ofile[symtab_cmd.symoff..][0..n_sym_bytes]);
477	477
478	478	// TODO handle tentative (common) symbols
479		var symbols_by_name: std.ArrayHashMapUnmanaged(u32, void, void, true) = .empty;
	479	var symbols_by_name: std.array_hash_map.Custom(u32, void, void, true) = .empty;
480	480	defer symbols_by_name.deinit(gpa);
481	481	try symbols_by_name.ensureUnusedCapacity(gpa, @intCast(symtab_raw.len));
482	482	for (symtab_raw, 0..) \|sym_raw, sym_index\| {

lib/std/debug/SelfInfo/MachO.zig+1-1

...	...	@@ -1,6 +1,6 @@
1	1	mutex: Io.Mutex,
2	2	/// Accessed through `Module.Adapter`.
3		modules: std.ArrayHashMapUnmanaged(Module, void, Module.Context, false),
	3	modules: std.array_hash_map.Custom(Module, void, Module.Context, false),
4	4
5	5	pub const init: SelfInfo = .{
6	6	.mutex = .init,

lib/std/json/hashmap.zig+4-4

...	...	@@ -6,20 +6,20 @@ const innerParse = @import("static.zig").innerParse;
6	6	const innerParseFromValue = @import("static.zig").innerParseFromValue;
7	7	const Value = @import("dynamic.zig").Value;
8	8
9		/// A thin wrapper around `std.StringArrayHashMapUnmanaged` that implements
	9	/// A thin wrapper around `std.array_hash_map.String` that implements
10	10	/// `jsonParse`, `jsonParseFromValue`, and `jsonStringify`.
11	11	/// This is useful when your JSON schema has an object with arbitrary data keys
12	12	/// instead of comptime-known struct field names.
13	13	pub fn ArrayHashMap(comptime T: type) type {
14	14	return struct {
15		map: std.StringArrayHashMapUnmanaged(T) = .empty,
	15	map: std.array_hash_map.String(T) = .empty,
16	16
17	17	pub fn deinit(self: *@This(), allocator: Allocator) void {
18	18	self.map.deinit(allocator);
19	19	}
20	20
21	21	pub fn jsonParse(allocator: Allocator, source: anytype, options: ParseOptions) !@This() {
22		var map: std.StringArrayHashMapUnmanaged(T) = .empty;
	22	var map: std.array_hash_map.String(T) = .empty;
23	23	errdefer map.deinit(allocator);
24	24
25	25	if (.object_begin != try source.next()) return error.UnexpectedToken;
...	...	@@ -52,7 +52,7 @@ pub fn ArrayHashMap(comptime T: type) type {
52	52	pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !@This() {
53	53	if (source != .object) return error.UnexpectedToken;
54	54
55		var map: std.StringArrayHashMapUnmanaged(T) = .empty;
	55	var map: std.array_hash_map.String(T) = .empty;
56	56	errdefer map.deinit(allocator);
57	57
58	58	var it = source.object.iterator();

lib/std/process/Environ.zig+1-1

...	...	@@ -101,7 +101,7 @@ pub const Map = struct {
101	101	array_hash_map: ArrayHashMap,
102	102	allocator: Allocator,
103	103
104		const ArrayHashMap = std.ArrayHashMapUnmanaged([]const u8, []const u8, EnvNameHashContext, false);
	104	const ArrayHashMap = std.array_hash_map.Custom([]const u8, []const u8, EnvNameHashContext, false);
105	105
106	106	pub const Size = usize;
107	107

lib/std/process/Preopens.zig+1-1

...	...	@@ -16,7 +16,7 @@ pub const empty: Preopens = switch (native_os) {
16	16
17	17	pub const Map = switch (native_os) {
18	18	// Indexed by file descriptor number.
19		.wasi => std.StringArrayHashMapUnmanaged(void),
	19	.wasi => std.array_hash_map.String(void),
20	20	else => void,
21	21	};
22	22

lib/std/zig/Ast/Render.zig+1-1

...	...	@@ -42,7 +42,7 @@ pub const Fixups = struct {
42	42	/// These nodes will be replaced with a different node.
43	43	replace_nodes_with_node: std.AutoHashMapUnmanaged(Ast.Node.Index, Ast.Node.Index) = .empty,
44	44	/// Change all identifier names matching the key to be value instead.
45		rename_identifiers: std.StringArrayHashMapUnmanaged([]const u8) = .empty,
	45	rename_identifiers: std.array_hash_map.String([]const u8) = .empty,
46	46
47	47	/// All `@import` builtin calls which refer to a file path will be prefixed
48	48	/// with this path.

lib/std/zig/AstGen.zig+5-5

...	...	@@ -52,7 +52,7 @@ within_fn: bool = false,
52	52	fn_ret_ty: Zir.Inst.Ref = .none,
53	53	/// Maps string table indexes to the first `@import` ZIR instruction
54	54	/// that uses this string as the operand.
55		imports: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, Ast.TokenIndex) = .empty,
	55	imports: std.array_hash_map.Auto(Zir.NullTerminatedString, Ast.TokenIndex) = .empty,
56	56	/// Used for temporary storage when building payloads.
57	57	scratch: std.ArrayList(u32) = .empty,
58	58	/// Whenever a `ref` instruction is needed, it is created and saved in this
...	...	@@ -11163,7 +11163,7 @@ const Scope = struct {
11163	11163	declaring_gz: ?*GenZir,
11164	11164
11165	11165	/// Set of captures used by this namespace.
11166		captures: std.AutoArrayHashMapUnmanaged(Zir.Inst.Capture, Zir.NullTerminatedString) = .empty,
	11166	captures: std.array_hash_map.Auto(Zir.Inst.Capture, Zir.NullTerminatedString) = .empty,
11167	11167
11168	11168	fn deinit(self: *Namespace, gpa: Allocator) void {
11169	11169	self.decls.deinit(gpa);
...	...	@@ -12856,9 +12856,9 @@ fn scanContainer(
12856	12856	var bfa_state: std.heap.BufferFirstAllocator = .init(&bfa_buf, astgen.gpa);
12857	12857	const bfa = bfa_state.allocator();
12858	12858
12859		var names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
12860		var test_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
12861		var decltest_names: std.AutoArrayHashMapUnmanaged(Zir.NullTerminatedString, NameEntry) = .empty;
	12859	var names: std.array_hash_map.Auto(Zir.NullTerminatedString, NameEntry) = .empty;
	12860	var test_names: std.array_hash_map.Auto(Zir.NullTerminatedString, NameEntry) = .empty;
	12861	var decltest_names: std.array_hash_map.Auto(Zir.NullTerminatedString, NameEntry) = .empty;
12862	12862	defer {
12863	12863	names.deinit(bfa);
12864	12864	test_names.deinit(bfa);

lib/std/zig/llvm/Builder.zig+21-21

...	...	@@ -21,25 +21,25 @@ data_layout: String,
21	21	target_triple: String,
22	22	module_asm: std.ArrayList(u8),
23	23
24		string_map: std.AutoArrayHashMapUnmanaged(void, void),
	24	string_map: std.array_hash_map.Auto(void, void),
25	25	string_indices: std.ArrayList(u32),
26	26	string_bytes: std.ArrayList(u8),
27	27
28		types: std.AutoArrayHashMapUnmanaged(String, Type),
	28	types: std.array_hash_map.Auto(String, Type),
29	29	next_unnamed_type: String,
30	30	next_unique_type_id: std.AutoHashMapUnmanaged(String, u32),
31		type_map: std.AutoArrayHashMapUnmanaged(void, void),
	31	type_map: std.array_hash_map.Auto(void, void),
32	32	type_items: std.ArrayList(Type.Item),
33	33	type_extra: std.ArrayList(u32),
34	34
35		attributes: std.AutoArrayHashMapUnmanaged(Attribute.Storage, void),
36		attributes_map: std.AutoArrayHashMapUnmanaged(void, void),
	35	attributes: std.array_hash_map.Auto(Attribute.Storage, void),
	36	attributes_map: std.array_hash_map.Auto(void, void),
37	37	attributes_indices: std.ArrayList(u32),
38	38	attributes_extra: std.ArrayList(u32),
39	39
40		function_attributes_set: std.AutoArrayHashMapUnmanaged(FunctionAttributes, void),
	40	function_attributes_set: std.array_hash_map.Auto(FunctionAttributes, void),
41	41
42		globals: std.AutoArrayHashMapUnmanaged(StrtabString, Global),
	42	globals: std.array_hash_map.Auto(StrtabString, Global),
43	43	next_unnamed_global: StrtabString,
44	44	next_replaced_global: StrtabString,
45	45	next_unique_global_id: std.AutoHashMapUnmanaged(StrtabString, u32),
...	...	@@ -47,28 +47,28 @@ aliases: std.ArrayList(Alias),
47	47	variables: std.ArrayList(Variable),
48	48	functions: std.ArrayList(Function),
49	49
50		strtab_string_map: std.AutoArrayHashMapUnmanaged(void, void),
	50	strtab_string_map: std.array_hash_map.Auto(void, void),
51	51	strtab_string_indices: std.ArrayList(u32),
52	52	strtab_string_bytes: std.ArrayList(u8),
53	53
54		constant_map: std.AutoArrayHashMapUnmanaged(void, void),
	54	constant_map: std.array_hash_map.Auto(void, void),
55	55	constant_items: std.MultiArrayList(Constant.Item),
56	56	constant_extra: std.ArrayList(u32),
57	57	constant_limbs: std.ArrayList(std.math.big.Limb),
58	58
59	59	alignment_forward_references: std.ArrayList(Alignment),
60	60
61		metadata_map: std.AutoArrayHashMapUnmanaged(void, void),
	61	metadata_map: std.array_hash_map.Auto(void, void),
62	62	metadata_items: std.MultiArrayList(Metadata.Item),
63	63	metadata_extra: std.ArrayList(u32),
64	64	metadata_limbs: std.ArrayList(std.math.big.Limb),
65	65	metadata_forward_references: std.ArrayList(Metadata.Optional),
66		metadata_named: std.AutoArrayHashMapUnmanaged(String, struct {
	66	metadata_named: std.array_hash_map.Auto(String, struct {
67	67	len: u32,
68	68	index: Metadata.Item.ExtraIndex,
69	69	}),
70	70
71		metadata_string_map: std.AutoArrayHashMapUnmanaged(void, void),
	71	metadata_string_map: std.array_hash_map.Auto(void, void),
72	72	metadata_string_indices: std.ArrayList(u32),
73	73	metadata_string_bytes: std.ArrayList(u8),
74	74
...	...	@@ -1633,7 +1633,7 @@ pub const FunctionAttributes = enum(u32) {
1633	1633	pub const Wip = struct {
1634	1634	maps: Maps = .empty,
1635	1635
1636		const Map = std.AutoArrayHashMapUnmanaged(Attribute.Kind, Attribute.Index);
	1636	const Map = std.array_hash_map.Auto(Attribute.Kind, Attribute.Index);
1637	1637	const Maps = std.ArrayList(Map);
1638	1638
1639	1639	pub fn deinit(self: Wip, builder: const Builder) void {
...	...	@@ -5235,8 +5235,8 @@ pub const WipFunction = struct {
5235	5235	instructions: std.MultiArrayList(Instruction),
5236	5236	names: std.ArrayList(String),
5237	5237	strip: bool,
5238		debug_locations: std.AutoArrayHashMapUnmanaged(Instruction.Index, DebugLocation),
5239		debug_values: std.AutoArrayHashMapUnmanaged(Instruction.Index, void),
	5238	debug_locations: std.array_hash_map.Auto(Instruction.Index, DebugLocation),
	5239	debug_values: std.array_hash_map.Auto(Instruction.Index, void),
5240	5240	extra: std.ArrayList(u32),
5241	5241
5242	5242	pub const Cursor = struct { block: Block.Index, instruction: u32 = 0 };
...	...	@@ -8451,7 +8451,7 @@ pub const Metadata = packed struct(u32) {
8451	8451	const Formatter = struct {
8452	8452	builder: *Builder,
8453	8453	need_comma: bool,
8454		map: std.AutoArrayHashMapUnmanaged(union(enum) {
	8454	map: std.array_hash_map.Auto(union(enum) {
8455	8455	metadata: Metadata,
8456	8456	debug_location: DebugLocation.Location,
8457	8457	}, void) = .empty,
...	...	@@ -9791,7 +9791,7 @@ pub fn print(self: Builder, w: Writer) (Writer.Error \|\| Allocator.Error)!void
9791	9791	}
9792	9792	}
9793	9793
9794		var attribute_groups: std.AutoArrayHashMapUnmanaged(Attributes, void) = .empty;
	9794	var attribute_groups: std.array_hash_map.Auto(Attributes, void) = .empty;
9795	9795	defer attribute_groups.deinit(self.gpa);
9796	9796
9797	9797	for (0.., self.functions.items) \|function_i, function\| {
...	...	@@ -13507,7 +13507,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
13507	13507	try type_block.end();
13508	13508	}
13509	13509
13510		var attributes_set: std.AutoArrayHashMapUnmanaged(struct {
	13510	var attributes_set: std.array_hash_map.Auto(struct {
13511	13511	attributes: Attributes,
13512	13512	index: u32,
13513	13513	}, void) = .{};
...	...	@@ -13743,7 +13743,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
13743	13743	try paramattr_block.end();
13744	13744	}
13745	13745
13746		var globals: std.AutoArrayHashMapUnmanaged(Global.Index, void) = .empty;
	13746	var globals: std.array_hash_map.Auto(Global.Index, void) = .empty;
13747	13747	defer globals.deinit(self.gpa);
13748	13748	try globals.ensureUnusedCapacity(
13749	13749	self.gpa,
...	...	@@ -13784,7 +13784,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
13784	13784
13785	13785	const ConstantAdapter = struct {
13786	13786	builder: *const Builder,
13787		globals: *const std.AutoArrayHashMapUnmanaged(Global.Index, void),
	13787	globals: *const std.array_hash_map.Auto(Global.Index, void),
13788	13788
13789	13789	pub fn get(adapter: @This(), param: anytype) switch (@TypeOf(param)) {
13790	13790	Constant => u32,
...	...	@@ -13815,7 +13815,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
13815	13815
13816	13816	// Globals
13817	13817	{
13818		var section_map: std.AutoArrayHashMapUnmanaged(String, void) = .empty;
	13818	var section_map: std.array_hash_map.Auto(String, void) = .empty;
13819	13819	defer section_map.deinit(self.gpa);
13820	13820	try section_map.ensureUnusedCapacity(self.gpa, globals.count());
13821	13821

src/Compilation.zig+19-19

...	...	@@ -87,7 +87,7 @@ link_inputs: []const link.Input,
87	87	framework_dirs: []const []const u8,
88	88	/// These are only for DLLs dependencies fulfilled by the `.def` files shipped
89	89	/// with Zig. Static libraries are provided as `link.Input` values.
90		windows_libs: std.StringArrayHashMapUnmanaged(void),
	90	windows_libs: std.array_hash_map.String(void),
91	91	/// The number of items in `windows_libs` which we have already built. All items at or after this
92	92	/// index will be built in `performAllTheWork`.
93	93	windows_libs_num_done: u32,
...	...	@@ -101,10 +101,10 @@ native_system_include_paths: []const []const u8,
101	101	/// List of symbols forced as undefined in the symbol table
102	102	/// thus forcing their resolution by the linker.
103	103	/// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.
104		force_undefined_symbols: std.StringArrayHashMapUnmanaged(void),
	104	force_undefined_symbols: std.array_hash_map.String(void),
105	105
106		c_object_table: std.AutoArrayHashMapUnmanaged(*CObject, void) = .empty,
107		win32_resource_table: if (dev.env.supports(.win32_resource)) std.AutoArrayHashMapUnmanaged(*Win32Resource, void) else struct {
	106	c_object_table: std.array_hash_map.Auto(*CObject, void) = .empty,
	107	win32_resource_table: if (dev.env.supports(.win32_resource)) std.array_hash_map.Auto(*Win32Resource, void) else struct {
108	108	pub fn keys(_: @This()) [0]void {
109	109	return .{};
110	110	}
...	...	@@ -145,11 +145,11 @@ win32_resource_work_queue: if (dev.env.supports(.win32_resource)) std.Deque(*Win
145	145
146	146	/// The ErrorMsg memory is owned by the `CObject`, using Compilation's general purpose allocator.
147	147	/// This data is accessed by multiple threads and is protected by `mutex`.
148		failed_c_objects: std.AutoArrayHashMapUnmanaged(CObject, CObject.Diag.Bundle) = .empty,
	148	failed_c_objects: std.array_hash_map.Auto(CObject, CObject.Diag.Bundle) = .empty,
149	149
150	150	/// The ErrorBundle memory is owned by the `Win32Resource`, using Compilation's general purpose allocator.
151	151	/// This data is accessed by multiple threads and is protected by `mutex`.
152		failed_win32_resources: if (dev.env.supports(.win32_resource)) std.AutoArrayHashMapUnmanaged(*Win32Resource, ErrorBundle) else struct {
	152	failed_win32_resources: if (dev.env.supports(.win32_resource)) std.array_hash_map.Auto(*Win32Resource, ErrorBundle) else struct {
153	153	pub fn values(_: @This()) [0]void {
154	154	return .{};
155	155	}
...	...	@@ -157,7 +157,7 @@ failed_win32_resources: if (dev.env.supports(.win32_resource)) std.AutoArrayHash
157	157	} = .{},
158	158
159	159	/// Miscellaneous things that can fail.
160		misc_failures: std.AutoArrayHashMapUnmanaged(MiscTask, MiscError) = .empty,
	160	misc_failures: std.array_hash_map.Auto(MiscTask, MiscError) = .empty,
161	161
162	162	/// When this is `true` it means invoking clang as a sub-process is expected to inherit
163	163	/// stdin, stdout, stderr, and if it returns non success, to forward the exit code.
...	...	@@ -865,7 +865,7 @@ pub const TimeReport = struct {
865	865	/// a function) all generic instances of this function. It also includes time spent analyzing
866	866	/// function bodies if this is a function (generic or otherwise).
867	867	/// An entry not existing means the declaration has not been analyzed (so far).
868		decl_sema_info: std.AutoArrayHashMapUnmanaged(InternPool.TrackedInst.Index, struct {
	868	decl_sema_info: std.array_hash_map.Auto(InternPool.TrackedInst.Index, struct {
869	869	ns: u64,
870	870	count: u32,
871	871	}),
...	...	@@ -875,14 +875,14 @@ pub const TimeReport = struct {
875	875	/// instances, both of this function itself and of its parent namespace.
876	876	/// An entry not existing means the declaration has not been codegenned (so far).
877	877	/// Every key in `decl_codegen_ns` is also in `decl_sema_ns`.
878		decl_codegen_ns: std.AutoArrayHashMapUnmanaged(InternPool.TrackedInst.Index, u64),
	878	decl_codegen_ns: std.array_hash_map.Auto(InternPool.TrackedInst.Index, u64),
879	879
880	880	/// Key is a ZIR `declaration` instruction which is anything other than a `comptime` decl; value
881	881	/// is the number of nanoseconds spent linking it into the binary. As above, this is the total
882	882	/// across all generic instances.
883	883	/// An entry not existing means the declaration has not been linked (so far).
884	884	/// Every key in `decl_link_ns` is also in `decl_sema_ns`.
885		decl_link_ns: std.AutoArrayHashMapUnmanaged(InternPool.TrackedInst.Index, u64),
	885	decl_link_ns: std.array_hash_map.Auto(InternPool.TrackedInst.Index, u64),
886	886
887	887	pub fn deinit(tr: *TimeReport, gpa: Allocator) void {
888	888	tr.stats = undefined;
...	...	@@ -1068,8 +1068,8 @@ pub const CObject = struct {
1068	1068	}
1069	1069
1070	1070	pub const Bundle = struct {
1071		file_names: std.AutoArrayHashMapUnmanaged(u32, []const u8) = .empty,
1072		category_names: std.AutoArrayHashMapUnmanaged(u32, []const u8) = .empty,
	1071	file_names: std.array_hash_map.Auto(u32, []const u8) = .empty,
	1072	category_names: std.array_hash_map.Auto(u32, []const u8) = .empty,
1073	1073	diags: []Diag = &.{},
1074	1074
1075	1075	pub fn destroy(bundle: *Bundle, gpa: Allocator) void {
...	...	@@ -1122,13 +1122,13 @@ pub const CObject = struct {
1122	1122	var bc = std.zig.llvm.BitcodeReader.init(gpa, .{ .reader = &file_reader.interface });
1123	1123	defer bc.deinit();
1124	1124
1125		var file_names: std.AutoArrayHashMapUnmanaged(u32, []const u8) = .empty;
	1125	var file_names: std.array_hash_map.Auto(u32, []const u8) = .empty;
1126	1126	errdefer {
1127	1127	for (file_names.values()) \|file_name\| gpa.free(file_name);
1128	1128	file_names.deinit(gpa);
1129	1129	}
1130	1130
1131		var category_names: std.AutoArrayHashMapUnmanaged(u32, []const u8) = .empty;
	1131	var category_names: std.array_hash_map.Auto(u32, []const u8) = .empty;
1132	1132	errdefer {
1133	1133	for (category_names.values()) \|category_name\| gpa.free(category_name);
1134	1134	category_names.deinit(gpa);
...	...	@@ -1604,7 +1604,7 @@ pub const CreateOptions = struct {
1604	1604	/// implementations still do.
1605	1605	lib_directories: []const Cache.Directory = &.{},
1606	1606	rpath_list: []const []const u8 = &[0][]const u8{},
1607		symbol_wrap_set: std.StringArrayHashMapUnmanaged(void) = .empty,
	1607	symbol_wrap_set: std.array_hash_map.String(void) = .empty,
1608	1608	c_source_files: []const CSourceFile = &.{},
1609	1609	rc_source_files: []const RcSourceFile = &.{},
1610	1610	manifest_file: ?[]const u8 = null,
...	...	@@ -1683,7 +1683,7 @@ pub const CreateOptions = struct {
1683	1683	skip_linker_dependencies: bool = false,
1684	1684	hash_style: link.File.Lld.Elf.HashStyle = .both,
1685	1685	entry: Entry = .default,
1686		force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .empty,
	1686	force_undefined_symbols: std.array_hash_map.String(void) = .empty,
1687	1687	stack_size: ?u64 = null,
1688	1688	image_base: ?u64 = null,
1689	1689	version: ?std.SemanticVersion = null,
...	...	@@ -4064,7 +4064,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle {
4064	4064	}
4065	4065	}
4066	4066	if (zcu.skip_analysis_this_update) break :zcu_errors;
4067		var sorted_failed_analysis: std.AutoArrayHashMapUnmanaged(InternPool.AnalUnit, *Zcu.ErrorMsg).DataList.Slice = s: {
	4067	var sorted_failed_analysis: std.array_hash_map.Auto(InternPool.AnalUnit, *Zcu.ErrorMsg).DataList.Slice = s: {
4068	4068	const SortOrder = struct {
4069	4069	zcu: *Zcu,
4070	4070	errors: []const *Zcu.ErrorMsg,
...	...	@@ -4360,7 +4360,7 @@ pub fn addModuleErrorMsg(
4360	4360
4361	4361	// De-duplicate error notes. The main use case in mind for this is
4362	4362	// too many "note: called from here" notes when eval branch quota is reached.
4363		var notes: std.ArrayHashMapUnmanaged(ErrorBundle.ErrorMessage, void, ErrorNoteHashContext, true) = .empty;
	4363	var notes: std.array_hash_map.Custom(ErrorBundle.ErrorMessage, void, ErrorNoteHashContext, true) = .empty;
4364	4364	defer notes.deinit(gpa);
4365	4365
4366	4366	var last_note_loc: ?std.zig.Loc = null;
...	...	@@ -4831,7 +4831,7 @@ fn docsCopyFallible(comp: *Compilation) anyerror!void {
4831	4831	var buffer: [1024]u8 = undefined;
4832	4832	var tar_file_writer = tar_file.writer(io, &buffer);
4833	4833
4834		var seen_table: std.AutoArrayHashMapUnmanaged(*Package.Module, []const u8) = .empty;
	4834	var seen_table: std.array_hash_map.Auto(*Package.Module, []const u8) = .empty;
4835	4835	defer seen_table.deinit(comp.gpa);
4836	4836
4837	4837	try seen_table.put(comp.gpa, zcu.main_mod, comp.root_name);

src/InternPool.zig+13-13

...	...	@@ -41,22 +41,22 @@ tid_shift_32: if (single_threaded) u0 else std.math.Log2Int(u32),
41	41	/// * For a `func`, this is the source of the full function signature.
42	42	/// These are also invalidated if tracking fails for this instruction.
43	43	/// Value is index into `dep_entries` of the first dependency on this hash.
44		src_hash_deps: std.AutoArrayHashMapUnmanaged(TrackedInst.Index, DepEntry.Index),
	44	src_hash_deps: std.array_hash_map.Auto(TrackedInst.Index, DepEntry.Index),
45	45	/// Dependencies on the value of a Nav.
46	46	/// Value is index into `dep_entries` of the first dependency on this Nav value.
47		nav_val_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
	47	nav_val_deps: std.array_hash_map.Auto(Nav.Index, DepEntry.Index),
48	48	/// Dependencies on the type of a Nav.
49	49	/// Value is index into `dep_entries` of the first dependency on this Nav value.
50		nav_ty_deps: std.AutoArrayHashMapUnmanaged(Nav.Index, DepEntry.Index),
	50	nav_ty_deps: std.array_hash_map.Auto(Nav.Index, DepEntry.Index),
51	51	/// Dependencies on a function's inferred error set. Key is the function body, not the IES.
52	52	/// Value is index into `dep_entries` of the first dependency on this function's IES.
53		func_ies_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
	53	func_ies_deps: std.array_hash_map.Auto(Index, DepEntry.Index),
54	54	/// Dependencies on the resolved layout of a `struct`, `union`, or `enum` type.
55	55	/// Value is index into `dep_entries` of the first dependency on this type's layout.
56		type_layout_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
	56	type_layout_deps: std.array_hash_map.Auto(Index, DepEntry.Index),
57	57	/// Dependencies on the resolved default field values of a `struct` type.
58	58	/// Value is index into `dep_entries` of the first dependency on this type's inits.
59		struct_defaults_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
	59	struct_defaults_deps: std.array_hash_map.Auto(Index, DepEntry.Index),
60	60	/// Dependencies on a Zig or ZON source file. Triggered by `@import`.
61	61	/// * For ZON source files, the dependency is invalidated if the file changes at all. The `@import`
62	62	/// must be re-analyzed to return the new data structure.
...	...	@@ -64,18 +64,18 @@ struct_defaults_deps: std.AutoArrayHashMapUnmanaged(Index, DepEntry.Index),
64	64	/// (which can only happen because the `.main_struct_inst` got lost). The `@import` must be
65	65	/// re-analyzed to return the new type.
66	66	/// Value is index into `dep_entries` of the first dependency on this Zig/ZON file.
67		source_file_deps: std.AutoArrayHashMapUnmanaged(FileIndex, DepEntry.Index),
	67	source_file_deps: std.array_hash_map.Auto(FileIndex, DepEntry.Index),
68	68	/// Dependencies on an embedded file.
69	69	/// Introduced by `@embedFile`; invalidated when the file changes.
70	70	/// Value is index into `dep_entries` of the first dependency on this `Zcu.EmbedFile`.
71		embed_file_deps: std.AutoArrayHashMapUnmanaged(Zcu.EmbedFile.Index, DepEntry.Index),
	71	embed_file_deps: std.array_hash_map.Auto(Zcu.EmbedFile.Index, DepEntry.Index),
72	72	/// Dependencies on the full set of names in a ZIR namespace.
73	73	/// Key refers to a `struct_decl`, `union_decl`, etc.
74	74	/// Value is index into `dep_entries` of the first dependency on this namespace.
75		namespace_deps: std.AutoArrayHashMapUnmanaged(TrackedInst.Index, DepEntry.Index),
	75	namespace_deps: std.array_hash_map.Auto(TrackedInst.Index, DepEntry.Index),
76	76	/// Dependencies on the (non-)existence of some name in a namespace.
77	77	/// Value is index into `dep_entries` of the first dependency on this name.
78		namespace_name_deps: std.AutoArrayHashMapUnmanaged(NamespaceNameKey, DepEntry.Index),
	78	namespace_name_deps: std.array_hash_map.Auto(NamespaceNameKey, DepEntry.Index),
79	79	// Dependencies on the value of fields memoized on `Zcu` (`panic_messages` etc).
80	80	// If set, these are indices into `dep_entries` of the first dependency on this state.
81	81	memoized_state_main_deps: DepEntry.Index.Optional,
...	...	@@ -86,7 +86,7 @@ memoized_state_assembly_deps: DepEntry.Index.Optional,
86	86	/// Given a `Depender`, points to an entry in `dep_entries` whose `depender`
87	87	/// matches. The `next_dependee` field can be used to iterate all such entries
88	88	/// and remove them from the corresponding lists.
89		first_dependency: std.AutoArrayHashMapUnmanaged(AnalUnit, DepEntry.Index),
	89	first_dependency: std.array_hash_map.Auto(AnalUnit, DepEntry.Index),
90	90
91	91	/// Stores dependency information. The hashmaps declared above are used to look
92	92	/// up entries in this list as required. This is not stored in `extra` so that
...	...	@@ -1587,7 +1587,7 @@ fn getIndexMask(ip: *const InternPool, comptime BackingInt: type) u32 {
1587	1587	return @as(u32, std.math.maxInt(BackingInt)) >> ip.tid_width;
1588	1588	}
1589	1589
1590		const FieldMap = std.ArrayHashMapUnmanaged(void, void, std.array_hash_map.AutoContext(void), false);
	1590	const FieldMap = std.array_hash_map.Custom(void, void, std.array_hash_map.AutoContext(void), false);
1591	1591
1592	1592	/// An index into `maps` which might be `none`.
1593	1593	pub const OptionalMapIndex = enum(u32) {
...	...	@@ -11039,7 +11039,7 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator,
11039	11039	defer arena_allocator.deinit();
11040	11040	const arena = arena_allocator.allocator();
11041	11041
11042		var instances: std.AutoArrayHashMapUnmanaged(Index, std.ArrayList(Index)) = .empty;
	11042	var instances: std.array_hash_map.Auto(Index, std.ArrayList(Index)) = .empty;
11043	11043	for (ip.locals, 0..) \|*local, tid\| {
11044	11044	const items = local.shared.items.view().slice();
11045	11045	const extra_list = local.shared.extra;

src/Package/Fetch.zig+5-5

...	...	@@ -162,9 +162,9 @@ pub const JobQueue = struct {
162	162	/// Both non-lazy and lazy dependencies are always fetched.
163	163	all,
164	164	};
165		pub const Table = std.AutoArrayHashMapUnmanaged(Package.Hash, *Fetch);
166		pub const UnlazySet = std.AutoArrayHashMapUnmanaged(Package.Hash, void);
167		pub const ForkSet = std.ArrayHashMapUnmanaged(Fork, void, Fork.Context, false);
	165	pub const Table = std.array_hash_map.Auto(Package.Hash, *Fetch);
	166	pub const UnlazySet = std.array_hash_map.Auto(Package.Hash, void);
	167	pub const ForkSet = std.array_hash_map.Custom(Fork, void, Fork.Context, false);
168	168
169	169	pub const Fork = struct {
170	170	path: Cache.Path,
...	...	@@ -1725,7 +1725,7 @@ fn computeHash(f: *Fetch, pkg_path: Cache.Path, filter: Filter) RunError!Compute
1725	1725
1726	1726	// Track directories which had any files deleted from them so that empty directories
1727	1727	// can be deleted.
1728		var sus_dirs: std.StringArrayHashMapUnmanaged(void) = .empty;
	1728	var sus_dirs: std.array_hash_map.String(void) = .empty;
1729	1729	defer sus_dirs.deinit(gpa);
1730	1730
1731	1731	var walker = try root_dir.walk(gpa);
...	...	@@ -2002,7 +2002,7 @@ fn normalizePath(bytes: []u8) void {
2002	2002	}
2003	2003
2004	2004	const Filter = struct {
2005		include_paths: std.StringArrayHashMapUnmanaged(void) = .empty,
	2005	include_paths: std.array_hash_map.String(void) = .empty,
2006	2006
2007	2007	/// sub_path is relative to the package root.
2008	2008	pub fn includePath(self: *const Filter, sub_path: []const u8) bool {

src/Package/Manifest.zig+4-4

...	...	@@ -42,9 +42,9 @@ name: []const u8,
42	42	id: u32,
43	43	version: std.SemanticVersion,
44	44	version_node: Ast.Node.Index,
45		dependencies: std.StringArrayHashMapUnmanaged(Dependency),
	45	dependencies: std.array_hash_map.String(Dependency),
46	46	dependencies_node: Ast.Node.OptionalIndex,
47		paths: std.StringArrayHashMapUnmanaged(void),
	47	paths: std.array_hash_map.String(void),
48	48	minimum_zig_version: ?std.SemanticVersion,
49	49
50	50	errors: []ErrorMessage,
...	...	@@ -144,9 +144,9 @@ const Parse = struct {
144	144	id: u32,
145	145	version: std.SemanticVersion,
146	146	version_node: Ast.Node.Index,
147		dependencies: std.StringArrayHashMapUnmanaged(Dependency),
	147	dependencies: std.array_hash_map.String(Dependency),
148	148	dependencies_node: Ast.Node.OptionalIndex,
149		paths: std.StringArrayHashMapUnmanaged(void),
	149	paths: std.array_hash_map.String(void),
150	150	allow_missing_paths_field: bool,
151	151	minimum_zig_version: ?std.SemanticVersion,
152	152

src/Package/Module.zig+2-2

...	...	@@ -35,11 +35,11 @@ cc_argv: []const []const u8,
35	35	structured_cfg: bool,
36	36	no_builtin: bool,
37	37
38		pub const Deps = std.StringArrayHashMapUnmanaged(*Module);
	38	pub const Deps = std.array_hash_map.String(*Module);
39	39
40	40	pub const Tree = struct {
41	41	/// Each `Package` exposes a `Module` with build.zig as its root source file.
42		build_module_table: std.AutoArrayHashMapUnmanaged(MultiHashHexDigest, *Module),
	42	build_module_table: std.array_hash_map.Auto(MultiHashHexDigest, *Module),
43	43	};
44	44
45	45	pub const CreateOptions = struct {

src/Sema.zig+6-6

...	...	@@ -88,7 +88,7 @@ err: ?*Zcu.ErrorMsg = null,
88	88
89	89	/// The temporary arena is used for the memory of the `InferredAlloc` values
90	90	/// here so the values can be dropped without any cleanup.
91		unresolved_inferred_allocs: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InferredAlloc) = .empty,
	91	unresolved_inferred_allocs: std.array_hash_map.Auto(Air.Inst.Index, InferredAlloc) = .empty,
92	92
93	93	/// Links every pointer derived from a base `alloc` back to that `alloc`. Used
94	94	/// to detect comptime-known `const`s.
...	...	@@ -119,13 +119,13 @@ exports: std.ArrayList(Zcu.Export) = .empty,
119	119	/// All references registered so far by this `Sema`. This is a temporary duplicate
120	120	/// of data stored in `Zcu.all_references`. It exists to avoid adding references to
121	121	/// a given `AnalUnit` multiple times.
122		references: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
123		type_references: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty,
	122	references: std.array_hash_map.Auto(AnalUnit, void) = .empty,
	123	type_references: std.array_hash_map.Auto(InternPool.Index, void) = .empty,
124	124
125	125	/// All dependencies registered so far by this `Sema`. This is a temporary duplicate
126	126	/// of the main dependency data. It exists to avoid adding dependencies to a given
127	127	/// `AnalUnit` multiple times.
128		dependencies: std.AutoArrayHashMapUnmanaged(InternPool.Dependee, void) = .empty,
	128	dependencies: std.array_hash_map.Auto(InternPool.Dependee, void) = .empty,
129	129
130	130	/// Whether memoization of this call is permitted. Operations with side effects global
131	131	/// to the `Sema`, such as `@setEvalBranchQuota`, set this to `false`. It is observed
...	...	@@ -212,11 +212,11 @@ pub const InferredErrorSet = struct {
212	212	/// are returned from any dependent functions.
213	213	errors: NameMap = .{},
214	214	/// Other inferred error sets which this inferred error set should include.
215		inferred_error_sets: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty,
	215	inferred_error_sets: std.array_hash_map.Auto(InternPool.Index, void) = .empty,
216	216	/// The regular error set created by resolving this inferred error set.
217	217	resolved: InternPool.Index = .none,
218	218
219		pub const NameMap = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void);
	219	pub const NameMap = std.array_hash_map.Auto(InternPool.NullTerminatedString, void);
220	220
221	221	pub fn addErrorSet(
222	222	self: *InferredErrorSet,

src/Type.zig+3-3

...	...	@@ -3340,7 +3340,7 @@ pub fn assertHasLayout(ty: Type, zcu: *const Zcu) void {
3340	3340	}
3341	3341
3342	3342	/// Recursively walks the type and marks for each subtype how many times it has been seen
3343		fn collectSubtypes(ty: Type, pt: Zcu.PerThread, visited: *std.AutoArrayHashMapUnmanaged(Type, u16)) error{OutOfMemory}!void {
	3343	fn collectSubtypes(ty: Type, pt: Zcu.PerThread, visited: *std.array_hash_map.Auto(Type, u16)) error{OutOfMemory}!void {
3344	3344	const zcu = pt.zcu;
3345	3345	const ip = &zcu.intern_pool;
3346	3346
...	...	@@ -3455,8 +3455,8 @@ fn shouldDedupeType(ty: Type, ctx: *Comparison, pt: Zcu.PerThread) error{OutOfMe
3455	3455	/// the subtype length and number of occurences. Placeholders are then found by
3456	3456	/// iterating `type_dedupe_cache` which caches the inline/placeholder decisions.
3457	3457	pub const Comparison = struct {
3458		type_occurrences: std.AutoArrayHashMapUnmanaged(Type, u16),
3459		type_dedupe_cache: std.AutoArrayHashMapUnmanaged(Type, DedupeEntry),
	3458	type_occurrences: std.array_hash_map.Auto(Type, u16),
	3459	type_dedupe_cache: std.array_hash_map.Auto(Type, DedupeEntry),
3460	3460	placeholder_index: u8,
3461	3461
3462	3462	pub const Placeholder = struct {

src/Zcu.zig+37-37

...	...	@@ -97,20 +97,20 @@ free_exports: std.ArrayList(Export.Index) = .empty,
97	97	/// Maps from an `AnalUnit` which performs a single export, to the index into `all_exports` of
98	98	/// the export it performs. Note that the key is not the `Decl` being exported, but the `AnalUnit`
99	99	/// whose analysis triggered the export.
100		single_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, Export.Index) = .empty,
	100	single_exports: std.array_hash_map.Auto(AnalUnit, Export.Index) = .empty,
101	101	/// Like `single_exports`, but for `AnalUnit`s which perform multiple exports.
102	102	/// The exports are `all_exports.items[index..][0..len]`.
103		multi_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {
	103	multi_exports: std.array_hash_map.Auto(AnalUnit, extern struct {
104	104	index: u32,
105	105	len: u32,
106	106	}) = .{},
107	107
108	108	/// Key is the digest returned by `Builtin.hash`; value is the corresponding module.
109		builtin_modules: std.AutoArrayHashMapUnmanaged(Cache.BinDigest, *Package.Module) = .empty,
	109	builtin_modules: std.array_hash_map.Auto(Cache.BinDigest, *Package.Module) = .empty,
110	110
111	111	/// Populated as soon as the `Compilation` is created. Guaranteed to contain all modules, even builtin ones.
112	112	/// Modules whose root file is not a Zig or ZON file have the value `.none`.
113		module_roots: std.AutoArrayHashMapUnmanaged(*Package.Module, File.Index.Optional) = .empty,
	113	module_roots: std.array_hash_map.Auto(*Package.Module, File.Index.Optional) = .empty,
114	114
115	115	/// The set of all the Zig source files in the Zig Compilation Unit. Tracked in
116	116	/// order to iterate over it and check which source files have been modified on
...	...	@@ -125,7 +125,7 @@ module_roots: std.AutoArrayHashMapUnmanaged(*Package.Module, File.Index.Optional
125	125	///
126	126	/// Not serialized. This state is reconstructed during the first call to
127	127	/// `Compilation.update` of the process for a given `Compilation`.
128		import_table: std.ArrayHashMapUnmanaged(
	128	import_table: std.array_hash_map.Custom(
129	129	File.Index,
130	130	void,
131	131	struct {
...	...	@@ -141,7 +141,7 @@ import_table: std.ArrayHashMapUnmanaged(
141	141	/// update removes an import, or if a module specified on the CLI is never imported.
142	142	/// Reconstructed on every update, after AstGen and before Sema.
143	143	/// Value is why the file is alive.
144		alive_files: std.AutoArrayHashMapUnmanaged(File.Index, File.Reference) = .empty,
	144	alive_files: std.array_hash_map.Auto(File.Index, File.Reference) = .empty,
145	145
146	146	/// If this is populated, a "file exists in multiple modules" error should be emitted.
147	147	/// This causes file errors to not be shown, because we don't really know which files
...	...	@@ -162,7 +162,7 @@ multi_module_err: ?struct {
162	162	/// on the `Compilation.Path` of the `EmbedFile`.
163	163	///
164	164	/// This table owns all of the `*EmbedFile` memory, which is allocated into gpa.
165		embed_table: std.ArrayHashMapUnmanaged(
	165	embed_table: std.array_hash_map.Custom(
166	166	*EmbedFile,
167	167	void,
168	168	struct {
...	...	@@ -179,27 +179,27 @@ intern_pool: InternPool = .empty,
179	179
180	180	/// Value explains why this `AnalUnit` is being analyzed. It is `null` for the topmost analysis
181	181	/// (index 0), and non-`null` for all others.
182		analysis_in_progress: std.AutoArrayHashMapUnmanaged(AnalUnit, ?*const DependencyReason) = .empty,
	182	analysis_in_progress: std.array_hash_map.Auto(AnalUnit, ?*const DependencyReason) = .empty,
183	183	/// The ErrorMsg memory is owned by the `AnalUnit`, using Module's general purpose allocator.
184		failed_analysis: std.AutoArrayHashMapUnmanaged(AnalUnit, *ErrorMsg) = .empty,
	184	failed_analysis: std.array_hash_map.Auto(AnalUnit, *ErrorMsg) = .empty,
185	185	/// This `AnalUnit` failed semantic analysis because it required analysis of another `AnalUnit` which itself failed.
186		transitive_failed_analysis: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
	186	transitive_failed_analysis: std.array_hash_map.Auto(AnalUnit, void) = .empty,
187	187	/// This `Nav` succeeded analysis, but failed codegen.
188	188	/// This may be a simple "value" `Nav`, or it may be a function.
189	189	/// The ErrorMsg memory is owned by the `AnalUnit`, using Module's general purpose allocator.
190	190	/// While multiple threads are active (most of the time!), this is guarded by `zcu.comp.mutex`, as
191	191	/// codegen and linking run on a separate thread.
192		failed_codegen: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, *ErrorMsg) = .empty,
193		failed_types: std.AutoArrayHashMapUnmanaged(InternPool.Index, *ErrorMsg) = .empty,
	192	failed_codegen: std.array_hash_map.Auto(InternPool.Nav.Index, *ErrorMsg) = .empty,
	193	failed_types: std.array_hash_map.Auto(InternPool.Index, *ErrorMsg) = .empty,
194	194
195	195	/// Key is an `AnalUnit` which is in `dependency_loop_nodes`. For each dependency loop, exactly one
196	196	/// unit in the loop is in this map, though the choice is arbitrary and not necessarily reproducible
197	197	/// between compilations. So, instead of (for instance) defining where the dependency loop "starts",
198	198	/// this map simply exists to allow easily iterating all dependency loops exactly once.
199		dependency_loops: std.AutoArrayHashMapUnmanaged(AnalUnit, void) = .empty,
	199	dependency_loops: std.array_hash_map.Auto(AnalUnit, void) = .empty,
200	200	/// Key is an `AnalUnit`, value is the `AnalUnit` which the key references and why it does so.
201	201	/// All units in here form loops. To iterate loops, see `dependency_loops`.
202		dependency_loop_nodes: std.AutoArrayHashMapUnmanaged(AnalUnit, struct {
	202	dependency_loop_nodes: std.array_hash_map.Auto(AnalUnit, struct {
203	203	unit: AnalUnit,
204	204	reason: DependencyReason,
205	205	}) = .empty,
...	...	@@ -207,7 +207,7 @@ dependency_loop_nodes: std.AutoArrayHashMapUnmanaged(AnalUnit, struct {
207	207	/// Keep track of `@compileLog`s per `AnalUnit`.
208	208	/// We track the source location of the first `@compileLog` call, and all logged lines as a linked list.
209	209	/// The list is singly linked, but we do track its tail for fast appends (optimizing many logs in one unit).
210		compile_logs: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {
	210	compile_logs: std.array_hash_map.Auto(AnalUnit, extern struct {
211	211	base_node_inst: InternPool.TrackedInst.Index,
212	212	node_offset: Ast.Node.Offset,
213	213	first_line: CompileLogLine.Index,
...	...	@@ -228,7 +228,7 @@ free_compile_log_lines: std.ArrayList(CompileLogLine.Index) = .empty,
228	228	/// We just store a `[]u8` instead of a full `*ErrorMsg`, because the source
229	229	/// location is always the entire file. The `[]u8` memory is owned by the map
230	230	/// and allocated into `gpa`.
231		failed_files: std.AutoArrayHashMapUnmanaged(File.Index, ?[]u8) = .empty,
	231	failed_files: std.array_hash_map.Auto(File.Index, ?[]u8) = .empty,
232	232	/// AstGen is not aware of modules, and so cannot determine whether an import
233	233	/// string makes sense. That is the job of a traversal after AstGen.
234	234	///
...	...	@@ -256,10 +256,10 @@ failed_imports: std.ArrayList(struct {
256	256	import_token: Ast.TokenIndex,
257	257	kind: enum { file_outside_module_root, illegal_zig_import },
258	258	}) = .empty,
259		failed_exports: std.AutoArrayHashMapUnmanaged(Export.Index, *ErrorMsg) = .empty,
	259	failed_exports: std.array_hash_map.Auto(Export.Index, *ErrorMsg) = .empty,
260	260	/// If analysis failed due to a cimport error, the corresponding Clang errors
261	261	/// are stored here.
262		cimport_errors: std.AutoArrayHashMapUnmanaged(AnalUnit, std.zig.ErrorBundle) = .empty,
	262	cimport_errors: std.array_hash_map.Auto(AnalUnit, std.zig.ErrorBundle) = .empty,
263	263
264	264	/// Maximum amount of distinct error values, set by --error-limit
265	265	error_limit: ErrorInt,
...	...	@@ -271,19 +271,19 @@ outdated_lock: if (std.debug.runtime_safety) std.Io.RwLock else void = if (std.d
271	271	/// Value is the number of PO dependencies of this AnalUnit.
272	272	/// This value will decrease as we perform semantic analysis to learn what is outdated.
273	273	/// If any of these PO deps is outdated, this value will be moved to `outdated`.
274		potentially_outdated: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .empty,
	274	potentially_outdated: std.array_hash_map.Auto(AnalUnit, u32) = .empty,
275	275	/// Value is the number of PO dependencies of this AnalUnit.
276	276	/// Once this value drops to 0, the AnalUnit is a candidate for re-analysis.
277		outdated: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .empty,
	277	outdated: std.array_hash_map.Auto(AnalUnit, u32) = .empty,
278	278	/// This is the set of all `AnalUnit`s in `outdated` whose PO dependency count is 0.
279	279	/// Such `AnalUnit`s are ready for immediate re-analysis.
280	280	/// See `findOutdatedToAnalyze` for details.
281	281	outdated_ready: struct {
282	282	/// These are separate from other units because it allows `findOutdatedToAnalyze` to prioritize
283	283	/// functions, which is useful because it means they will be sent to codegen more quickly.
284		funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	284	funcs: std.array_hash_map.Auto(InternPool.Index, void),
285	285	/// Does not contain `.func` units.
286		other: std.AutoArrayHashMapUnmanaged(AnalUnit, void),
	286	other: std.array_hash_map.Auto(AnalUnit, void),
287	287	} = .{ .funcs = .empty, .other = .empty },
288	288	/// This contains a list of AnalUnit whose analysis or codegen failed, but the
289	289	/// failure was something like running out of disk space, and trying again may
...	...	@@ -298,23 +298,23 @@ analysis_roots_len: usize = 0,
298	298	/// This is the cached result of `Zcu.resolveReferences`. It is computed on-demand, and
299	299	/// reset to `null` when any semantic analysis occurs (since this invalidates the data).
300	300	/// Allocated into `gpa`.
301		resolved_references: ?std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) = null,
	301	resolved_references: ?std.array_hash_map.Auto(AnalUnit, ?ResolvedReference) = null,
302	302
303	303	/// If `true`, then semantic analysis must not occur on this update due to AstGen errors.
304	304	/// Essentially the entire pipeline after AstGen, including Sema, codegen, and link, is skipped.
305	305	/// Reset to `false` at the start of each update in `Compilation.update`.
306	306	skip_analysis_this_update: bool = false,
307	307
308		test_functions: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty,
	308	test_functions: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty,
309	309
310		global_assembly: std.AutoArrayHashMapUnmanaged(AnalUnit, []u8) = .empty,
	310	global_assembly: std.array_hash_map.Auto(AnalUnit, []u8) = .empty,
311	311
312	312	/// Key is the `AnalUnit` performing the reference. This representation allows
313	313	/// incremental updates to quickly delete references caused by a specific `AnalUnit`.
314	314	/// Value is index into `all_references` of the first reference triggered by the unit.
315	315	/// The `next` field on the `Reference` forms a linked list of all references
316	316	/// triggered by the key `AnalUnit`.
317		reference_table: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .empty,
	317	reference_table: std.array_hash_map.Auto(AnalUnit, u32) = .empty,
318	318	all_references: std.ArrayList(Reference) = .empty,
319	319	/// Freelist of indices in `all_references`.
320	320	free_references: std.ArrayList(u32) = .empty,
...	...	@@ -327,7 +327,7 @@ free_inline_reference_frames: std.ArrayList(InlineReferenceFrame.Index) = .empty
327	327	/// Value is index into `all_type_reference` of the first reference triggered by the unit.
328	328	/// The `next` field on the `TypeReference` forms a linked list of all type references
329	329	/// triggered by the key `AnalUnit`.
330		type_reference_table: std.AutoArrayHashMapUnmanaged(AnalUnit, u32) = .empty,
	330	type_reference_table: std.array_hash_map.Auto(AnalUnit, u32) = .empty,
331	331	all_type_references: std.ArrayList(TypeReference) = .empty,
332	332	/// Freelist of indices in `all_type_references`.
333	333	free_type_references: std.ArrayList(u32) = .empty,
...	...	@@ -355,12 +355,12 @@ pub const DependencyReason = struct {
355	355	pub const IncrementalDebugState = struct {
356	356	/// All container types in the ZCU, even dead ones.
357	357	/// Value is the generation the type was created on.
358		types: std.AutoArrayHashMapUnmanaged(InternPool.Index, u32),
	358	types: std.array_hash_map.Auto(InternPool.Index, u32),
359	359	/// All `Nav`s in the ZCU, even dead ones.
360	360	/// Value is the generation the `Nav` was created on.
361		navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, u32),
	361	navs: std.array_hash_map.Auto(InternPool.Nav.Index, u32),
362	362	/// All `AnalUnit`s in the ZCU, even dead ones.
363		units: std.AutoArrayHashMapUnmanaged(AnalUnit, UnitInfo),
	363	units: std.array_hash_map.Auto(AnalUnit, UnitInfo),
364	364
365	365	pub const init: IncrementalDebugState = .{
366	366	.types = .empty,
...	...	@@ -681,7 +681,7 @@ pub const SimplePanicId = enum {
681	681	}
682	682	};
683	683
684		pub const GlobalErrorSet = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void);
	684	pub const GlobalErrorSet = std.array_hash_map.Auto(InternPool.NullTerminatedString, void);
685	685
686	686	pub const CImportError = struct {
687	687	offset: u32,
...	...	@@ -840,9 +840,9 @@ pub const Namespace = struct {
840	840	/// Will be a struct, enum, union, or opaque.
841	841	owner_type: InternPool.Index,
842	842	/// Members of the namespace which are marked `pub`.
843		pub_decls: std.ArrayHashMapUnmanaged(InternPool.Nav.Index, void, NavNameContext, true) = .empty,
	843	pub_decls: std.array_hash_map.Custom(InternPool.Nav.Index, void, NavNameContext, true) = .empty,
844	844	/// Members of the namespace which are not marked `pub`.
845		priv_decls: std.ArrayHashMapUnmanaged(InternPool.Nav.Index, void, NavNameContext, true) = .empty,
	845	priv_decls: std.array_hash_map.Custom(InternPool.Nav.Index, void, NavNameContext, true) = .empty,
846	846	/// All `comptime` declarations in this namespace. We store these purely so that incremental
847	847	/// compilation can re-use the existing `ComptimeUnit`s when a namespace changes.
848	848	comptime_decls: std.ArrayList(InternPool.ComptimeUnit.Id) = .empty,
...	...	@@ -4188,13 +4188,13 @@ pub const ResolvedReference = struct {
4188	4188	/// If an `AnalUnit` is not in the returned map, it is unreferenced.
4189	4189	/// The returned hashmap is owned by the `Zcu`, so should not be freed by the caller.
4190	4190	/// This hashmap is cached, so repeated calls to this function are cheap.
4191		pub fn resolveReferences(zcu: Zcu) Allocator.Error!const std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
	4191	pub fn resolveReferences(zcu: Zcu) Allocator.Error!const std.array_hash_map.Auto(AnalUnit, ?ResolvedReference) {
4192	4192	if (zcu.resolved_references == null) {
4193	4193	zcu.resolved_references = try zcu.resolveReferencesInner();
4194	4194	}
4195	4195	return &zcu.resolved_references.?;
4196	4196	}
4197		fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) {
	4197	fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.array_hash_map.Auto(AnalUnit, ?ResolvedReference) {
4198	4198	const trace = tracy.trace(@src());
4199	4199	defer trace.end();
4200	4200
...	...	@@ -4202,8 +4202,8 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.AutoArrayHashMapUnmanag
4202	4202	const comp = zcu.comp;
4203	4203	const ip = &zcu.intern_pool;
4204	4204
4205		var units: std.AutoArrayHashMapUnmanaged(AnalUnit, ?ResolvedReference) = .empty;
4206		var types: std.AutoArrayHashMapUnmanaged(InternPool.Index, ?ResolvedReference) = .empty;
	4205	var units: std.array_hash_map.Auto(AnalUnit, ?ResolvedReference) = .empty;
	4206	var types: std.array_hash_map.Auto(InternPool.Index, ?ResolvedReference) = .empty;
4207	4207	defer {
4208	4208	units.deinit(gpa);
4209	4209	types.deinit(gpa);

src/Zcu/PerThread.zig+6-6

...	...	@@ -787,7 +787,7 @@ const UpdatedFile = struct {
787	787	inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index),
788	788	};
789	789
790		fn cleanupUpdatedFiles(gpa: Allocator, updated_files: *std.AutoArrayHashMapUnmanaged(Zcu.File.Index, UpdatedFile)) void {
	790	fn cleanupUpdatedFiles(gpa: Allocator, updated_files: *std.array_hash_map.Auto(Zcu.File.Index, UpdatedFile)) void {
791	791	for (updated_files.values()) \|*elem\| elem.inst_map.deinit(gpa);
792	792	updated_files.deinit(gpa);
793	793	}
...	...	@@ -805,7 +805,7 @@ fn updateZirRefs(pt: Zcu.PerThread) (Io.Cancelable \|\| Allocator.Error)!void {
805	805
806	806	// We need to visit every updated File for every TrackedInst in InternPool.
807	807	// This only includes Zig files; ZON files are omitted.
808		var updated_files: std.AutoArrayHashMapUnmanaged(Zcu.File.Index, UpdatedFile) = .empty;
	808	var updated_files: std.array_hash_map.Auto(Zcu.File.Index, UpdatedFile) = .empty;
809	809	defer cleanupUpdatedFiles(gpa, &updated_files);
810	810
811	811	for (zcu.import_table.keys()) \|file_index\| {
...	...	@@ -907,7 +907,7 @@ fn updateZirRefs(pt: Zcu.PerThread) (Io.Cancelable \|\| Allocator.Error)!void {
907	907	if (!has_namespace) continue;
908	908
909	909	// Value is whether the declaration is `pub`.
910		var old_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, bool) = .empty;
	910	var old_names: std.array_hash_map.Auto(InternPool.NullTerminatedString, bool) = .empty;
911	911	defer old_names.deinit(zcu.gpa);
912	912	for (old_zir.typeDecls(old_inst)) \|decl_inst\| {
913	913	const old_decl = old_zir.getDeclaration(decl_inst);
...	...	@@ -3568,8 +3568,8 @@ pub fn processExports(pt: Zcu.PerThread) !void {
3568	3568	}
3569	3569
3570	3570	// First, construct a mapping of every exported value and Nav to the indices of all its different exports.
3571		var nav_exports: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, std.ArrayList(Zcu.Export.Index)) = .empty;
3572		var uav_exports: std.AutoArrayHashMapUnmanaged(InternPool.Index, std.ArrayList(Zcu.Export.Index)) = .empty;
	3571	var nav_exports: std.array_hash_map.Auto(InternPool.Nav.Index, std.ArrayList(Zcu.Export.Index)) = .empty;
	3572	var uav_exports: std.array_hash_map.Auto(InternPool.Index, std.ArrayList(Zcu.Export.Index)) = .empty;
3573	3573	defer {
3574	3574	for (nav_exports.values()) \|*exports\| {
3575	3575	exports.deinit(gpa);
...	...	@@ -3665,7 +3665,7 @@ pub fn processExports(pt: Zcu.PerThread) !void {
3665	3665	}
3666	3666	}
3667	3667
3668		const SymbolExports = std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, Zcu.Export.Index);
	3668	const SymbolExports = std.array_hash_map.Auto(InternPool.NullTerminatedString, Zcu.Export.Index);
3669	3669
3670	3670	fn processExportsInner(
3671	3671	pt: Zcu.PerThread,

src/codegen/aarch64/Select.zig+6-6

...	...	@@ -4,12 +4,12 @@ air: Air,
4	4	nav_index: InternPool.Nav.Index,
5	5
6	6	// Blocks
7		def_order: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, void),
8		blocks: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, Block),
9		loops: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, Loop),
	7	def_order: std.array_hash_map.Auto(Air.Inst.Index, void),
	8	blocks: std.array_hash_map.Auto(Air.Inst.Index, Block),
	9	loops: std.array_hash_map.Auto(Air.Inst.Index, Loop),
10	10	active_loops: std.ArrayList(Loop.Index),
11	11	loop_live: struct {
12		set: std.AutoArrayHashMapUnmanaged(struct { Loop.Index, Air.Inst.Index }, void),
	12	set: std.array_hash_map.Auto(struct { Loop.Index, Air.Inst.Index }, void),
13	13	list: std.ArrayList(Air.Inst.Index),
14	14	},
15	15	dom_start: u32,
...	...	@@ -11225,7 +11225,7 @@ fn dumpValuesInner(isel: *Select, which: WhichValues) !void {
11225	11225	defer std.debug.unlockStderr();
11226	11226	const stderr = &locked_stderr.file_writer.interface;
11227	11227
11228		var reverse_live_values: std.AutoArrayHashMapUnmanaged(Value.Index, std.ArrayList(Air.Inst.Index)) = .empty;
	11228	var reverse_live_values: std.array_hash_map.Auto(Value.Index, std.ArrayList(Air.Inst.Index)) = .empty;
11229	11229	defer {
11230	11230	for (reverse_live_values.values()) \|*list\| list.deinit(gpa);
11231	11231	reverse_live_values.deinit(gpa);
...	...	@@ -11254,7 +11254,7 @@ fn dumpValuesInner(isel: *Select, which: WhichValues) !void {
11254	11254	};
11255	11255	}
11256	11256
11257		var roots: std.AutoArrayHashMapUnmanaged(Value.Index, u32) = .empty;
	11257	var roots: std.array_hash_map.Auto(Value.Index, u32) = .empty;
11258	11258	defer roots.deinit(gpa);
11259	11259	{
11260	11260	try roots.ensureTotalCapacity(gpa, isel.values.items.len);

src/codegen/c.zig+11-11

...	...	@@ -59,14 +59,14 @@ pub const Mir = struct {
59	59	/// Key is the value of the UAV; value is the UAV's alignment, or
60	60	/// `.none` for natural alignment. The specified alignment is never
61	61	/// less than the natural alignment.
62		need_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
	62	need_uavs: std.array_hash_map.Auto(InternPool.Index, Alignment),
63	63	ctype_deps: CType.Dependencies,
64	64	/// Key is an enum type for which we need a generated `@tagName` function.
65		need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	65	need_tag_name_funcs: std.array_hash_map.Auto(InternPool.Index, void),
66	66	/// Key is a function Nav for which we need a generated `zig_never_tail` wrapper.
67		need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	67	need_never_tail_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void),
68	68	/// Key is a function Nav for which we need a generated `zig_never_inline` wrapper.
69		need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	69	need_never_inline_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void),
70	70
71	71	pub fn deinit(mir: *Mir, gpa: Allocator) void {
72	72	gpa.free(mir.fwd_decl);
...	...	@@ -164,8 +164,8 @@ const LocalType = struct {
164	164	};
165	165
166	166	const LocalIndex = u16;
167		const LocalsList = std.AutoArrayHashMapUnmanaged(LocalIndex, void);
168		const LocalsMap = std.AutoArrayHashMapUnmanaged(LocalType, LocalsList);
	167	const LocalsList = std.array_hash_map.Auto(LocalIndex, void);
	168	const LocalsMap = std.array_hash_map.Auto(LocalType, LocalsList);
169	169
170	170	const ValueRenderLocation = enum {
171	171	initializer,
...	...	@@ -391,11 +391,11 @@ pub const Function = struct {
391	391	code: Writer.Allocating,
392	392	indent_counter: usize,
393	393	/// Key is an enum type for which we need a generated `@tagName` function.
394		need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	394	need_tag_name_funcs: std.array_hash_map.Auto(InternPool.Index, void),
395	395	/// Key is a function Nav for which we need a generated `zig_never_tail` wrapper.
396		need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	396	need_never_tail_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void),
397	397	/// Key is a function Nav for which we need a generated `zig_never_inline` wrapper.
398		need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	398	need_never_inline_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void),
399	399	func_index: InternPool.Index,
400	400	/// All the locals, to be emitted at the top of the function.
401	401	locals: std.ArrayList(LocalType) = .empty,
...	...	@@ -407,7 +407,7 @@ pub const Function = struct {
407	407	/// of variable declarations at the top of a function, sorted descending
408	408	/// by type alignment.
409	409	/// The value is whether the alloc needs to be emitted in the header.
410		allocs: std.AutoArrayHashMapUnmanaged(LocalIndex, bool) = .empty,
	410	allocs: std.array_hash_map.Auto(LocalIndex, bool) = .empty,
411	411	/// Maps from `loop_switch_br` instructions to the allocated local used
412	412	/// for the switch cond. Dispatches should set this local to the new cond.
413	413	loop_switch_conds: std.AutoHashMapUnmanaged(Air.Inst.Index, LocalIndex) = .empty,
...	...	@@ -643,7 +643,7 @@ pub const DeclGen = struct {
643	643	/// Key is the value of the UAV; value is the UAV's alignment, or
644	644	/// `.none` for natural alignment. The specified alignment is never
645	645	/// less than the natural alignment.
646		uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
	646	uavs: std.array_hash_map.Auto(InternPool.Index, Alignment),
647	647
648	648	fn fail(dg: *DeclGen, comptime format: []const u8, args: anytype) Error {
649	649	@branchHint(.cold);

src/codegen/c/type.zig+6-6

...	...	@@ -572,30 +572,30 @@ pub const CType = union(enum) {
572	572	pub const Dependencies = struct {
573	573	/// Key is any Zig type which corresponds to a C `struct`, `union`, or `typedef`. That C
574	574	/// type must be declared and complete.
575		type: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	575	type: std.array_hash_map.Auto(InternPool.Index, void),
576	576
577	577	/// Key is a Zig type which is the payload of an error union. The C `struct` type
578	578	/// corresponding to such an error union must be declared and complete.
579	579	///
580	580	/// These are separate from `type` to avoid redundant types for every different error set
581	581	/// used with the same payload type---for instance a different C type for every `E!void`.
582		errunion_type: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	582	errunion_type: std.array_hash_map.Auto(InternPool.Index, void),
583	583
584	584	/// Like `type`, but the type does not necessarily need to be completed yet: a forward
585	585	/// declaration is sufficient.
586		type_fwd: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	586	type_fwd: std.array_hash_map.Auto(InternPool.Index, void),
587	587
588	588	/// Like `errunion_type`, but the type does not necessarily need to be completed yet: a
589	589	/// forward declaration is sufficient.
590		errunion_type_fwd: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	590	errunion_type_fwd: std.array_hash_map.Auto(InternPool.Index, void),
591	591
592	592	/// Key is a Zig type; value is a bitmask of alignments. For every bit which is set, an
593	593	/// aligned typedef is required. For instance, if bit 3 is set, the C type 'aligned__8_foo'
594	594	/// must be declared through `typedef` (but not necessarily completed yet).
595		aligned_type_fwd: std.AutoArrayHashMapUnmanaged(InternPool.Index, u64),
	595	aligned_type_fwd: std.array_hash_map.Auto(InternPool.Index, u64),
596	596
597	597	/// Key specifies a big-int type whose C `struct` must be declared and complete.
598		bigint: std.AutoArrayHashMapUnmanaged(BigInt, void),
	598	bigint: std.array_hash_map.Auto(BigInt, void),
599	599
600	600	pub const empty: Dependencies = .{
601	601	.type = .empty,

src/codegen/llvm/FuncGen.zig+1-1

...	...	@@ -2513,7 +2513,7 @@ fn airAssembly(self: *FuncGen, inst: Air.Inst.Index) TodoError!Builder.Value {
2513	2513	var llvm_param_i: usize = 0;
2514	2514	var total_i: usize = 0;
2515	2515
2516		var name_map: std.StringArrayHashMapUnmanaged(u16) = .empty;
	2516	var name_map: std.array_hash_map.String(u16) = .empty;
2517	2517	try name_map.ensureUnusedCapacity(arena, max_param_count);
2518	2518
2519	2519	var it = unwrapped_asm.iterateOutputs();

src/codegen/riscv64/CodeGen.zig+4-4

...	...	@@ -112,7 +112,7 @@ const_tracking: ConstTrackingMap = .{},
112	112	inst_tracking: InstTrackingMap = .{},
113	113
114	114	frame_allocs: std.MultiArrayList(FrameAlloc) = .{},
115		free_frame_indices: std.AutoArrayHashMapUnmanaged(FrameIndex, void) = .empty,
	115	free_frame_indices: std.array_hash_map.Auto(FrameIndex, void) = .empty,
116	116	frame_locs: std.MultiArrayList(Mir.FrameLoc) = .{},
117	117
118	118	loops: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
...	...	@@ -338,7 +338,7 @@ const MCValue = union(enum) {
338	338	};
339	339
340	340	const Branch = struct {
341		inst_table: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, MCValue) = .empty,
	341	inst_table: std.array_hash_map.Auto(Air.Inst.Index, MCValue) = .empty,
342	342
343	343	fn deinit(func: *Branch, gpa: Allocator) void {
344	344	func.inst_table.deinit(gpa);
...	...	@@ -346,8 +346,8 @@ const Branch = struct {
346	346	}
347	347	};
348	348
349		const InstTrackingMap = std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InstTracking);
350		const ConstTrackingMap = std.AutoArrayHashMapUnmanaged(InternPool.Index, InstTracking);
	349	const InstTrackingMap = std.array_hash_map.Auto(Air.Inst.Index, InstTracking);
	350	const ConstTrackingMap = std.array_hash_map.Auto(InternPool.Index, InstTracking);
351	351
352	352	const InstTracking = struct {
353	353	long: MCValue,

src/codegen/sparc64/CodeGen.zig+1-1

...	...	@@ -200,7 +200,7 @@ const MCValue = union(enum) {
200	200	};
201	201
202	202	const Branch = struct {
203		inst_table: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, MCValue) = .empty,
	203	inst_table: std.array_hash_map.Auto(Air.Inst.Index, MCValue) = .empty,
204	204
205	205	fn deinit(self: *Branch, gpa: Allocator) void {
206	206	self.inst_table.deinit(gpa);

src/codegen/spirv/Assembler.zig+2-2

...	...	@@ -35,8 +35,8 @@ inst: struct {
35	35	return null;
36	36	}
37	37	} = .{},
38		value_map: std.StringArrayHashMapUnmanaged(AsmValue) = .{},
39		inst_map: std.StringArrayHashMapUnmanaged(void) = .empty,
	38	value_map: std.array_hash_map.String(AsmValue) = .{},
	39	inst_map: std.array_hash_map.String(void) = .empty,
40	40
41	41	const Operand = union(enum) {
42	42	/// Any 'simple' 32-bit value. This could be a mask or

src/codegen/spirv/Module.zig+5-5

...	...	@@ -28,7 +28,7 @@ uav_link: std.AutoHashMapUnmanaged(struct { InternPool.Index, spec.StorageClass
28	28	intern_map: std.AutoHashMapUnmanaged(struct { InternPool.Index, Repr }, Id) = .empty,
29	29	decls: std.ArrayList(Decl) = .empty,
30	30	decl_deps: std.ArrayList(Decl.Index) = .empty,
31		entry_points: std.AutoArrayHashMapUnmanaged(Id, EntryPoint) = .empty,
	31	entry_points: std.array_hash_map.Auto(Id, EntryPoint) = .empty,
32	32	/// This map serves a dual purpose:
33	33	/// - It keeps track of pointers that are currently being emitted, so that we can tell
34	34	/// if they are recursive and need an OpTypeForwardPointer.
...	...	@@ -58,18 +58,18 @@ cache: struct {
58	58	float_types: std.AutoHashMapUnmanaged(std.lang.Type.Float, Id) = .empty,
59	59	vector_types: std.AutoHashMapUnmanaged(struct { Id, u32 }, Id) = .empty,
60	60	array_types: std.AutoHashMapUnmanaged(struct { Id, Id }, Id) = .empty,
61		struct_types: std.ArrayHashMapUnmanaged(StructType, Id, StructType.HashContext, true) = .empty,
62		fn_types: std.ArrayHashMapUnmanaged(FnType, Id, FnType.HashContext, true) = .empty,
	61	struct_types: std.array_hash_map.Custom(StructType, Id, StructType.HashContext, true) = .empty,
	62	fn_types: std.array_hash_map.Custom(FnType, Id, FnType.HashContext, true) = .empty,
63	63
64	64	capabilities: std.AutoHashMapUnmanaged(spec.Capability, void) = .empty,
65	65	extensions: std.StringHashMapUnmanaged(void) = .empty,
66	66	extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, Id) = .empty,
67	67	decorations: std.AutoHashMapUnmanaged(struct { Id, spec.Decoration }, void) = .empty,
68	68	builtins: std.AutoHashMapUnmanaged(struct { spec.BuiltIn, spec.StorageClass }, Decl.Index) = .empty,
69		strings: std.StringArrayHashMapUnmanaged(Id) = .empty,
	69	strings: std.array_hash_map.String(Id) = .empty,
70	70
71	71	bool_const: [2]?Id = .{ null, null },
72		constants: std.ArrayHashMapUnmanaged(Constant, Id, Constant.HashContext, true) = .empty,
	72	constants: std.array_hash_map.Custom(Constant, Id, Constant.HashContext, true) = .empty,
73	73
74	74	spirv_types: std.AutoHashMapUnmanaged(InternPool.Index, Id) = .empty,
75	75	} = .{},

src/codegen/wasm/CodeGen.zig+5-5

...	...	@@ -141,7 +141,7 @@ branches: std.ArrayList(Branch) = .empty,
141	141	/// Table to save `WValue`'s generated by an `Air.Inst`
142	142	// values: ValueTable,
143	143	/// Mapping from Air.Inst.Index to block ids
144		blocks: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, struct {
	144	blocks: std.array_hash_map.Auto(Air.Inst.Index, struct {
145	145	label: u32,
146	146	value: WValue,
147	147	}) = .{},
...	...	@@ -171,12 +171,12 @@ mir_extra: std.ArrayList(u32),
171	171	mir_locals: std.ArrayList(std.wasm.Valtype),
172	172	/// Set of all UAVs referenced by this function. Key is the UAV value, value is the alignment.
173	173	/// `.none` means naturally aligned. An explicit alignment is never less than the natural alignment.
174		mir_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
	174	mir_uavs: std.array_hash_map.Auto(InternPool.Index, Alignment),
175	175	/// Set of all functions whose address this function has taken and which therefore might be called
176	176	/// via a `call_indirect` function.
177		mir_indirect_function_set: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	177	mir_indirect_function_set: std.array_hash_map.Auto(InternPool.Nav.Index, void),
178	178	/// Set of all function types used by this function. These must be interned by the linker.
179		mir_func_tys: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	179	mir_func_tys: std.array_hash_map.Auto(InternPool.Index, void),
180	180	/// The number of `error_name_table_ref` instructions emitted.
181	181	error_name_table_ref_count: u32,
182	182	/// When a function is executing, we store the the current stack pointer's value within this local.
...	...	@@ -322,7 +322,7 @@ const WValue = union(enum) {
322	322	};
323	323
324	324	/// Hashmap to store generated `WValue` for each `Air.Inst.Ref`
325		const ValueTable = std.AutoArrayHashMapUnmanaged(Air.Inst.Ref, WValue);
	325	const ValueTable = std.array_hash_map.Auto(Air.Inst.Ref, WValue);
326	326
327	327	const bookkeeping_init = if (std.debug.runtime_safety) @as(usize, 0) else {};
328	328

src/codegen/wasm/Mir.zig+3-3

...	...	@@ -26,11 +26,11 @@ prologue: Prologue,
26	26
27	27	/// Not directly used by `Emit`, but the linker needs this to merge it with a global set.
28	28	/// Value is the explicit alignment if greater than natural alignment, `.none` otherwise.
29		uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
	29	uavs: std.array_hash_map.Auto(InternPool.Index, Alignment),
30	30	/// Not directly used by `Emit`, but the linker needs this to merge it with a global set.
31		indirect_function_set: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	31	indirect_function_set: std.array_hash_map.Auto(InternPool.Nav.Index, void),
32	32	/// Not directly used by `Emit`, but the linker needs this to ensure these types are interned.
33		func_tys: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	33	func_tys: std.array_hash_map.Auto(InternPool.Index, void),
34	34	/// Not directly used by `Emit`, but the linker needs this to add it to its own refcount.
35	35	error_name_table_ref_count: u32,
36	36

src/codegen/x86_64/CodeGen.zig+3-3

...	...	@@ -140,7 +140,7 @@ register_manager: RegisterManager = .{},
140	140	scope_generation: u32 = 0,
141	141
142	142	frame_allocs: std.MultiArrayList(FrameAlloc) = .empty,
143		free_frame_indices: std.AutoArrayHashMapUnmanaged(FrameIndex, void) = .empty,
	143	free_frame_indices: std.array_hash_map.Auto(FrameIndex, void) = .empty,
144	144	frame_locs: std.MultiArrayList(Mir.FrameLoc) = .empty,
145	145
146	146	loops: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
...	...	@@ -569,8 +569,8 @@ pub const MCValue = union(enum) {
569	569	}
570	570	};
571	571
572		const InstTrackingMap = std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InstTracking);
573		const ConstTrackingMap = std.AutoArrayHashMapUnmanaged(InternPool.Index, InstTracking);
	572	const InstTrackingMap = std.array_hash_map.Auto(Air.Inst.Index, InstTracking);
	573	const ConstTrackingMap = std.array_hash_map.Auto(InternPool.Index, InstTracking);
574	574	const InstTracking = struct {
575	575	long: MCValue,
576	576	short: MCValue,

src/libs/mingw/implib.zig+1-1

...	...	@@ -245,7 +245,7 @@ pub fn getMembers(
245	245	};
246	246	var renames: std.ArrayList(DeferredExport) = .empty;
247	247	defer renames.deinit(allocator);
248		var regular_imports: std.StringArrayHashMapUnmanaged([]const u8) = .empty;
	248	var regular_imports: std.array_hash_map.String([]const u8) = .empty;
249	249	defer regular_imports.deinit(allocator);
250	250
251	251	for (module_def.exports.items) \|*e\| {

src/link.zig+1-1

...	...	@@ -471,7 +471,7 @@ pub const File = struct {
471	471	/// wrapper for a system function. The wrapper function should be called
472	472	/// __wrap_symbol. If it wishes to call the system function, it should call
473	473	/// __real_symbol.
474		symbol_wrap_set: std.StringArrayHashMapUnmanaged(void),
	474	symbol_wrap_set: std.array_hash_map.String(void),
475	475
476	476	compatibility_version: ?std.SemanticVersion,
477	477

src/link/C.zig+26-26

...	...	@@ -44,10 +44,10 @@ type_dependencies: std.ArrayList(link.ConstPool.Index),
44	44	align_dependency_masks: std.ArrayList(u64),
45	45
46	46	/// All NAVs, regardless of whether they are functions or simple constants, are put in this map.
47		navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, RenderedDecl),
	47	navs: std.array_hash_map.Auto(InternPool.Nav.Index, RenderedDecl),
48	48	/// All UAVs which may be referenced are in this map. The UAV alignment is not included in the
49	49	/// rendered C code stored here, because we don't know the alignment a UAV needs until `flush`.
50		uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, RenderedDecl),
	50	uavs: std.array_hash_map.Auto(InternPool.Index, RenderedDecl),
51	51	/// Contains all types which are needed by some other rendered code. Does not contain any constants
52	52	/// other than types.
53	53	type_pool: link.ConstPool,
...	...	@@ -59,10 +59,10 @@ types: std.ArrayList(RenderedType),
59	59	/// The set of big int types required by any generated code so far. These are always safe to emit,
60	60	/// so they do not participate in the dependency graph traversal in `flush`. Therefore, redundant
61	61	/// big-int types may be emitted under incremental compilation.
62		bigint_types: std.AutoArrayHashMapUnmanaged(codegen.CType.BigInt, void),
	62	bigint_types: std.array_hash_map.Auto(codegen.CType.BigInt, void),
63	63
64		exported_navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, String),
65		exported_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, String),
	64	exported_navs: std.array_hash_map.Auto(InternPool.Nav.Index, String),
	65	exported_uavs: std.array_hash_map.Auto(InternPool.Index, String),
66	66
67	67	/// A reference into `string_bytes`.
68	68	const String = extern struct {
...	...	@@ -133,10 +133,10 @@ const RenderedDecl = struct {
133	133	fwd_decl: String,
134	134	code: String,
135	135	ctype_deps: CTypeDependencies,
136		need_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
137		need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
138		need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
139		need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void),
	136	need_uavs: std.array_hash_map.Auto(InternPool.Index, Alignment),
	137	need_tag_name_funcs: std.array_hash_map.Auto(InternPool.Index, void),
	138	need_never_tail_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void),
	139	need_never_inline_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void),
140	140
141	141	const init: RenderedDecl = .{
142	142	.fwd_decl = .empty,
...	...	@@ -746,7 +746,7 @@ pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Prog
746	746	// incremental updates which is invalid C (due to e.g. types changing). Machine code backends
747	747	// don't have this problem because there are, of course, no type checking performed when you
748	748	// execute a binary!
749		var need_navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty;
	749	var need_navs: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty;
750	750	defer need_navs.deinit(gpa);
751	751	{
752	752	const unit_references = try zcu.resolveReferences();
...	...	@@ -774,23 +774,23 @@ pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Prog
774	774	//
775	775	// At the same time, we will discover the set of lazy functions which are referenced.
776	776
777		var need_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment) = .empty;
	777	var need_uavs: std.array_hash_map.Auto(InternPool.Index, Alignment) = .empty;
778	778	defer need_uavs.deinit(gpa);
779	779
780		var need_types: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void) = .empty;
	780	var need_types: std.array_hash_map.Auto(link.ConstPool.Index, void) = .empty;
781	781	defer need_types.deinit(gpa);
782		var need_errunion_types: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void) = .empty;
	782	var need_errunion_types: std.array_hash_map.Auto(link.ConstPool.Index, void) = .empty;
783	783	defer need_errunion_types.deinit(gpa);
784		var need_aligned_types: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, u64) = .empty;
	784	var need_aligned_types: std.array_hash_map.Auto(link.ConstPool.Index, u64) = .empty;
785	785	defer need_aligned_types.deinit(gpa);
786	786
787		var need_tag_name_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .empty;
	787	var need_tag_name_funcs: std.array_hash_map.Auto(InternPool.Index, void) = .empty;
788	788	defer need_tag_name_funcs.deinit(gpa);
789	789
790		var need_never_tail_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty;
	790	var need_never_tail_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty;
791	791	defer need_never_tail_funcs.deinit(gpa);
792	792
793		var need_never_inline_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty;
	793	var need_never_inline_funcs: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty;
794	794	defer need_never_inline_funcs.deinit(gpa);
795	795
796	796	// As mentioned above, we need this type for error names.
...	...	@@ -1284,9 +1284,9 @@ pub fn deleteExport(
1284	1284
1285	1285	fn mergeNeededCTypes(
1286	1286	c: *C,
1287		need_types: *std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void),
1288		need_errunion_types: *std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void),
1289		need_aligned_types: *std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, u64),
	1287	need_types: *std.array_hash_map.Auto(link.ConstPool.Index, void),
	1288	need_errunion_types: *std.array_hash_map.Auto(link.ConstPool.Index, void),
	1289	need_aligned_types: *std.array_hash_map.Auto(link.ConstPool.Index, u64),
1290	1290	deps: *const CTypeDependencies,
1291	1291	) Allocator.Error!void {
1292	1292	const gpa = c.base.comp.gpa;
...	...	@@ -1312,8 +1312,8 @@ fn mergeNeededCTypes(
1312	1312
1313	1313	fn mergeNeededUavs(
1314	1314	zcu: *const Zcu,
1315		global: *std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
1316		new: *const std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment),
	1315	global: *std.array_hash_map.Auto(InternPool.Index, Alignment),
	1316	new: *const std.array_hash_map.Auto(InternPool.Index, Alignment),
1317	1317	) Allocator.Error!void {
1318	1318	const gpa = zcu.comp.gpa;
1319	1319
...	...	@@ -1422,12 +1422,12 @@ const FlushTypes = struct {
1422	1422	c: *C,
1423	1423	f: *Flush,
1424	1424
1425		aligned_types: *const std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, u64),
	1425	aligned_types: *const std.array_hash_map.Auto(link.ConstPool.Index, u64),
1426	1426	aligned_type_strings: []const []const u8,
1427	1427
1428		status: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, bool),
1429		errunion_status: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, bool),
1430		aligned_status: std.AutoArrayHashMapUnmanaged(link.ConstPool.Index, void),
	1428	status: std.array_hash_map.Auto(link.ConstPool.Index, bool),
	1429	errunion_status: std.array_hash_map.Auto(link.ConstPool.Index, bool),
	1430	aligned_status: std.array_hash_map.Auto(link.ConstPool.Index, void),
1431	1431
1432	1432	fn processDeps(ft: FlushTypes, deps: const CTypeDependencies) void {
1433	1433	const resolved = deps.get(ft.c);

src/link/Coff.zig+8-8

...	...	@@ -30,18 +30,18 @@ strings: std.HashMapUnmanaged(
30	30	),
31	31	string_bytes: std.ArrayList(u8),
32	32	image_section_table: std.ArrayList(Symbol.Index),
33		pseudo_section_table: std.AutoArrayHashMapUnmanaged(String, Symbol.Index),
34		object_section_table: std.AutoArrayHashMapUnmanaged(String, Symbol.Index),
	33	pseudo_section_table: std.array_hash_map.Auto(String, Symbol.Index),
	34	object_section_table: std.array_hash_map.Auto(String, Symbol.Index),
35	35	symbol_table: std.ArrayList(Symbol),
36		globals: std.AutoArrayHashMapUnmanaged(GlobalName, Symbol.Index),
	36	globals: std.array_hash_map.Auto(GlobalName, Symbol.Index),
37	37	global_pending_index: u32,
38		navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, Symbol.Index),
39		uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Symbol.Index),
	38	navs: std.array_hash_map.Auto(InternPool.Nav.Index, Symbol.Index),
	39	uavs: std.array_hash_map.Auto(InternPool.Index, Symbol.Index),
40	40	lazy: std.EnumArray(link.File.LazySymbol.Kind, struct {
41		map: std.AutoArrayHashMapUnmanaged(InternPool.Index, Symbol.Index),
	41	map: std.array_hash_map.Auto(InternPool.Index, Symbol.Index),
42	42	pending_index: u32,
43	43	}),
44		pending_uavs: std.AutoArrayHashMapUnmanaged(Node.UavMapIndex, struct {
	44	pending_uavs: std.array_hash_map.Auto(Node.UavMapIndex, struct {
45	45	alignment: InternPool.Alignment,
46	46	}),
47	47	relocs: std.ArrayList(Reloc),
...	...	@@ -272,7 +272,7 @@ pub const Node = union(enum) {
272	272
273	273	pub const ImportTable = struct {
274	274	ni: MappedFile.Node.Index,
275		entries: std.AutoArrayHashMapUnmanaged(void, Entry),
	275	entries: std.array_hash_map.Auto(void, Entry),
276	276
277	277	pub const Entry = struct {
278	278	import_lookup_table_ni: MappedFile.Node.Index,

src/link/ConstPool.zig+3-3

...	...	@@ -15,10 +15,10 @@
15	15	/// * ensure that any `get` call is eventually followed by a `flushPending` call
16	16	const ConstPool = @This();
17	17
18		values: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
	18	values: std.array_hash_map.Auto(InternPool.Index, void),
19	19	pending: std.ArrayList(Index),
20		complete_containers: std.AutoArrayHashMapUnmanaged(InternPool.Index, void),
21		container_deps: std.AutoArrayHashMapUnmanaged(InternPool.Index, ContainerDepEntry.Index),
	20	complete_containers: std.array_hash_map.Auto(InternPool.Index, void),
	21	container_deps: std.array_hash_map.Auto(InternPool.Index, ContainerDepEntry.Index),
22	22	container_dep_entries: std.ArrayList(ContainerDepEntry),
23	23
24	24	pub const empty: ConstPool = .{

src/link/Dwarf.zig+6-6

...	...	@@ -27,11 +27,11 @@ address_size: AddressSize,
27	27
28	28	const_pool: link.ConstPool,
29	29
30		mods: std.AutoArrayHashMapUnmanaged(*Module, ModInfo),
	30	mods: std.array_hash_map.Auto(*Module, ModInfo),
31	31	/// Indices are `link.ConstPool.Index`.
32	32	values: std.ArrayList(struct { Unit.Index, Entry.Index }),
33		navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, Entry.Index),
34		decls: std.AutoArrayHashMapUnmanaged(InternPool.TrackedInst.Index, Entry.Index),
	33	navs: std.array_hash_map.Auto(InternPool.Nav.Index, Entry.Index),
	34	decls: std.array_hash_map.Auto(InternPool.TrackedInst.Index, Entry.Index),
35	35
36	36	debug_abbrev: DebugAbbrev,
37	37	debug_aranges: DebugAranges,
...	...	@@ -69,8 +69,8 @@ pub const AddressSize = enum(u8) {
69	69
70	70	const ModInfo = struct {
71	71	root_dir_path: Entry.Index,
72		dirs: std.AutoArrayHashMapUnmanaged(Unit.Index, void),
73		files: std.AutoArrayHashMapUnmanaged(Zcu.File.Index, void),
	72	dirs: std.array_hash_map.Auto(Unit.Index, void),
	73	files: std.array_hash_map.Auto(Zcu.File.Index, void),
74	74
75	75	fn deinit(mod_info: *ModInfo, gpa: Allocator) void {
76	76	mod_info.dirs.deinit(gpa);
...	...	@@ -236,7 +236,7 @@ const DebugRngLists = struct {
236	236
237	237	const StringSection = struct {
238	238	contents: std.ArrayList(u8),
239		map: std.AutoArrayHashMapUnmanaged(void, void),
	239	map: std.array_hash_map.Auto(void, void),
240	240	section: Section,
241	241
242	242	const unit: Unit.Index = @enumFromInt(0);

src/link/Elf.zig+5-5

...	...	@@ -2,7 +2,7 @@ pub const Atom = @import("Elf/Atom.zig");
2	2
3	3	base: link.File,
4	4	zig_object: ?*ZigObject,
5		rpath_table: std.StringArrayHashMapUnmanaged(void),
	5	rpath_table: std.array_hash_map.String(void),
6	6	image_base: u64,
7	7	z_nodelete: bool,
8	8	z_notext: bool,
...	...	@@ -30,7 +30,7 @@ file_handles: std.ArrayList(File.Handle) = .empty,
30	30	zig_object_index: ?File.Index = null,
31	31	linker_defined_index: ?File.Index = null,
32	32	objects: std.ArrayList(File.Index) = .empty,
33		shared_objects: std.StringArrayHashMapUnmanaged(File.Index) = .empty,
	33	shared_objects: std.array_hash_map.String(File.Index) = .empty,
34	34
35	35	/// List of all output sections and their associated metadata.
36	36	sections: std.MultiArrayList(Section) = .{},
...	...	@@ -249,7 +249,7 @@ pub fn createEmpty(
249	249	const is_dyn_lib = output_mode == .Lib and link_mode == .dynamic;
250	250	const default_sym_version: elf.Versym = if (is_dyn_lib or comp.config.rdynamic) .GLOBAL else .LOCAL;
251	251
252		var rpath_table: std.StringArrayHashMapUnmanaged(void) = .empty;
	252	var rpath_table: std.array_hash_map.String(void) = .empty;
253	253	try rpath_table.entries.resize(arena, options.rpath_list.len);
254	254	@memcpy(rpath_table.entries.items(.key), options.rpath_list);
255	255	try rpath_table.reIndex(arena);
...	...	@@ -1112,7 +1112,7 @@ fn parseDso(
1112	1112	io: Io,
1113	1113	diags: *Diags,
1114	1114	dso: link.Input.Dso,
1115		shared_objects: *std.StringArrayHashMapUnmanaged(File.Index),
	1115	shared_objects: *std.array_hash_map.String(File.Index),
1116	1116	files: *std.MultiArrayList(File.Entry),
1117	1117	target: *const std.Target,
1118	1118	) !void {
...	...	@@ -4153,7 +4153,7 @@ pub const Ref = struct {
4153	4153	pub const SymbolResolver = struct {
4154	4154	keys: std.ArrayList(Key) = .empty,
4155	4155	values: std.ArrayList(Ref) = .empty,
4156		table: std.AutoArrayHashMapUnmanaged(void, void) = .empty,
	4156	table: std.array_hash_map.Auto(void, void) = .empty,
4157	4157
4158	4158	const Result = struct {
4159	4159	found_existing: bool,

src/link/Elf/AtomList.zig+1-1

...	...	@@ -3,7 +3,7 @@ size: u64 = 0,
3	3	alignment: Atom.Alignment = .@"1",
4	4	output_section_index: u32 = 0,
5	5	// atoms: std.ArrayList(Elf.Ref) = .empty,
6		atoms: std.AutoArrayHashMapUnmanaged(Elf.Ref, void) = .empty,
	6	atoms: std.array_hash_map.Auto(Elf.Ref, void) = .empty,
7	7
8	8	dirty: bool = true,
9	9

src/link/Elf/Thunk.zig+1-1

...	...	@@ -1,6 +1,6 @@
1	1	value: i64 = 0,
2	2	output_section_index: u32 = 0,
3		symbols: std.AutoArrayHashMapUnmanaged(Elf.Ref, void) = .empty,
	3	symbols: std.array_hash_map.Auto(Elf.Ref, void) = .empty,
4	4	output_symtab_ctx: Elf.SymtabCtx = .{},
5	5
6	6	pub fn deinit(thunk: *Thunk, allocator: Allocator) void {

src/link/Elf/ZigObject.zig+4-4

...	...	@@ -2408,10 +2408,10 @@ const TlsVariable = struct {
2408	2408	};
2409	2409
2410	2410	const AtomList = std.ArrayList(Atom.Index);
2411		const NavTable = std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, AvMetadata);
2412		const UavTable = std.AutoArrayHashMapUnmanaged(InternPool.Index, AvMetadata);
2413		const LazySymbolTable = std.AutoArrayHashMapUnmanaged(InternPool.Index, LazySymbolMetadata);
2414		const TlsTable = std.AutoArrayHashMapUnmanaged(Atom.Index, void);
	2411	const NavTable = std.array_hash_map.Auto(InternPool.Nav.Index, AvMetadata);
	2412	const UavTable = std.array_hash_map.Auto(InternPool.Index, AvMetadata);
	2413	const LazySymbolTable = std.array_hash_map.Auto(InternPool.Index, LazySymbolMetadata);
	2414	const TlsTable = std.array_hash_map.Auto(Atom.Index, void);
2415	2415
2416	2416	const x86_64 = struct {
2417	2417	fn writeTrampolineCode(source_addr: i64, target_addr: i64, buf: *[max_trampoline_len]u8) ![]u8 {

src/link/Elf2.zig+4-4

...	...	@@ -112,7 +112,7 @@ plt_first_symbol_reloc: SymbolReloc.Index,
112	112	/// The `.dynamic` section contains zero or more symbol relocations starting at this index.
113	113	dynamic_first_symbol_reloc: SymbolReloc.Index,
114	114
115		needed: std.AutoArrayHashMapUnmanaged(String(.dynstr), void),
	115	needed: std.array_hash_map.Auto(String(.dynstr), void),
116	116	inputs: std.ArrayList(struct {
117	117	path: std.Build.Cache.Path,
118	118	member: ?[]const u8,
...	...	@@ -120,21 +120,21 @@ inputs: std.ArrayList(struct {
120	120	}),
121	121	input_sections: std.ArrayList(InputSection),
122	122	input_section_pending_index: u32,
123		navs: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, struct {
	123	navs: std.array_hash_map.Auto(InternPool.Nav.Index, struct {
124	124	lsi: Symbol.LocalIndex,
125	125	/// The start index of the contiguous sequence of symbol relocations in this NAV.
126	126	first_symbol_reloc: SymbolReloc.Index,
127	127	/// The start index of the contiguous sequence of GOT relocations in this NAV.
128	128	first_got_reloc: GotReloc.Index,
129	129	}),
130		uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, struct {
	130	uavs: std.array_hash_map.Auto(InternPool.Index, struct {
131	131	lsi: Symbol.LocalIndex,
132	132	/// The start index of the contiguous sequence of symbol relocations in this UAV.
133	133	first_symbol_reloc: SymbolReloc.Index,
134	134	// No `first_got_reloc` field because a UAV never contains GOT relocations.
135	135	}),
136	136	lazy: std.EnumArray(link.File.LazySymbol.Kind, struct {
137		map: std.AutoArrayHashMapUnmanaged(InternPool.Index, struct {
	137	map: std.array_hash_map.Auto(InternPool.Index, struct {
138	138	lsi: Symbol.LocalIndex,
139	139	/// The start index of the contiguous sequence of symbol relocations in this lazy code/data.
140	140	first_symbol_reloc: SymbolReloc.Index,

src/link/MachO.zig+4-4

...	...	@@ -28,9 +28,9 @@ sections: std.MultiArrayList(Section) = .{},
28	28	resolver: SymbolResolver = .{},
29	29	/// This table will be populated after `scanRelocs` has run.
30	30	/// Key is symbol index.
31		undefs: std.AutoArrayHashMapUnmanaged(SymbolResolver.Index, UndefRefs) = .empty,
	31	undefs: std.array_hash_map.Auto(SymbolResolver.Index, UndefRefs) = .empty,
32	32	undefs_mutex: std.Io.Mutex = .init,
33		dupes: std.AutoArrayHashMapUnmanaged(SymbolResolver.Index, std.ArrayList(File.Index)) = .empty,
	33	dupes: std.array_hash_map.Auto(SymbolResolver.Index, std.ArrayList(File.Index)) = .empty,
34	34	dupes_mutex: std.Io.Mutex = .init,
35	35
36	36	dyld_info_cmd: macho.dyld_info_command = .{},
...	...	@@ -4102,7 +4102,7 @@ const Section = struct {
4102	4102	};
4103	4103
4104	4104	pub const LiteralPool = struct {
4105		table: std.AutoArrayHashMapUnmanaged(void, void) = .empty,
	4105	table: std.array_hash_map.Auto(void, void) = .empty,
4106	4106	keys: std.ArrayList(Key) = .empty,
4107	4107	values: std.ArrayList(MachO.Ref) = .empty,
4108	4108	data: std.ArrayList(u8) = .empty,
...	...	@@ -4541,7 +4541,7 @@ pub const Ref = struct {
4541	4541	pub const SymbolResolver = struct {
4542	4542	keys: std.ArrayList(Key) = .empty,
4543	4543	values: std.ArrayList(Ref) = .empty,
4544		table: std.AutoArrayHashMapUnmanaged(void, void) = .empty,
	4544	table: std.array_hash_map.Auto(void, void) = .empty,
4545	4545
4546	4546	const Result = struct {
4547	4547	found_existing: bool,

src/link/MachO/Dylib.zig+1-1

...	...	@@ -14,7 +14,7 @@ symbols: std.ArrayList(Symbol) = .empty,
14	14	symbols_extra: std.ArrayList(u32) = .empty,
15	15	globals: std.ArrayList(MachO.SymbolResolver.Index) = .empty,
16	16	dependents: std.ArrayList(Id) = .empty,
17		rpaths: std.StringArrayHashMapUnmanaged(void) = .empty,
	17	rpaths: std.array_hash_map.String(void) = .empty,
18	18	umbrella: File.Index,
19	19	platform: ?MachO.Platform = null,
20	20

src/link/MachO/Thunk.zig+1-1

...	...	@@ -1,6 +1,6 @@
1	1	value: u64 = 0,
2	2	out_n_sect: u8 = 0,
3		symbols: std.AutoArrayHashMapUnmanaged(MachO.Ref, void) = .empty,
	3	symbols: std.array_hash_map.Auto(MachO.Ref, void) = .empty,
4	4	output_symtab_ctx: MachO.SymtabCtx = .{},
5	5
6	6	pub fn deinit(thunk: *Thunk, allocator: Allocator) void {

src/link/MachO/ZigObject.zig+4-4

...	...	@@ -1750,11 +1750,11 @@ const TlvInitializer = struct {
1750	1750	}
1751	1751	};
1752	1752
1753		const NavTable = std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, AvMetadata);
1754		const UavTable = std.AutoArrayHashMapUnmanaged(InternPool.Index, AvMetadata);
1755		const LazySymbolTable = std.AutoArrayHashMapUnmanaged(InternPool.Index, LazySymbolMetadata);
	1753	const NavTable = std.array_hash_map.Auto(InternPool.Nav.Index, AvMetadata);
	1754	const UavTable = std.array_hash_map.Auto(InternPool.Index, AvMetadata);
	1755	const LazySymbolTable = std.array_hash_map.Auto(InternPool.Index, LazySymbolMetadata);
1756	1756	const RelocationTable = std.ArrayList(std.ArrayList(Relocation));
1757		const TlvInitializerTable = std.AutoArrayHashMapUnmanaged(Atom.Index, TlvInitializer);
	1757	const TlvInitializerTable = std.array_hash_map.Auto(Atom.Index, TlvInitializer);
1758	1758
1759	1759	const x86_64 = struct {
1760	1760	fn writeTrampolineCode(source_addr: u64, target_addr: u64, buf: *[max_trampoline_len]u8) ![]u8 {

src/link/SpirV/lower_invocation_globals.zig+7-7

...	...	@@ -23,14 +23,14 @@ const ModuleInfo = struct {
23	23	/// The set of (result-id's of) invocation globals that are accessed
24	24	/// in this function, or after resolution, that are accessed in this
25	25	/// function or any of it's callees.
26		invocation_globals: std.AutoArrayHashMapUnmanaged(ResultId, void),
	26	invocation_globals: std.array_hash_map.Auto(ResultId, void),
27	27	};
28	28
29	29	/// Information about a particular invocation global
30	30	const InvocationGlobal = struct {
31	31	/// The list of invocation globals that this invocation global
32	32	/// depends on.
33		dependencies: std.AutoArrayHashMapUnmanaged(ResultId, void),
	33	dependencies: std.array_hash_map.Auto(ResultId, void),
34	34	/// The invocation global's type
35	35	ty: ResultId,
36	36	/// Initializer function. May be `none`.
...	...	@@ -39,13 +39,13 @@ const ModuleInfo = struct {
39	39	};
40	40
41	41	/// Maps function result-id -> Fn information structure.
42		functions: std.AutoArrayHashMapUnmanaged(ResultId, Fn),
	42	functions: std.array_hash_map.Auto(ResultId, Fn),
43	43	/// Set of OpFunction result-ids in this module.
44		entry_points: std.AutoArrayHashMapUnmanaged(ResultId, void),
	44	entry_points: std.array_hash_map.Auto(ResultId, void),
45	45	/// For each function, a list of function result-ids that it calls.
46	46	callee_store: []const ResultId,
47	47	/// Maps each invocation global result-id to a type-id.
48		invocation_globals: std.AutoArrayHashMapUnmanaged(ResultId, InvocationGlobal),
	48	invocation_globals: std.array_hash_map.Auto(ResultId, InvocationGlobal),
49	49
50	50	/// Fetch the list of callees per function. Guaranteed to contain only unique IDs.
51	51	fn callees(self: ModuleInfo, fn_id: ResultId) []const ResultId {
...	...	@@ -342,9 +342,9 @@ const ModuleBuilder = struct {
342	342	entry_point_new_id_base: u32,
343	343	/// A set of all function types in the new program. SPIR-V mandates that these are unique,
344	344	/// and until a general type deduplication pass is programmed, we just handle it here via this.
345		function_types: std.ArrayHashMapUnmanaged(FunctionType, ResultId, FunctionType.Context, true) = .empty,
	345	function_types: std.array_hash_map.Custom(FunctionType, ResultId, FunctionType.Context, true) = .empty,
346	346	/// Maps functions to new information required for creating the module
347		function_new_info: std.AutoArrayHashMapUnmanaged(ResultId, FunctionNewInfo) = .empty,
	347	function_new_info: std.array_hash_map.Auto(ResultId, FunctionNewInfo) = .empty,
348	348	/// Offset of the functions section in the new binary.
349	349	new_functions_section: ?usize,
350	350

src/link/Wasm.zig+32-32

...	...	@@ -80,27 +80,27 @@ name: []const u8,
80	80	/// List of relocatable files to be linked into the final binary.
81	81	objects: std.ArrayList(Object) = .empty,
82	82
83		func_types: std.AutoArrayHashMapUnmanaged(FunctionType, void) = .empty,
	83	func_types: std.array_hash_map.Auto(FunctionType, void) = .empty,
84	84	/// Provides a mapping of both imports and provided functions to symbol name.
85	85	/// Local functions may be unnamed.
86	86	/// Key is symbol name, however the `FunctionImport` may have an name override for the import name.
87		object_function_imports: std.AutoArrayHashMapUnmanaged(String, FunctionImport) = .empty,
	87	object_function_imports: std.array_hash_map.Auto(String, FunctionImport) = .empty,
88	88	/// All functions for all objects.
89	89	object_functions: std.ArrayList(ObjectFunction) = .empty,
90	90
91	91	/// Provides a mapping of both imports and provided globals to symbol name.
92	92	/// Local globals may be unnamed.
93		object_global_imports: std.AutoArrayHashMapUnmanaged(String, GlobalImport) = .empty,
	93	object_global_imports: std.array_hash_map.Auto(String, GlobalImport) = .empty,
94	94	/// All globals for all objects.
95	95	object_globals: std.ArrayList(ObjectGlobal) = .empty,
96	96
97	97	/// All table imports for all objects.
98		object_table_imports: std.AutoArrayHashMapUnmanaged(String, TableImport) = .empty,
	98	object_table_imports: std.array_hash_map.Auto(String, TableImport) = .empty,
99	99	/// All parsed table sections for all objects.
100	100	object_tables: std.ArrayList(Table) = .empty,
101	101
102	102	/// All memory imports for all objects.
103		object_memory_imports: std.AutoArrayHashMapUnmanaged(String, MemoryImport) = .empty,
	103	object_memory_imports: std.array_hash_map.Auto(String, MemoryImport) = .empty,
104	104	/// All parsed memory sections for all objects.
105	105	object_memories: std.ArrayList(ObjectMemory) = .empty,
106	106
...	...	@@ -119,15 +119,15 @@ object_data_segments: std.ArrayList(ObjectDataSegment) = .empty,
119	119	/// Each segment has many data symbols, which correspond logically to global
120	120	/// constants.
121	121	object_datas: std.ArrayList(ObjectData) = .empty,
122		object_data_imports: std.AutoArrayHashMapUnmanaged(String, ObjectDataImport) = .empty,
	122	object_data_imports: std.array_hash_map.Auto(String, ObjectDataImport) = .empty,
123	123	/// Non-synthetic section that can essentially be mem-cpy'd into place after performing relocations.
124		object_custom_segments: std.AutoArrayHashMapUnmanaged(ObjectSectionIndex, CustomSegment) = .empty,
	124	object_custom_segments: std.array_hash_map.Auto(ObjectSectionIndex, CustomSegment) = .empty,
125	125
126	126	/// All comdat information for all objects.
127	127	object_comdats: std.ArrayList(Comdat) = .empty,
128	128	/// A table that maps the relocations to be performed where the key represents
129	129	/// the section (across all objects) that the slice of relocations applies to.
130		object_relocations_table: std.AutoArrayHashMapUnmanaged(ObjectSectionIndex, ObjectRelocation.Slice) = .empty,
	130	object_relocations_table: std.array_hash_map.Auto(ObjectSectionIndex, ObjectRelocation.Slice) = .empty,
131	131	/// Incremented across all objects in order to enable calculation of `ObjectSectionIndex` values.
132	132	object_total_sections: u32 = 0,
133	133	/// All comdat symbols from all objects concatenated.
...	...	@@ -150,7 +150,7 @@ nav_fixups: std.ArrayList(NavFixup) = .empty,
150	150	func_table_fixups: std.ArrayList(FuncTableFixup) = .empty,
151	151	/// Symbols to be emitted into an object file. Remains empty when not emitting
152	152	/// an object file.
153		symbol_table: std.AutoArrayHashMapUnmanaged(String, void) = .empty,
	153	symbol_table: std.array_hash_map.Auto(String, void) = .empty,
154	154
155	155	/// When importing objects from the host environment, a name must be supplied.
156	156	/// LLVM uses "env" by default when none is given.
...	...	@@ -174,24 +174,24 @@ preloaded_strings: PreloadedStrings,
174	174
175	175	/// This field is used when emitting an object; `navs_exe` used otherwise.
176	176	/// Does not include externs since that data lives elsewhere.
177		navs_obj: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, ZcuDataObj) = .empty,
	177	navs_obj: std.array_hash_map.Auto(InternPool.Nav.Index, ZcuDataObj) = .empty,
178	178	/// This field is unused when emitting an object; `navs_obj` used otherwise.
179	179	/// Does not include externs since that data lives elsewhere.
180		navs_exe: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, ZcuDataExe) = .empty,
	180	navs_exe: std.array_hash_map.Auto(InternPool.Nav.Index, ZcuDataExe) = .empty,
181	181	/// Tracks all InternPool values referenced by codegen. Needed for outputting
182	182	/// the data segment. This one does not track ref count because object files
183	183	/// require using max LEB encoding for these references anyway.
184		uavs_obj: std.AutoArrayHashMapUnmanaged(InternPool.Index, ZcuDataObj) = .empty,
	184	uavs_obj: std.array_hash_map.Auto(InternPool.Index, ZcuDataObj) = .empty,
185	185	/// Tracks ref count to optimize LEB encodings for UAV references.
186		uavs_exe: std.AutoArrayHashMapUnmanaged(InternPool.Index, ZcuDataExe) = .empty,
	186	uavs_exe: std.array_hash_map.Auto(InternPool.Index, ZcuDataExe) = .empty,
187	187	/// Sparse table of uavs that need to be emitted with greater alignment than
188	188	/// the default for the type.
189		overaligned_uavs: std.AutoArrayHashMapUnmanaged(InternPool.Index, Alignment) = .empty,
	189	overaligned_uavs: std.array_hash_map.Auto(InternPool.Index, Alignment) = .empty,
190	190	/// When the key is an enum type, this represents a `@tagName` function.
191		zcu_funcs: std.AutoArrayHashMapUnmanaged(InternPool.Index, ZcuFunc) = .empty,
192		nav_exports: std.AutoArrayHashMapUnmanaged(NavExport, Zcu.Export.Index) = .empty,
193		uav_exports: std.AutoArrayHashMapUnmanaged(UavExport, Zcu.Export.Index) = .empty,
194		imports: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty,
	191	zcu_funcs: std.array_hash_map.Auto(InternPool.Index, ZcuFunc) = .empty,
	192	nav_exports: std.array_hash_map.Auto(NavExport, Zcu.Export.Index) = .empty,
	193	uav_exports: std.array_hash_map.Auto(UavExport, Zcu.Export.Index) = .empty,
	194	imports: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty,
195	195
196	196	dwarf: ?Dwarf = null,
197	197
...	...	@@ -200,19 +200,19 @@ flush_buffer: Flush = .{},
200	200	/// Empty until `prelink`. There it is populated based on object files.
201	201	/// Next, it is copied into `Flush.missing_exports` just before `flush`
202	202	/// and that data is used during `flush`.
203		missing_exports: std.AutoArrayHashMapUnmanaged(String, void) = .empty,
	203	missing_exports: std.array_hash_map.Auto(String, void) = .empty,
204	204	entry_resolution: FunctionImport.Resolution = .unresolved,
205	205
206	206	/// Empty when outputting an object.
207		function_exports: std.AutoArrayHashMapUnmanaged(String, FunctionIndex) = .empty,
208		hidden_function_exports: std.AutoArrayHashMapUnmanaged(String, FunctionIndex) = .empty,
	207	function_exports: std.array_hash_map.Auto(String, FunctionIndex) = .empty,
	208	hidden_function_exports: std.array_hash_map.Auto(String, FunctionIndex) = .empty,
209	209	global_exports: std.ArrayList(GlobalExport) = .empty,
210	210	/// Tracks the value at the end of prelink.
211	211	global_exports_len: u32 = 0,
212	212
213	213	/// Ordered list of non-import functions that will appear in the final binary.
214	214	/// Empty until prelink.
215		functions: std.AutoArrayHashMapUnmanaged(FunctionImport.Resolution, void) = .empty,
	215	functions: std.array_hash_map.Auto(FunctionImport.Resolution, void) = .empty,
216	216	/// Tracks the value at the end of prelink, at which point `functions`
217	217	/// contains only object file functions, and nothing from the Zcu yet.
218	218	functions_end_prelink: u32 = 0,
...	...	@@ -230,7 +230,7 @@ data_imports_len_prelink: u32 = 0,
230	230	/// `flush` gets a copy of this table, and then Zcu exports are applied to
231	231	/// remove elements from the table, and the remainder are either undefined
232	232	/// symbol errors, or import section entries depending on the output mode.
233		function_imports: std.AutoArrayHashMapUnmanaged(String, FunctionImportId) = .empty,
	233	function_imports: std.array_hash_map.Auto(String, FunctionImportId) = .empty,
234	234
235	235	/// At the end of prelink, this is populated with data symbols needed by
236	236	/// objects.
...	...	@@ -243,29 +243,29 @@ function_imports: std.AutoArrayHashMapUnmanaged(String, FunctionImportId) = .emp
243	243	/// `flush` gets a copy of this table, and then Zcu exports are applied to
244	244	/// remove elements from the table, and the remainder are either undefined
245	245	/// symbol errors, or symbol table entries depending on the output mode.
246		data_imports: std.AutoArrayHashMapUnmanaged(String, DataImportId) = .empty,
	246	data_imports: std.array_hash_map.Auto(String, DataImportId) = .empty,
247	247	/// Set of data symbols that will appear in the final binary. Used to populate
248	248	/// `Flush.data_segments` before sorting.
249		data_segments: std.AutoArrayHashMapUnmanaged(DataSegmentId, void) = .empty,
	249	data_segments: std.array_hash_map.Auto(DataSegmentId, void) = .empty,
250	250
251	251	/// Ordered list of non-import globals that will appear in the final binary.
252	252	/// Empty until prelink.
253		globals: std.AutoArrayHashMapUnmanaged(GlobalImport.Resolution, void) = .empty,
	253	globals: std.array_hash_map.Auto(GlobalImport.Resolution, void) = .empty,
254	254	/// Tracks the value at the end of prelink, at which point `globals`
255	255	/// contains only object file globals, and nothing from the Zcu yet.
256	256	globals_end_prelink: u32 = 0,
257		global_imports: std.AutoArrayHashMapUnmanaged(String, GlobalImportId) = .empty,
	257	global_imports: std.array_hash_map.Auto(String, GlobalImportId) = .empty,
258	258
259	259	/// Ordered list of non-import tables that will appear in the final binary.
260	260	/// Empty until prelink.
261		tables: std.AutoArrayHashMapUnmanaged(TableImport.Resolution, void) = .empty,
262		table_imports: std.AutoArrayHashMapUnmanaged(String, TableImport.Index) = .empty,
	261	tables: std.array_hash_map.Auto(TableImport.Resolution, void) = .empty,
	262	table_imports: std.array_hash_map.Auto(String, TableImport.Index) = .empty,
263	263
264	264	/// All functions that have had their address taken and therefore might be
265	265	/// called via a `call_indirect` function.
266		zcu_indirect_function_set: std.AutoArrayHashMapUnmanaged(InternPool.Nav.Index, void) = .empty,
267		object_indirect_function_import_set: std.AutoArrayHashMapUnmanaged(String, void) = .empty,
268		object_indirect_function_set: std.AutoArrayHashMapUnmanaged(ObjectFunctionIndex, void) = .empty,
	266	zcu_indirect_function_set: std.array_hash_map.Auto(InternPool.Nav.Index, void) = .empty,
	267	object_indirect_function_import_set: std.array_hash_map.Auto(String, void) = .empty,
	268	object_indirect_function_set: std.array_hash_map.Auto(ObjectFunctionIndex, void) = .empty,
269	269
270	270	error_name_table_ref_count: u32 = 0,
271	271	tag_name_table_ref_count: u32 = 0,

src/link/Wasm/Archive.zig+1-1

...	...	@@ -12,7 +12,7 @@ toc: Toc,
12	12
13	13	/// Key points into `LazyArchive` `file_contents`.
14	14	/// Value is allocated with gpa.
15		const Toc = std.StringArrayHashMapUnmanaged(std.ArrayList(u32));
	15	const Toc = std.array_hash_map.String(std.ArrayList(u32));
16	16
17	17	const ARMAG = std.elf.ARMAG;
18	18	const ARFMAG = std.elf.ARFMAG;

src/link/Wasm/Flush.zig+7-7

...	...	@@ -24,22 +24,22 @@ const ArrayList = std.ArrayList;
24	24	/// Ordered list of data segments that will appear in the final binary.
25	25	/// When sorted, to-be-merged segments will be made adjacent.
26	26	/// Values are virtual address.
27		data_segments: std.AutoArrayHashMapUnmanaged(Wasm.DataSegmentId, u32) = .empty,
	27	data_segments: std.array_hash_map.Auto(Wasm.DataSegmentId, u32) = .empty,
28	28	/// Each time a `data_segment` offset equals zero it indicates a new group, and
29	29	/// the next element in this array will contain the total merged segment size.
30	30	/// Value is the virtual memory address of the end of the segment.
31	31	data_segment_groups: ArrayList(DataSegmentGroup) = .empty,
32	32
33	33	binary_bytes: ArrayList(u8) = .empty,
34		missing_exports: std.AutoArrayHashMapUnmanaged(String, void) = .empty,
35		function_imports: std.AutoArrayHashMapUnmanaged(String, Wasm.FunctionImportId) = .empty,
36		global_imports: std.AutoArrayHashMapUnmanaged(String, Wasm.GlobalImportId) = .empty,
37		data_imports: std.AutoArrayHashMapUnmanaged(String, Wasm.DataImportId) = .empty,
	34	missing_exports: std.array_hash_map.Auto(String, void) = .empty,
	35	function_imports: std.array_hash_map.Auto(String, Wasm.FunctionImportId) = .empty,
	36	global_imports: std.array_hash_map.Auto(String, Wasm.GlobalImportId) = .empty,
	37	data_imports: std.array_hash_map.Auto(String, Wasm.DataImportId) = .empty,
38	38
39		indirect_function_table: std.AutoArrayHashMapUnmanaged(Wasm.OutputFunctionIndex, void) = .empty,
	39	indirect_function_table: std.array_hash_map.Auto(Wasm.OutputFunctionIndex, void) = .empty,
40	40
41	41	/// A subset of the full interned function type list created only during flush.
42		func_types: std.AutoArrayHashMapUnmanaged(Wasm.FunctionType.Index, void) = .empty,
	42	func_types: std.array_hash_map.Auto(Wasm.FunctionType.Index, void) = .empty,
43	43
44	44	/// For debug purposes only.
45	45	memory_layout_finished: bool = false,

src/main.zig+7-7

...	...	@@ -987,7 +987,7 @@ fn buildOutputType(
987	987	var test_no_exec = false;
988	988	var test_execve = false;
989	989	var entry: Compilation.CreateOptions.Entry = .default;
990		var force_undefined_symbols: std.StringArrayHashMapUnmanaged(void) = .empty;
	990	var force_undefined_symbols: std.array_hash_map.String(void) = .empty;
991	991	var stack_size: ?u64 = null;
992	992	var image_base: ?u64 = null;
993	993	var link_eh_frame_hdr = false;
...	...	@@ -1024,7 +1024,7 @@ fn buildOutputType(
1024	1024	// These are before resolving sysroot.
1025	1025	var extra_cflags: std.ArrayList([]const u8) = .empty;
1026	1026	var extra_rcflags: std.ArrayList([]const u8) = .empty;
1027		var symbol_wrap_set: std.StringArrayHashMapUnmanaged(void) = .empty;
	1027	var symbol_wrap_set: std.array_hash_map.String(void) = .empty;
1028	1028	var rc_includes: std.zig.RcIncludes = .any;
1029	1029	var manifest_file: ?[]const u8 = null;
1030	1030	var linker_export_symbol_names: std.ArrayList([]const u8) = .empty;
...	...	@@ -3592,7 +3592,7 @@ fn buildOutputType(
3592	3592	defer file_system_inputs.deinit(gpa);
3593	3593
3594	3594	// Deduplicate rpath entries
3595		var rpath_dedup = std.StringArrayHashMapUnmanaged(void){};
	3595	var rpath_dedup = std.array_hash_map.String(void){};
3596	3596	for (create_module.rpath_list.items) \|rpath\| {
3597	3597	try rpath_dedup.put(arena, rpath, {});
3598	3598	}
...	...	@@ -3896,7 +3896,7 @@ fn buildOutputType(
3896	3896
3897	3897	const CreateModule = struct {
3898	3898	dirs: Compilation.Directories,
3899		modules: std.StringArrayHashMapUnmanaged(CliModule),
	3899	modules: std.array_hash_map.String(CliModule),
3900	3900	opts: Compilation.Config.Options,
3901	3901	dynamic_linker: ?[]const u8,
3902	3902	object_format: ?[]const u8,
...	...	@@ -3908,7 +3908,7 @@ const CreateModule = struct {
3908	3908	/// link_libcpp, and then the libraries are filtered into
3909	3909	/// `unresolved_link_inputs` and `windows_libs`.
3910	3910	cli_link_inputs: std.ArrayList(link.UnresolvedInput),
3911		windows_libs: std.StringArrayHashMapUnmanaged(void),
	3911	windows_libs: std.array_hash_map.String(void),
3912	3912	/// The local variable `unresolved_link_inputs` is fed into library
3913	3913	/// resolution, mutating the input array, and producing this data as
3914	3914	/// output. Allocated with gpa.
...	...	@@ -3926,7 +3926,7 @@ const CreateModule = struct {
3926	3926	lib_dir_args: std.ArrayList([]const u8),
3927	3927	libc_installation: ?LibCInstallation,
3928	3928	want_native_include_dirs: bool,
3929		frameworks: std.StringArrayHashMapUnmanaged(Framework),
	3929	frameworks: std.array_hash_map.String(Framework),
3930	3930	native_system_include_paths: []const []const u8,
3931	3931	framework_dirs: std.ArrayList([]const u8),
3932	3932	rpath_list: std.ArrayList([]const u8),
...	...	@@ -4419,7 +4419,7 @@ fn serveUpdateResults(s: Server, comp: Compilation) !void {
4419	4419
4420	4420	var file_name_bytes: std.ArrayList(u8) = .empty;
4421	4421	defer file_name_bytes.deinit(gpa);
4422		var files: std.AutoArrayHashMapUnmanaged(Zcu.File.Index, void) = .empty;
	4422	var files: std.array_hash_map.Auto(Zcu.File.Index, void) = .empty;
4423	4423	defer files.deinit(gpa);
4424	4424	var decl_data: std.ArrayList(u8) = .empty;
4425	4425	defer decl_data.deinit(gpa);

tools/dump-cov.zig+1-1

...	...	@@ -67,7 +67,7 @@ pub fn main(init: std.process.Init) !void {
67	67	try stdout.print("{any}\n", .{header.*});
68	68	const pcs = header.pcAddrs();
69	69
70		var indexed_pcs: std.AutoArrayHashMapUnmanaged(usize, void) = .empty;
	70	var indexed_pcs: std.array_hash_map.Auto(usize, void) = .empty;
71	71	try indexed_pcs.entries.resize(arena, pcs.len);
72	72	@memcpy(indexed_pcs.entries.items(.key), pcs);
73	73	try indexed_pcs.reIndex(arena);