Commit 80d7e260d78400b841f15e3350473650b87931a5 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-07-11 23:27:13+01:00
committer	GitHub <noreply@github.com> 2024-07-11 23:27:13+01:00
log	80d7e260d78400b841f15e3350473650b87931a5
tree	3035bae743da24cbe1d5046469fea0a5542a8829
parent	45be80364659332807b527670514332a4b835f84
parent	77810f288216ef3e35f3d0df4a04351297560a5e
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #20570 from jacobly0/fix-races

InternPool: fix more races blocking a separate codegen/linker thread

27 files changed, 1472 insertions(+), 1004 deletions(-)

src
- Air.zig
- Compilation.zig
- InternPool.zig
- Sema.zig
- Type.zig
- Value.zig
- Zcu.zig
- Zcu
  - PerThread.zig
- arch
  - aarch64
    CodeGen.zig
  - arm
    CodeGen.zig
  - riscv64
    CodeGen.zig
  - sparc64
    CodeGen.zig
  - wasm
    CodeGen.zig
  - x86_64
    CodeGen.zig
- codegen.zig
- codegen
- link
  - Coff.zig
  - Dwarf.zig
  - Elf
    ZigObject.zig
  - MachO
    ZigObject.zig
  - Plan9.zig
  - SpirV.zig
  - Wasm
    ZigObject.zig
- print_air.zig
- print_value.zig

src/Air.zig+6-1

 @@ -1034,7 +1034,12 @@ pub const Inst = struct {
         ty: Type,
         arg: struct {
             ty: Ref,
-            src_index: u32,
+            /// Index into `extra` of a null-terminated string representing the parameter name.
+            /// This is `.none` if debug info is stripped.
+            name: enum(u32) {
+                none = std.math.maxInt(u32),
+                _,
+            },
         },
         ty_op: struct {
             ty: Ref,

src/Compilation.zig+51-78

 @@ -1877,6 +1877,7 @@ pub fn destroy(comp: *Compilation) void {
     if (comp.module) |zcu| zcu.deinit();
     comp.cache_use.deinit();
     comp.work_queue.deinit();
+    if (!InternPool.single_threaded) comp.codegen_work.queue.deinit();
     comp.c_object_work_queue.deinit();
     if (!build_options.only_core_functionality) {
         comp.win32_resource_work_queue.deinit();
 @@ -2119,12 +2120,14 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
     }
     if (comp.module) |zcu| {
+        const pt: Zcu.PerThread = .{ .zcu = zcu, .tid = .main };
         zcu.compile_log_text.shrinkAndFree(gpa, 0);
         // Make sure std.zig is inside the import_table. We unconditionally need
         // it for start.zig.
         const std_mod = zcu.std_mod;
-        _ = try zcu.importPkg(std_mod);
+        _ = try pt.importPkg(std_mod);
         // Normally we rely on importing std to in turn import the root source file
         // in the start code, but when using the stage1 backend that won't happen,
 @@ -2133,20 +2136,19 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
         // Likewise, in the case of `zig test`, the test runner is the root source file,
         // and so there is nothing to import the main file.
         if (comp.config.is_test) {
-            _ = try zcu.importPkg(zcu.main_mod);
+            _ = try pt.importPkg(zcu.main_mod);
         }
         if (zcu.root_mod.deps.get("compiler_rt")) |compiler_rt_mod| {
-            _ = try zcu.importPkg(compiler_rt_mod);
+            _ = try pt.importPkg(compiler_rt_mod);
         }
         // Put a work item in for every known source file to detect if
         // it changed, and, if so, re-compute ZIR and then queue the job
         // to update it.
         try comp.astgen_work_queue.ensureUnusedCapacity(zcu.import_table.count());
-        for (zcu.import_table.values(), 0..) |file, file_index_usize| {
+        for (zcu.import_table.values()) |file_index| {
-            const file_index: Zcu.File.Index = @enumFromInt(file_index_usize);
+            if (zcu.fileByIndex(file_index).mod.isBuiltin()) continue;
-            if (file.mod.isBuiltin()) continue;
             comp.astgen_work_queue.writeItemAssumeCapacity(file_index);
         }
 @@ -2641,7 +2643,8 @@ fn resolveEmitLoc(
     return slice.ptr;
 }
-fn reportMultiModuleErrors(zcu: *Zcu) !void {
+fn reportMultiModuleErrors(pt: Zcu.PerThread) !void {
+    const zcu = pt.zcu;
     const gpa = zcu.gpa;
     const ip = &zcu.intern_pool;
     // Some cases can give you a whole bunch of multi-module errors, which it's not helpful to
 @@ -2651,14 +2654,13 @@ fn reportMultiModuleErrors(zcu: *Zcu) !void {
     // Attach the "some omitted" note to the final error message
     var last_err: ?*Zcu.ErrorMsg = null;
-    for (zcu.import_table.values(), 0..) |file, file_index_usize| {
+    for (zcu.import_table.values()) |file_index| {
+        const file = zcu.fileByIndex(file_index);
         if (!file.multi_pkg) continue;
         num_errors += 1;
         if (num_errors > max_errors) continue;
-        const file_index: Zcu.File.Index = @enumFromInt(file_index_usize);
         const err = err_blk: {
             // Like with errors, let's cap the number of notes to prevent a huge error spew.
             const max_notes = 5;
 @@ -2674,7 +2676,10 @@ fn reportMultiModuleErrors(zcu: *Zcu) !void {
                     .import => |import| try Zcu.ErrorMsg.init(
                         gpa,
                         .{
-                            .base_node_inst = try ip.trackZir(gpa, import.file, .main_struct_inst),
+                            .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                                .file = import.file,
+                                .inst = .main_struct_inst,
+                            }),
                             .offset = .{ .token_abs = import.token },
                         },
                         "imported from module {s}",
 @@ -2683,7 +2688,10 @@ fn reportMultiModuleErrors(zcu: *Zcu) !void {
                     .root => |pkg| try Zcu.ErrorMsg.init(
                         gpa,
                         .{
-                            .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
+                            .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                                .file = file_index,
+                                .inst = .main_struct_inst,
+                            }),
                             .offset = .entire_file,
                         },
                         "root of module {s}",
 @@ -2697,7 +2705,10 @@ fn reportMultiModuleErrors(zcu: *Zcu) !void {
                 notes[num_notes] = try Zcu.ErrorMsg.init(
                     gpa,
                     .{
-                        .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
+                        .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                            .file = file_index,
+                            .inst = .main_struct_inst,
+                        }),
                         .offset = .entire_file,
                     },
                     "{} more references omitted",
 @@ -2709,7 +2720,10 @@ fn reportMultiModuleErrors(zcu: *Zcu) !void {
             const err = try Zcu.ErrorMsg.create(
                 gpa,
                 .{
-                    .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
+                    .base_node_inst = try ip.trackZir(gpa, pt.tid, .{
+                        .file = file_index,
+                        .inst = .main_struct_inst,
+                    }),
                     .offset = .entire_file,
                 },
                 "file exists in multiple modules",
 @@ -2749,8 +2763,9 @@ fn reportMultiModuleErrors(zcu: *Zcu) !void {
     // to add this flag after reporting the errors however, as otherwise
     // we'd get an error for every single downstream file, which wouldn't be
     // very useful.
-    for (zcu.import_table.values()) |file| {
+    for (zcu.import_table.values()) |file_index| {
-        if (file.multi_pkg) file.recursiveMarkMultiPkg(zcu);
+        const file = zcu.fileByIndex(file_index);
+        if (file.multi_pkg) file.recursiveMarkMultiPkg(pt);
     }
 }
 @@ -2774,7 +2789,7 @@ const Header = extern struct {
         //extra_len: u32,
         //limbs_len: u32,
         //string_bytes_len: u32,
-        tracked_insts_len: u32,
+        //tracked_insts_len: u32,
         src_hash_deps_len: u32,
         decl_val_deps_len: u32,
         namespace_deps_len: u32,
 @@ -2782,7 +2797,7 @@ const Header = extern struct {
         first_dependency_len: u32,
         dep_entries_len: u32,
         free_dep_entries_len: u32,
-        files_len: u32,
+        //files_len: u32,
     },
 };
 @@ -2803,7 +2818,7 @@ pub fn saveState(comp: *Compilation) !void {
                 //.extra_len = @intCast(ip.extra.items.len),
                 //.limbs_len = @intCast(ip.limbs.items.len),
                 //.string_bytes_len = @intCast(ip.string_bytes.items.len),
-                .tracked_insts_len = @intCast(ip.tracked_insts.count()),
+                //.tracked_insts_len = @intCast(ip.tracked_insts.count()),
                 .src_hash_deps_len = @intCast(ip.src_hash_deps.count()),
                 .decl_val_deps_len = @intCast(ip.decl_val_deps.count()),
                 .namespace_deps_len = @intCast(ip.namespace_deps.count()),
 @@ -2811,7 +2826,7 @@ pub fn saveState(comp: *Compilation) !void {
                 .first_dependency_len = @intCast(ip.first_dependency.count()),
                 .dep_entries_len = @intCast(ip.dep_entries.items.len),
                 .free_dep_entries_len = @intCast(ip.free_dep_entries.items.len),
-                .files_len = @intCast(ip.files.entries.len),
+                //.files_len = @intCast(ip.files.entries.len),
             },
         };
         addBuf(&bufs_list, &bufs_len, mem.asBytes(&header));
 @@ -2820,7 +2835,7 @@ pub fn saveState(comp: *Compilation) !void {
         //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.items.items(.data)));
         //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.items.items(.tag)));
         //addBuf(&bufs_list, &bufs_len, ip.string_bytes.items);
-        addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.tracked_insts.keys()));
+        //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.tracked_insts.keys()));
         addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.src_hash_deps.keys()));
         addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.src_hash_deps.values()));
 @@ -2836,8 +2851,8 @@ pub fn saveState(comp: *Compilation) !void {
         addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.dep_entries.items));
         addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.free_dep_entries.items));
-        addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.files.keys()));
+        //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.files.keys()));
-        addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.files.values()));
+        //addBuf(&bufs_list, &bufs_len, mem.sliceAsBytes(ip.files.values()));
         // TODO: compilation errors
         // TODO: namespaces
 @@ -2929,7 +2944,7 @@ pub fn totalErrorCount(comp: *Compilation) u32 {
             }
         }
-        if (zcu.global_error_set.entries.len - 1 > zcu.error_limit) {
+        if (zcu.intern_pool.global_error_set.mutate.list.len > zcu.error_limit) {
             total += 1;
         }
     }
 @@ -3058,7 +3073,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) !ErrorBundle {
             try addModuleErrorMsg(zcu, &bundle, value.*, &all_references);
         }
-        const actual_error_count = zcu.global_error_set.entries.len - 1;
+        const actual_error_count = zcu.intern_pool.global_error_set.mutate.list.len;
         if (actual_error_count > zcu.error_limit) {
             try bundle.addRootErrorMessage(.{
                 .msg = try bundle.printString("ZCU used more errors than possible: used {d}, max {d}", .{
 @@ -3443,11 +3458,12 @@ fn performAllTheWorkInner(
         }
     }
-    if (comp.module) |mod| {
+    if (comp.module) |zcu| {
-        try reportMultiModuleErrors(mod);
+        const pt: Zcu.PerThread = .{ .zcu = comp.module.?, .tid = .main };
-        try mod.flushRetryableFailures();
+        try reportMultiModuleErrors(pt);
-        mod.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
+        try zcu.flushRetryableFailures();
-        mod.codegen_prog_node = main_progress_node.start("Code Generation", 0);
+        zcu.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
+        zcu.codegen_prog_node = main_progress_node.start("Code Generation", 0);
     }
     if (!InternPool.single_threaded) comp.thread_pool.spawnWgId(&comp.work_queue_wait_group, codegenThread, .{comp});
 @@ -4131,14 +4147,6 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) anye
     };
 }
-const AstGenSrc = union(enum) {
-    root,
-    import: struct {
-        importing_file: Zcu.File.Index,
-        import_tok: std.zig.Ast.TokenIndex,
-    },
-};
 fn workerAstGenFile(
     tid: usize,
     comp: *Compilation,
 @@ -4148,7 +4156,7 @@ fn workerAstGenFile(
     root_decl: Zcu.Decl.OptionalIndex,
     prog_node: std.Progress.Node,
     wg: *WaitGroup,
-    src: AstGenSrc,
+    src: Zcu.AstGenSrc,
 ) void {
     const child_prog_node = prog_node.start(file.sub_file_path, 0);
     defer child_prog_node.end();
 @@ -4158,7 +4166,7 @@ fn workerAstGenFile(
         error.AnalysisFail => return,
         else => {
             file.status = .retryable_failure;
-            comp.reportRetryableAstGenError(src, file_index, err) catch |oom| switch (oom) {
+            pt.reportRetryableAstGenError(src, file_index, err) catch |oom| switch (oom) {
                 // Swallowing this error is OK because it's implied to be OOM when
                 // there is a missing `failed_files` error message.
                 error.OutOfMemory => {},
 @@ -4189,9 +4197,9 @@ fn workerAstGenFile(
                 comp.mutex.lock();
                 defer comp.mutex.unlock();
-                const res = pt.zcu.importFile(file, import_path) catch continue;
+                const res = pt.importFile(file, import_path) catch continue;
                 if (!res.is_pkg) {
-                    res.file.addReference(pt.zcu.*, .{ .import = .{
+                    res.file.addReference(pt.zcu, .{ .import = .{
                         .file = file_index,
                         .token = item.data.token,
                     } }) catch continue;
 @@ -4204,7 +4212,7 @@ fn workerAstGenFile(
                 log.debug("AstGen of {s} has import '{s}'; queuing AstGen of {s}", .{
                     file.sub_file_path, import_path, import_result.file.sub_file_path,
                 });
-                const sub_src: AstGenSrc = .{ .import = .{
+                const sub_src: Zcu.AstGenSrc = .{ .import = .{
                     .importing_file = file_index,
                     .import_tok = item.data.token,
                 } };
 @@ -4557,41 +4565,6 @@ fn reportRetryableWin32ResourceError(
     }
 }
-fn reportRetryableAstGenError(
-    comp: *Compilation,
-    src: AstGenSrc,
-    file_index: Zcu.File.Index,
-    err: anyerror,
-) error{OutOfMemory}!void {
-    const zcu = comp.module.?;
-    const gpa = zcu.gpa;
-    const file = zcu.fileByIndex(file_index);
-    file.status = .retryable_failure;
-    const src_loc: Zcu.LazySrcLoc = switch (src) {
-        .root => .{
-            .base_node_inst = try zcu.intern_pool.trackZir(gpa, file_index, .main_struct_inst),
-            .offset = .entire_file,
-        },
-        .import => |info| .{
-            .base_node_inst = try zcu.intern_pool.trackZir(gpa, info.importing_file, .main_struct_inst),
-            .offset = .{ .token_abs = info.import_tok },
-        },
-    };
-    const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
-        file.mod.root, file.sub_file_path, @errorName(err),
-    });
-    errdefer err_msg.destroy(gpa);
-    {
-        comp.mutex.lock();
-        defer comp.mutex.unlock();
-        try zcu.failed_files.putNoClobber(gpa, file, err_msg);
-    }
-}
 fn reportRetryableEmbedFileError(
     comp: *Compilation,
     embed_file: *Zcu.EmbedFile,

src/InternPool.zig+649-220

 @@ -1,12 +1,13 @@
 //! All interned objects have both a value and a type.
-//! This data structure is self-contained, with the following exceptions:
+//! This data structure is self-contained.
-//! * Module.Namespace has a pointer to Module.File
 /// One item per thread, indexed by `tid`, which is dense and unique per thread.
 locals: []Local = &.{},
 /// Length must be a power of two and represents the number of simultaneous
 /// writers that can mutate any single sharded data structure.
 shards: []Shard = &.{},
+/// Key is the error name, index is the error tag value. Index 0 has a length-0 string.
+global_error_set: GlobalErrorSet = GlobalErrorSet.empty,
 /// Cached number of active bits in a `tid`.
 tid_width: if (single_threaded) u0 else std.math.Log2Int(u32) = 0,
 /// Cached shift amount to put a `tid` in the top bits of a 31-bit value.
 @@ -14,17 +15,6 @@ tid_shift_31: if (single_threaded) u0 else std.math.Log2Int(u32) = if (single_th
 /// Cached shift amount to put a `tid` in the top bits of a 32-bit value.
 tid_shift_32: if (single_threaded) u0 else std.math.Log2Int(u32) = if (single_threaded) 0 else 31,
-/// Some types such as enums, structs, and unions need to store mappings from field names
-/// to field index, or value to field index. In such cases, they will store the underlying
-/// field names and values directly, relying on one of these maps, stored separately,
-/// to provide lookup.
-/// These are not serialized; it is computed upon deserialization.
-maps: std.ArrayListUnmanaged(FieldMap) = .{},
-/// An index into `tracked_insts` gives a reference to a single ZIR instruction which
-/// persists across incremental updates.
-tracked_insts: std.AutoArrayHashMapUnmanaged(TrackedInst, void) = .{},
 /// Dependencies on the source code hash associated with a ZIR instruction.
 /// * For a `declaration`, this is the entire declaration body.
 /// * For a `struct_decl`, `union_decl`, etc, this is the source of the fields (but not declarations).
 @@ -60,17 +50,6 @@ dep_entries: std.ArrayListUnmanaged(DepEntry) = .{},
 /// garbage collection pass.
 free_dep_entries: std.ArrayListUnmanaged(DepEntry.Index) = .{},
-/// Elements are ordered identically to the `import_table` field of `Zcu`.
-///
-/// Unlike `import_table`, this data is serialized as part of incremental
-/// compilation state.
-///
-/// Key is the hash of the path to this file, used to store
-/// `InternPool.TrackedInst`.
-///
-/// Value is the `Decl` of the struct that represents this `File`.
-files: std.AutoArrayHashMapUnmanaged(Cache.BinDigest, OptionalDeclIndex) = .{},
 /// Whether a multi-threaded intern pool is useful.
 /// Currently `false` until the intern pool is actually accessed
 /// from multiple threads to reduce the cost of this data structure.
 @@ -79,10 +58,6 @@ const want_multi_threaded = false;
 /// Whether a single-threaded intern pool impl is in use.
 pub const single_threaded = builtin.single_threaded or !want_multi_threaded;
-pub const FileIndex = enum(u32) {
-    _,
-};
 pub const TrackedInst = extern struct {
     file: FileIndex,
     inst: Zir.Inst.Index,
 @@ -92,12 +67,15 @@ pub const TrackedInst = extern struct {
     }
     pub const Index = enum(u32) {
         _,
-        pub fn resolveFull(i: TrackedInst.Index, ip: *const InternPool) TrackedInst {
+        pub fn resolveFull(tracked_inst_index: TrackedInst.Index, ip: *const InternPool) TrackedInst {
-            return ip.tracked_insts.keys()[@intFromEnum(i)];
+            const tracked_inst_unwrapped = tracked_inst_index.unwrap(ip);
+            const tracked_insts = ip.getLocalShared(tracked_inst_unwrapped.tid).tracked_insts.acquire();
+            return tracked_insts.view().items(.@"0")[tracked_inst_unwrapped.index];
         }
         pub fn resolve(i: TrackedInst.Index, ip: *const InternPool) Zir.Inst.Index {
             return i.resolveFull(ip).inst;
         }
         pub fn toOptional(i: TrackedInst.Index) Optional {
             return @enumFromInt(@intFromEnum(i));
         }
 @@ -111,21 +89,124 @@ pub const TrackedInst = extern struct {
                 };
             }
         };
+        pub const Unwrapped = struct {
+            tid: Zcu.PerThread.Id,
+            index: u32,
+            pub fn wrap(unwrapped: Unwrapped, ip: *const InternPool) TrackedInst.Index {
+                assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask());
+                assert(unwrapped.index <= ip.getIndexMask(u32));
+                return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 |
+                    unwrapped.index);
+            }
+        };
+        pub fn unwrap(tracked_inst_index: TrackedInst.Index, ip: *const InternPool) Unwrapped {
+            return .{
+                .tid = @enumFromInt(@intFromEnum(tracked_inst_index) >> ip.tid_shift_32 & ip.getTidMask()),
+                .index = @intFromEnum(tracked_inst_index) & ip.getIndexMask(u32),
+            };
+        }
     };
 };
 pub fn trackZir(
     ip: *InternPool,
     gpa: Allocator,
-    file: FileIndex,
+    tid: Zcu.PerThread.Id,
-    inst: Zir.Inst.Index,
+    key: TrackedInst,
 ) Allocator.Error!TrackedInst.Index {
-    const key: TrackedInst = .{
+    const full_hash = Hash.hash(0, std.mem.asBytes(&key));
-        .file = file,
+    const hash: u32 = @truncate(full_hash >> 32);
-        .inst = inst,
+    const shard = &ip.shards[@intCast(full_hash & (ip.shards.len - 1))];
-    };
+    var map = shard.shared.tracked_inst_map.acquire();
-    const gop = try ip.tracked_insts.getOrPut(gpa, key);
+    const Map = @TypeOf(map);
-    return @enumFromInt(gop.index);
+    var map_mask = map.header().mask();
+    var map_index = hash;
+    while (true) : (map_index += 1) {
+        map_index &= map_mask;
+        const entry = &map.entries[map_index];
+        const index = entry.acquire().unwrap() orelse break;
+        if (entry.hash != hash) continue;
+        if (std.meta.eql(index.resolveFull(ip), key)) return index;
+    }
+    shard.mutate.tracked_inst_map.mutex.lock();
+    defer shard.mutate.tracked_inst_map.mutex.unlock();
+    if (map.entries != shard.shared.tracked_inst_map.entries) {
+        shard.mutate.tracked_inst_map.len += 1;
+        map = shard.shared.tracked_inst_map;
+        map_mask = map.header().mask();
+        map_index = hash;
+    }
+    while (true) : (map_index += 1) {
+        map_index &= map_mask;
+        const entry = &map.entries[map_index];
+        const index = entry.acquire().unwrap() orelse break;
+        if (entry.hash != hash) continue;
+        if (std.meta.eql(index.resolveFull(ip), key)) return index;
+    }
+    defer shard.mutate.tracked_inst_map.len += 1;
+    const local = ip.getLocal(tid);
+    local.mutate.tracked_insts.mutex.lock();
+    defer local.mutate.tracked_insts.mutex.unlock();
+    const list = local.getMutableTrackedInsts(gpa);
+    try list.ensureUnusedCapacity(1);
+    const map_header = map.header().*;
+    if (shard.mutate.tracked_inst_map.len < map_header.capacity * 3 / 5) {
+        const entry = &map.entries[map_index];
+        entry.hash = hash;
+        const index = (TrackedInst.Index.Unwrapped{
+            .tid = tid,
+            .index = list.mutate.len,
+        }).wrap(ip);
+        list.appendAssumeCapacity(.{key});
+        entry.release(index.toOptional());
+        return index;
+    }
+    const arena_state = &local.mutate.arena;
+    var arena = arena_state.promote(gpa);
+    defer arena_state.* = arena.state;
+    const new_map_capacity = map_header.capacity * 2;
+    const new_map_buf = try arena.allocator().alignedAlloc(
+        u8,
+        Map.alignment,
+        Map.entries_offset + new_map_capacity * @sizeOf(Map.Entry),
+    );
+    const new_map: Map = .{ .entries = @ptrCast(new_map_buf[Map.entries_offset..].ptr) };
+    new_map.header().* = .{ .capacity = new_map_capacity };
+    @memset(new_map.entries[0..new_map_capacity], .{ .value = .none, .hash = undefined });
+    const new_map_mask = new_map.header().mask();
+    map_index = 0;
+    while (map_index < map_header.capacity) : (map_index += 1) {
+        const entry = &map.entries[map_index];
+        const index = entry.value.unwrap() orelse continue;
+        const item_hash = entry.hash;
+        var new_map_index = item_hash;
+        while (true) : (new_map_index += 1) {
+            new_map_index &= new_map_mask;
+            const new_entry = &new_map.entries[new_map_index];
+            if (new_entry.value != .none) continue;
+            new_entry.* = .{
+                .value = index.toOptional(),
+                .hash = item_hash,
+            };
+            break;
+        }
+    }
+    map = new_map;
+    map_index = hash;
+    while (true) : (map_index += 1) {
+        map_index &= new_map_mask;
+        if (map.entries[map_index].value == .none) break;
+    }
+    const index = (TrackedInst.Index.Unwrapped{
+        .tid = tid,
+        .index = list.mutate.len,
+    }).wrap(ip);
+    list.appendAssumeCapacity(.{key});
+    map.entries[map_index] = .{ .value = index.toOptional(), .hash = hash };
+    shard.shared.tracked_inst_map.release(new_map);
+    return index;
 }
 /// Analysis Unit. Represents a single entity which undergoes semantic analysis.
 @@ -337,9 +418,12 @@ const Local = struct {
         arena: std.heap.ArenaAllocator.State,
         items: ListMutate,
-        extra: ListMutate,
+        extra: MutexListMutate,
         limbs: ListMutate,
         strings: ListMutate,
+        tracked_insts: MutexListMutate,
+        files: ListMutate,
+        maps: ListMutate,
         decls: BucketListMutate,
         namespaces: BucketListMutate,
 @@ -350,6 +434,9 @@ const Local = struct {
         extra: Extra,
         limbs: Limbs,
         strings: Strings,
+        tracked_insts: TrackedInsts,
+        files: List(File),
+        maps: Maps,
         decls: Decls,
         namespaces: Namespaces,
 @@ -370,16 +457,18 @@ const Local = struct {
         else => @compileError("unsupported host"),
     };
     const Strings = List(struct { u8 });
+    const TrackedInsts = List(struct { TrackedInst });
+    const Maps = List(struct { FieldMap });
     const decls_bucket_width = 8;
     const decls_bucket_mask = (1 << decls_bucket_width) - 1;
     const decl_next_free_field = "src_namespace";
-    const Decls = List(struct { *[1 << decls_bucket_width]Module.Decl });
+    const Decls = List(struct { *[1 << decls_bucket_width]Zcu.Decl });
     const namespaces_bucket_width = 8;
     const namespaces_bucket_mask = (1 << namespaces_bucket_width) - 1;
     const namespace_next_free_field = "decl_index";
-    const Namespaces = List(struct { *[1 << namespaces_bucket_width]Module.Namespace });
+    const Namespaces = List(struct { *[1 << namespaces_bucket_width]Zcu.Namespace });
     const ListMutate = struct {
         len: u32,
 @@ -389,6 +478,16 @@ const Local = struct {
         };
     };
+    const MutexListMutate = struct {
+        mutex: std.Thread.Mutex,
+        list: ListMutate,
+        const empty: MutexListMutate = .{
+            .mutex = .{},
+            .list = ListMutate.empty,
+        };
+    };
     const BucketListMutate = struct {
         last_bucket_len: u32,
         buckets_list: ListMutate,
 @@ -410,7 +509,7 @@ const Local = struct {
             const ListSelf = @This();
             const Mutable = struct {
-                gpa: std.mem.Allocator,
+                gpa: Allocator,
                 arena: *std.heap.ArenaAllocator.State,
                 mutate: *ListMutate,
                 list: *ListSelf,
 @@ -435,14 +534,17 @@ const Local = struct {
                         .is_tuple = elem_info.is_tuple,
                     } });
                 }
-                fn SliceElem(comptime opts: struct { is_const: bool = false }) type {
+                fn PtrElem(comptime opts: struct {
+                    size: std.builtin.Type.Pointer.Size,
+                    is_const: bool = false,
+                }) type {
                     const elem_info = @typeInfo(Elem).Struct;
                     const elem_fields = elem_info.fields;
                     var new_fields: [elem_fields.len]std.builtin.Type.StructField = undefined;
                     for (&new_fields, elem_fields) |*new_field, elem_field| new_field.* = .{
                         .name = elem_field.name,
                         .type = @Type(.{ .Pointer = .{
-                            .size = .Slice,
+                            .size = opts.size,
                             .is_const = opts.is_const,
                             .is_volatile = false,
                             .alignment = 0,
 @@ -463,6 +565,23 @@ const Local = struct {
                     } });
                 }
+                pub fn addOne(mutable: Mutable) Allocator.Error!PtrElem(.{ .size = .One }) {
+                    try mutable.ensureUnusedCapacity(1);
+                    return mutable.addOneAssumeCapacity();
+                }
+                pub fn addOneAssumeCapacity(mutable: Mutable) PtrElem(.{ .size = .One }) {
+                    const index = mutable.mutate.len;
+                    assert(index < mutable.list.header().capacity);
+                    mutable.mutate.len = index + 1;
+                    const mutable_view = mutable.view().slice();
+                    var ptr: PtrElem(.{ .size = .One }) = undefined;
+                    inline for (fields) |field| {
+                        @field(ptr, @tagName(field)) = &mutable_view.items(field)[index];
+                    }
+                    return ptr;
+                }
                 pub fn append(mutable: Mutable, elem: Elem) Allocator.Error!void {
                     try mutable.ensureUnusedCapacity(1);
                     mutable.appendAssumeCapacity(elem);
 @@ -476,14 +595,14 @@ const Local = struct {
                 pub fn appendSliceAssumeCapacity(
                     mutable: Mutable,
-                    slice: SliceElem(.{ .is_const = true }),
+                    slice: PtrElem(.{ .size = .Slice, .is_const = true }),
                 ) void {
                     if (fields.len == 0) return;
                     const start = mutable.mutate.len;
                     const slice_len = @field(slice, @tagName(fields[0])).len;
                     assert(slice_len <= mutable.list.header().capacity - start);
                     mutable.mutate.len = @intCast(start + slice_len);
-                    const mutable_view = mutable.view();
+                    const mutable_view = mutable.view().slice();
                     inline for (fields) |field| {
                         const field_slice = @field(slice, @tagName(field));
                         assert(field_slice.len == slice_len);
 @@ -500,7 +619,7 @@ const Local = struct {
                     const start = mutable.mutate.len;
                     assert(len <= mutable.list.header().capacity - start);
                     mutable.mutate.len = @intCast(start + len);
-                    const mutable_view = mutable.view();
+                    const mutable_view = mutable.view().slice();
                     inline for (fields) |field| {
                         @memset(mutable_view.items(field)[start..][0..len], @field(elem, @tagName(field)));
                     }
 @@ -515,7 +634,7 @@ const Local = struct {
                     const start = mutable.mutate.len;
                     assert(len <= mutable.list.header().capacity - start);
                     mutable.mutate.len = @intCast(start + len);
-                    const mutable_view = mutable.view();
+                    const mutable_view = mutable.view().slice();
                     var ptr_array: PtrArrayElem(len) = undefined;
                     inline for (fields) |field| {
                         @field(ptr_array, @tagName(field)) = mutable_view.items(field)[start..][0..len];
 @@ -523,17 +642,17 @@ const Local = struct {
                     return ptr_array;
                 }
-                pub fn addManyAsSlice(mutable: Mutable, len: usize) Allocator.Error!SliceElem(.{}) {
+                pub fn addManyAsSlice(mutable: Mutable, len: usize) Allocator.Error!PtrElem(.{ .size = .Slice }) {
                     try mutable.ensureUnusedCapacity(len);
                     return mutable.addManyAsSliceAssumeCapacity(len);
                 }
-                pub fn addManyAsSliceAssumeCapacity(mutable: Mutable, len: usize) SliceElem(.{}) {
+                pub fn addManyAsSliceAssumeCapacity(mutable: Mutable, len: usize) PtrElem(.{ .size = .Slice }) {
                     const start = mutable.mutate.len;
                     assert(len <= mutable.list.header().capacity - start);
                     mutable.mutate.len = @intCast(start + len);
-                    const mutable_view = mutable.view();
+                    const mutable_view = mutable.view().slice();
-                    var slice: SliceElem(.{}) = undefined;
+                    var slice: PtrElem(.{ .size = .Slice }) = undefined;
                     inline for (fields) |field| {
                         @field(slice, @tagName(field)) = mutable_view.items(field)[start..][0..len];
                     }
 @@ -578,7 +697,7 @@ const Local = struct {
                     mutable.list.release(new_list);
                 }
-                fn view(mutable: Mutable) View {
+                pub fn view(mutable: Mutable) View {
                     const capacity = mutable.list.header().capacity;
                     assert(capacity > 0); // optimizes `MultiArrayList.Slice.items`
                     return .{
 @@ -602,7 +721,7 @@ const Local = struct {
             const View = std.MultiArrayList(Elem);
             /// Must be called when accessing from another thread.
-            fn acquire(list: *const ListSelf) ListSelf {
+            pub fn acquire(list: *const ListSelf) ListSelf {
                 return .{ .bytes = @atomicLoad([*]align(@alignOf(Elem)) u8, &list.bytes, .acquire) };
             }
             fn release(list: *ListSelf, new_list: ListSelf) void {
 @@ -616,7 +735,7 @@ const Local = struct {
                 return @ptrFromInt(@intFromPtr(list.bytes) - bytes_offset);
             }
-            fn view(list: ListSelf) View {
+            pub fn view(list: ListSelf) View {
                 const capacity = list.header().capacity;
                 assert(capacity > 0); // optimizes `MultiArrayList.Slice.items`
                 return .{
 @@ -628,7 +747,7 @@ const Local = struct {
         };
     }
-    pub fn getMutableItems(local: *Local, gpa: std.mem.Allocator) List(Item).Mutable {
+    pub fn getMutableItems(local: *Local, gpa: Allocator) List(Item).Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -637,11 +756,11 @@ const Local = struct {
         };
     }
-    pub fn getMutableExtra(local: *Local, gpa: std.mem.Allocator) Extra.Mutable {
+    pub fn getMutableExtra(local: *Local, gpa: Allocator) Extra.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
-            .mutate = &local.mutate.extra,
+            .mutate = &local.mutate.extra.list,
             .list = &local.shared.extra,
         };
     }
 @@ -650,7 +769,7 @@ const Local = struct {
     /// On 64-bit systems, this array is used for big integers and associated metadata.
     /// Use the helper methods instead of accessing this directly in order to not
     /// violate the above mechanism.
-    pub fn getMutableLimbs(local: *Local, gpa: std.mem.Allocator) Limbs.Mutable {
+    pub fn getMutableLimbs(local: *Local, gpa: Allocator) Limbs.Mutable {
         return switch (@sizeOf(Limb)) {
             @sizeOf(u32) => local.getMutableExtra(gpa),
             @sizeOf(u64) => .{
 @@ -668,7 +787,7 @@ const Local = struct {
     /// is referencing the data here whether they want to store both index and length,
     /// thus allowing null bytes, or store only index, and use null-termination. The
     /// `strings` array is agnostic to either usage.
-    pub fn getMutableStrings(local: *Local, gpa: std.mem.Allocator) Strings.Mutable {
+    pub fn getMutableStrings(local: *Local, gpa: Allocator) Strings.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -677,6 +796,49 @@ const Local = struct {
         };
     }
+    /// An index into `tracked_insts` gives a reference to a single ZIR instruction which
+    /// persists across incremental updates.
+    pub fn getMutableTrackedInsts(local: *Local, gpa: Allocator) TrackedInsts.Mutable {
+        return .{
+            .gpa = gpa,
+            .arena = &local.mutate.arena,
+            .mutate = &local.mutate.tracked_insts.list,
+            .list = &local.shared.tracked_insts,
+        };
+    }
+    /// Elements are ordered identically to the `import_table` field of `Zcu`.
+    ///
+    /// Unlike `import_table`, this data is serialized as part of incremental
+    /// compilation state.
+    ///
+    /// Key is the hash of the path to this file, used to store
+    /// `InternPool.TrackedInst`.
+    ///
+    /// Value is the `Decl` of the struct that represents this `File`.
+    pub fn getMutableFiles(local: *Local, gpa: Allocator) List(File).Mutable {
+        return .{
+            .gpa = gpa,
+            .arena = &local.mutate.arena,
+            .mutate = &local.mutate.files,
+            .list = &local.shared.files,
+        };
+    }
+    /// Some types such as enums, structs, and unions need to store mappings from field names
+    /// to field index, or value to field index. In such cases, they will store the underlying
+    /// field names and values directly, relying on one of these maps, stored separately,
+    /// to provide lookup.
+    /// These are not serialized; it is computed upon deserialization.
+    pub fn getMutableMaps(local: *Local, gpa: Allocator) Maps.Mutable {
+        return .{
+            .gpa = gpa,
+            .arena = &local.mutate.arena,
+            .mutate = &local.mutate.maps,
+            .list = &local.shared.maps,
+        };
+    }
     /// Rather than allocating Decl objects with an Allocator, we instead allocate
     /// them with this BucketList. This provides four advantages:
     ///  * Stable memory so that one thread can access a Decl object while another
 @@ -687,7 +849,7 @@ const Local = struct {
     ///    serialization trivial.
     ///  * It provides a unique integer to be used for anonymous symbol names, avoiding
     ///    multi-threaded contention on an atomic counter.
-    pub fn getMutableDecls(local: *Local, gpa: std.mem.Allocator) Decls.Mutable {
+    pub fn getMutableDecls(local: *Local, gpa: Allocator) Decls.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -697,7 +859,7 @@ const Local = struct {
     }
     /// Same pattern as with `getMutableDecls`.
-    pub fn getMutableNamespaces(local: *Local, gpa: std.mem.Allocator) Namespaces.Mutable {
+    pub fn getMutableNamespaces(local: *Local, gpa: Allocator) Namespaces.Mutable {
         return .{
             .gpa = gpa,
             .arena = &local.mutate.arena,
 @@ -719,11 +881,13 @@ const Shard = struct {
     shared: struct {
         map: Map(Index),
         string_map: Map(OptionalNullTerminatedString),
+        tracked_inst_map: Map(TrackedInst.Index.Optional),
     } align(std.atomic.cache_line),
     mutate: struct {
         // TODO: measure cost of sharing unrelated mutate state
         map: Mutate align(std.atomic.cache_line),
         string_map: Mutate align(std.atomic.cache_line),
+        tracked_inst_map: Mutate align(std.atomic.cache_line),
     },
     const Mutate = struct {
 @@ -812,8 +976,6 @@ const Hash = std.hash.Wyhash;
 const InternPool = @This();
 const Zcu = @import("Zcu.zig");
-/// Deprecated.
-const Module = Zcu;
 const Zir = std.zig.Zir;
 /// An index into `maps` which might be `none`.
 @@ -831,9 +993,37 @@ pub const OptionalMapIndex = enum(u32) {
 pub const MapIndex = enum(u32) {
     _,
+    pub fn get(map_index: MapIndex, ip: *InternPool) *FieldMap {
+        const unwrapped_map_index = map_index.unwrap(ip);
+        const maps = ip.getLocalShared(unwrapped_map_index.tid).maps.acquire();
+        return &maps.view().items(.@"0")[unwrapped_map_index.index];
+    }
+    pub fn getConst(map_index: MapIndex, ip: *const InternPool) FieldMap {
+        return map_index.get(@constCast(ip)).*;
+    }
     pub fn toOptional(i: MapIndex) OptionalMapIndex {
         return @enumFromInt(@intFromEnum(i));
     }
+    const Unwrapped = struct {
+        tid: Zcu.PerThread.Id,
+        index: u32,
+        fn wrap(unwrapped: Unwrapped, ip: *const InternPool) MapIndex {
+            assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask());
+            assert(unwrapped.index <= ip.getIndexMask(u32));
+            return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 |
+                unwrapped.index);
+        }
+    };
+    fn unwrap(map_index: MapIndex, ip: *const InternPool) Unwrapped {
+        return .{
+            .tid = @enumFromInt(@intFromEnum(map_index) >> ip.tid_shift_32 & ip.getTidMask()),
+            .index = @intFromEnum(map_index) & ip.getIndexMask(u32),
+        };
+    }
 };
 pub const RuntimeIndex = enum(u32) {
 @@ -938,6 +1128,34 @@ pub const OptionalNamespaceIndex = enum(u32) {
     }
 };
+pub const FileIndex = enum(u32) {
+    _,
+    const Unwrapped = struct {
+        tid: Zcu.PerThread.Id,
+        index: u32,
+        fn wrap(unwrapped: Unwrapped, ip: *const InternPool) FileIndex {
+            assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask());
+            assert(unwrapped.index <= ip.getIndexMask(u32));
+            return @enumFromInt(@as(u32, @intFromEnum(unwrapped.tid)) << ip.tid_shift_32 |
+                unwrapped.index);
+        }
+    };
+    pub fn unwrap(file_index: FileIndex, ip: *const InternPool) Unwrapped {
+        return .{
+            .tid = @enumFromInt(@intFromEnum(file_index) >> ip.tid_shift_32 & ip.getTidMask()),
+            .index = @intFromEnum(file_index) & ip.getIndexMask(u32),
+        };
+    }
+};
+const File = struct {
+    bin_digest: Cache.BinDigest,
+    file: *Zcu.File,
+    root_decl: OptionalDeclIndex,
+};
 /// An index into `strings`.
 pub const String = enum(u32) {
     /// An empty string.
 @@ -1240,7 +1458,7 @@ pub const Key = union(enum) {
         /// Look up field index based on field name.
         pub fn nameIndex(self: ErrorSetType, ip: *const InternPool, name: NullTerminatedString) ?u32 {
-            const map = &ip.maps.items[@intFromEnum(self.names_map.unwrap().?)];
+            const map = self.names_map.unwrap().?.getConst(ip);
             const adapter: NullTerminatedString.Adapter = .{ .strings = self.names.get(ip) };
             const field_index = map.getIndexAdapted(name, adapter) orelse return null;
             return @intCast(field_index);
 @@ -2665,7 +2883,7 @@ pub const LoadedStructType = struct {
             if (i >= self.field_types.len) return null;
             return i;
         };
-        const map = &ip.maps.items[@intFromEnum(names_map)];
+        const map = names_map.getConst(ip);
         const adapter: NullTerminatedString.Adapter = .{ .strings = self.field_names.get(ip) };
         const field_index = map.getIndexAdapted(name, adapter) orelse return null;
         return @intCast(field_index);
 @@ -2783,20 +3001,25 @@ pub const LoadedStructType = struct {
     }
     pub fn setInitsWip(s: LoadedStructType, ip: *InternPool) bool {
-        switch (s.layout) {
+        const local = ip.getLocal(s.tid);
-            .@"packed" => {
+        local.mutate.extra.mutex.lock();
-                const flag = &s.packedFlagsPtr(ip).field_inits_wip;
+        defer local.mutate.extra.mutex.unlock();
-                if (flag.*) return true;
+        return switch (s.layout) {
-                flag.* = true;
+            .@"packed" => @as(Tag.TypeStructPacked.Flags, @bitCast(@atomicRmw(
-                return false;
+                u32,
-            },
+                @as(*u32, @ptrCast(s.packedFlagsPtr(ip))),
-            .auto, .@"extern" => {
+                .Or,
-                const flag = &s.flagsPtr(ip).field_inits_wip;
+                @bitCast(Tag.TypeStructPacked.Flags{ .field_inits_wip = true }),
-                if (flag.*) return true;
+                .acq_rel,
-                flag.* = true;
+            ))).field_inits_wip,
-                return false;
+            .auto, .@"extern" => @as(Tag.TypeStruct.Flags, @bitCast(@atomicRmw(
-            },
+                u32,
-        }
+                @as(*u32, @ptrCast(s.flagsPtr(ip))),
+                .Or,
+                @bitCast(Tag.TypeStruct.Flags{ .field_inits_wip = true }),
+                .acq_rel,
+            ))).field_inits_wip,
+        };
     }
     pub fn clearInitsWip(s: LoadedStructType, ip: *InternPool) void {
 @@ -2962,6 +3185,7 @@ pub const LoadedStructType = struct {
 pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
     const unwrapped_index = index.unwrap(ip);
     const extra_list = unwrapped_index.getExtra(ip);
+    const extra_items = extra_list.view().items(.@"0");
     const item = unwrapped_index.getItem(ip);
     switch (item.tag) {
         .type_struct => {
 @@ -2982,10 +3206,12 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .names_map = .none,
                 .captures = CaptureValue.Slice.empty,
             };
-            const extra = extraDataTrail(extra_list, Tag.TypeStruct, item.data);
+            const decl: DeclIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "decl").?]);
-            const fields_len = extra.data.fields_len;
+            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?]);
-            var extra_index = extra.end;
+            const fields_len = extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "fields_len").?];
-            const captures_len = if (extra.data.flags.any_captures) c: {
+            const flags: Tag.TypeStruct.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?], .monotonic));
+            var extra_index = item.data + @as(u32, @typeInfo(Tag.TypeStruct).Struct.fields.len);
+            const captures_len = if (flags.any_captures) c: {
                 const len = extra_list.view().items(.@"0")[extra_index];
                 extra_index += 1;
                 break :c len;
 @@ -2996,7 +3222,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .len = captures_len,
             };
             extra_index += captures_len;
-            if (extra.data.flags.is_reified) {
+            if (flags.is_reified) {
                 extra_index += 2; // PackedU64
             }
             const field_types: Index.Slice = .{
 @@ -3005,7 +3231,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .len = fields_len,
             };
             extra_index += fields_len;
-            const names_map: OptionalMapIndex, const names = if (!extra.data.flags.is_tuple) n: {
+            const names_map: OptionalMapIndex, const names = if (!flags.is_tuple) n: {
                 const names_map: OptionalMapIndex = @enumFromInt(extra_list.view().items(.@"0")[extra_index]);
                 extra_index += 1;
                 const names: NullTerminatedString.Slice = .{
 @@ -3016,7 +3242,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 extra_index += fields_len;
                 break :n .{ names_map, names };
             } else .{ .none, NullTerminatedString.Slice.empty };
-            const inits: Index.Slice = if (extra.data.flags.any_default_inits) i: {
+            const inits: Index.Slice = if (flags.any_default_inits) i: {
                 const inits: Index.Slice = .{
                     .tid = unwrapped_index.tid,
                     .start = extra_index,
 @@ -3025,12 +3251,12 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 extra_index += fields_len;
                 break :i inits;
             } else Index.Slice.empty;
-            const namespace: OptionalNamespaceIndex = if (extra.data.flags.has_namespace) n: {
+            const namespace: OptionalNamespaceIndex = if (flags.has_namespace) n: {
                 const n: NamespaceIndex = @enumFromInt(extra_list.view().items(.@"0")[extra_index]);
                 extra_index += 1;
                 break :n n.toOptional();
             } else .none;
-            const aligns: Alignment.Slice = if (extra.data.flags.any_aligned_fields) a: {
+            const aligns: Alignment.Slice = if (flags.any_aligned_fields) a: {
                 const a: Alignment.Slice = .{
                     .tid = unwrapped_index.tid,
                     .start = extra_index,
 @@ -3039,7 +3265,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 extra_index += std.math.divCeil(u32, fields_len, 4) catch unreachable;
                 break :a a;
             } else Alignment.Slice.empty;
-            const comptime_bits: LoadedStructType.ComptimeBits = if (extra.data.flags.any_comptime_fields) c: {
+            const comptime_bits: LoadedStructType.ComptimeBits = if (flags.any_comptime_fields) c: {
                 const len = std.math.divCeil(u32, fields_len, 32) catch unreachable;
                 const c: LoadedStructType.ComptimeBits = .{
                     .tid = unwrapped_index.tid,
 @@ -3049,7 +3275,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 extra_index += len;
                 break :c c;
             } else LoadedStructType.ComptimeBits.empty;
-            const runtime_order: LoadedStructType.RuntimeOrder.Slice = if (!extra.data.flags.is_extern) ro: {
+            const runtime_order: LoadedStructType.RuntimeOrder.Slice = if (!flags.is_extern) ro: {
                 const ro: LoadedStructType.RuntimeOrder.Slice = .{
                     .tid = unwrapped_index.tid,
                     .start = extra_index,
 @@ -3070,10 +3296,10 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
             return .{
                 .tid = unwrapped_index.tid,
                 .extra_index = item.data,
-                .decl = extra.data.decl.toOptional(),
+                .decl = decl.toOptional(),
                 .namespace = namespace,
-                .zir_index = extra.data.zir_index.toOptional(),
+                .zir_index = zir_index.toOptional(),
-                .layout = if (extra.data.flags.is_extern) .@"extern" else .auto,
+                .layout = if (flags.is_extern) .@"extern" else .auto,
                 .field_names = names,
                 .field_types = field_types,
                 .field_inits = inits,
 @@ -3086,11 +3312,15 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
             };
         },
         .type_struct_packed, .type_struct_packed_inits => {
-            const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, item.data);
+            const decl: DeclIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "decl").?]);
+            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "zir_index").?]);
+            const fields_len = extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "fields_len").?];
+            const namespace: OptionalNamespaceIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "namespace").?]);
+            const names_map: MapIndex = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "names_map").?]);
+            const flags: Tag.TypeStructPacked.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?], .monotonic));
+            var extra_index = item.data + @as(u32, @typeInfo(Tag.TypeStructPacked).Struct.fields.len);
             const has_inits = item.tag == .type_struct_packed_inits;
-            const fields_len = extra.data.fields_len;
+            const captures_len = if (flags.any_captures) c: {
-            var extra_index = extra.end;
-            const captures_len = if (extra.data.flags.any_captures) c: {
                 const len = extra_list.view().items(.@"0")[extra_index];
                 extra_index += 1;
                 break :c len;
 @@ -3101,7 +3331,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .len = captures_len,
             };
             extra_index += captures_len;
-            if (extra.data.flags.is_reified) {
+            if (flags.is_reified) {
                 extra_index += 2; // PackedU64
             }
             const field_types: Index.Slice = .{
 @@ -3128,9 +3358,9 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
             return .{
                 .tid = unwrapped_index.tid,
                 .extra_index = item.data,
-                .decl = extra.data.decl.toOptional(),
+                .decl = decl.toOptional(),
-                .namespace = extra.data.namespace,
+                .namespace = namespace,
-                .zir_index = extra.data.zir_index.toOptional(),
+                .zir_index = zir_index.toOptional(),
                 .layout = .@"packed",
                 .field_names = field_names,
                 .field_types = field_types,
 @@ -3139,7 +3369,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType {
                 .runtime_order = LoadedStructType.RuntimeOrder.Slice.empty,
                 .comptime_bits = LoadedStructType.ComptimeBits.empty,
                 .offsets = LoadedStructType.Offsets.empty,
-                .names_map = extra.data.names_map.toOptional(),
+                .names_map = names_map.toOptional(),
                 .captures = captures,
             };
         },
 @@ -3183,7 +3413,7 @@ const LoadedEnumType = struct {
     /// Look up field index based on field name.
     pub fn nameIndex(self: LoadedEnumType, ip: *const InternPool, name: NullTerminatedString) ?u32 {
-        const map = &ip.maps.items[@intFromEnum(self.names_map)];
+        const map = self.names_map.getConst(ip);
         const adapter: NullTerminatedString.Adapter = .{ .strings = self.names.get(ip) };
         const field_index = map.getIndexAdapted(name, adapter) orelse return null;
         return @intCast(field_index);
 @@ -3203,7 +3433,7 @@ const LoadedEnumType = struct {
             else => unreachable,
         };
         if (self.values_map.unwrap()) |values_map| {
-            const map = &ip.maps.items[@intFromEnum(values_map)];
+            const map = values_map.getConst(ip);
             const adapter: Index.Adapter = .{ .indexes = self.values.get(ip) };
             const field_index = map.getIndexAdapted(int_tag_val, adapter) orelse return null;
             return @intCast(field_index);
 @@ -4476,11 +4706,11 @@ pub const Tag = enum(u8) {
         flags: Flags,
         pub const Flags = packed struct(u32) {
-            any_captures: bool,
+            any_captures: bool = false,
             /// Dependency loop detection when resolving field inits.
-            field_inits_wip: bool,
+            field_inits_wip: bool = false,
-            inits_resolved: bool,
+            inits_resolved: bool = false,
-            is_reified: bool,
+            is_reified: bool = false,
             _: u28 = 0,
         };
     };
 @@ -4526,36 +4756,36 @@ pub const Tag = enum(u8) {
         size: u32,
         pub const Flags = packed struct(u32) {
-            any_captures: bool,
+            any_captures: bool = false,
-            is_extern: bool,
+            is_extern: bool = false,
-            known_non_opv: bool,
+            known_non_opv: bool = false,
-            requires_comptime: RequiresComptime,
+            requires_comptime: RequiresComptime = @enumFromInt(0),
-            is_tuple: bool,
+            is_tuple: bool = false,
-            assumed_runtime_bits: bool,
+            assumed_runtime_bits: bool = false,
-            assumed_pointer_aligned: bool,
+            assumed_pointer_aligned: bool = false,
-            has_namespace: bool,
+            has_namespace: bool = false,
-            any_comptime_fields: bool,
+            any_comptime_fields: bool = false,
-            any_default_inits: bool,
+            any_default_inits: bool = false,
-            any_aligned_fields: bool,
+            any_aligned_fields: bool = false,
             /// `.none` until layout_resolved
-            alignment: Alignment,
+            alignment: Alignment = @enumFromInt(0),
             /// Dependency loop detection when resolving struct alignment.
-            alignment_wip: bool,
+            alignment_wip: bool = false,
             /// Dependency loop detection when resolving field types.
-            field_types_wip: bool,
+            field_types_wip: bool = false,
             /// Dependency loop detection when resolving struct layout.
-            layout_wip: bool,
+            layout_wip: bool = false,
             /// Indicates whether `size`, `alignment`, runtime field order, and
             /// field offets are populated.
-            layout_resolved: bool,
+            layout_resolved: bool = false,
             /// Dependency loop detection when resolving field inits.
-            field_inits_wip: bool,
+            field_inits_wip: bool = false,
             /// Indicates whether `field_inits` has been resolved.
-            inits_resolved: bool,
+            inits_resolved: bool = false,
-            // The types and all its fields have had their layout resolved. Even through pointer,
+            // The types and all its fields have had their layout resolved. Even through pointer = false,
             // which `layout_resolved` does not ensure.
-            fully_resolved: bool,
+            fully_resolved: bool = false,
-            is_reified: bool,
+            is_reified: bool = false,
             _: u6 = 0,
         };
     };
 @@ -4599,12 +4829,12 @@ pub const FuncAnalysis = packed struct(u32) {
         /// inline, which means no runtime version of the function will be generated.
         inline_only,
         in_progress,
-        /// There will be a corresponding ErrorMsg in Module.failed_decls
+        /// There will be a corresponding ErrorMsg in Zcu.failed_decls
         sema_failure,
         /// This function might be OK but it depends on another Decl which did not
         /// successfully complete semantic analysis.
         dependency_failure,
-        /// There will be a corresponding ErrorMsg in Module.failed_decls.
+        /// There will be a corresponding ErrorMsg in Zcu.failed_decls.
         /// Indicates that semantic analysis succeeded, but code generation for
         /// this function failed.
         codegen_failure,
 @@ -5201,6 +5431,9 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
             .extra = Local.Extra.empty,
             .limbs = Local.Limbs.empty,
             .strings = Local.Strings.empty,
+            .tracked_insts = Local.TrackedInsts.empty,
+            .files = Local.List(File).empty,
+            .maps = Local.Maps.empty,
             .decls = Local.Decls.empty,
             .namespaces = Local.Namespaces.empty,
 @@ -5209,9 +5442,12 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
             .arena = .{},
             .items = Local.ListMutate.empty,
-            .extra = Local.ListMutate.empty,
+            .extra = Local.MutexListMutate.empty,
             .limbs = Local.ListMutate.empty,
             .strings = Local.ListMutate.empty,
+            .tracked_insts = Local.MutexListMutate.empty,
+            .files = Local.ListMutate.empty,
+            .maps = Local.ListMutate.empty,
             .decls = Local.BucketListMutate.empty,
             .namespaces = Local.BucketListMutate.empty,
 @@ -5226,10 +5462,12 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
         .shared = .{
             .map = Shard.Map(Index).empty,
             .string_map = Shard.Map(OptionalNullTerminatedString).empty,
+            .tracked_inst_map = Shard.Map(TrackedInst.Index.Optional).empty,
         },
         .mutate = .{
             .map = Shard.Mutate.empty,
             .string_map = Shard.Mutate.empty,
+            .tracked_inst_map = Shard.Mutate.empty,
         },
     });
 @@ -5267,11 +5505,6 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
 }
 pub fn deinit(ip: *InternPool, gpa: Allocator) void {
-    for (ip.maps.items) |*map| map.deinit(gpa);
-    ip.maps.deinit(gpa);
-    ip.tracked_insts.deinit(gpa);
     ip.src_hash_deps.deinit(gpa);
     ip.decl_val_deps.deinit(gpa);
     ip.func_ies_deps.deinit(gpa);
 @@ -5283,8 +5516,6 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
     ip.dep_entries.deinit(gpa);
     ip.free_dep_entries.deinit(gpa);
-    ip.files.deinit(gpa);
     gpa.free(ip.shards);
     for (ip.locals) |*local| {
         const buckets_len = local.mutate.namespaces.buckets_list.len;
 @@ -5301,6 +5532,8 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
                 namespace.usingnamespace_set.deinit(gpa);
             }
         };
+        const maps = local.getMutableMaps(gpa);
+        if (maps.mutate.len > 0) for (maps.view().items(.@"0")) |*map| map.deinit(gpa);
         local.mutate.arena.promote(gpa).deinit();
     }
     gpa.free(ip.locals);
 @@ -5400,40 +5633,46 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key {
         .type_struct => .{ .struct_type = ns: {
             if (data == 0) break :ns .empty_struct;
             const extra_list = unwrapped_index.getExtra(ip);
-            const extra = extraDataTrail(extra_list, Tag.TypeStruct, data);
+            const extra_items = extra_list.view().items(.@"0");
-            if (extra.data.flags.is_reified) {
+            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[data + std.meta.fieldIndex(Tag.TypeStruct, "zir_index").?]);
-                assert(!extra.data.flags.any_captures);
+            const flags: Tag.TypeStruct.Flags = @bitCast(@atomicLoad(u32, &extra_items[data + std.meta.fieldIndex(Tag.TypeStruct, "flags").?], .monotonic));
+            const end_extra_index = data + @as(u32, @typeInfo(Tag.TypeStruct).Struct.fields.len);
+            if (flags.is_reified) {
+                assert(!flags.any_captures);
                 break :ns .{ .reified = .{
-                    .zir_index = extra.data.zir_index,
+                    .zir_index = zir_index,
-                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
+                    .type_hash = extraData(extra_list, PackedU64, end_extra_index).get(),
                 } };
             }
             break :ns .{ .declared = .{
-                .zir_index = extra.data.zir_index,
+                .zir_index = zir_index,
-                .captures = .{ .owned = if (extra.data.flags.any_captures) .{
+                .captures = .{ .owned = if (flags.any_captures) .{
                     .tid = unwrapped_index.tid,
-                    .start = extra.end + 1,
+                    .start = end_extra_index + 1,
-                    .len = extra_list.view().items(.@"0")[extra.end],
+                    .len = extra_list.view().items(.@"0")[end_extra_index],
                 } else CaptureValue.Slice.empty },
             } };
         } },
         .type_struct_packed, .type_struct_packed_inits => .{ .struct_type = ns: {
             const extra_list = unwrapped_index.getExtra(ip);
-            const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data);
+            const extra_items = extra_list.view().items(.@"0");
-            if (extra.data.flags.is_reified) {
+            const zir_index: TrackedInst.Index = @enumFromInt(extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "zir_index").?]);
-                assert(!extra.data.flags.any_captures);
+            const flags: Tag.TypeStructPacked.Flags = @bitCast(@atomicLoad(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "flags").?], .monotonic));
+            const end_extra_index = data + @as(u32, @typeInfo(Tag.TypeStructPacked).Struct.fields.len);
+            if (flags.is_reified) {
+                assert(!flags.any_captures);
                 break :ns .{ .reified = .{
-                    .zir_index = extra.data.zir_index,
+                    .zir_index = zir_index,
-                    .type_hash = extraData(extra_list, PackedU64, extra.end).get(),
+                    .type_hash = extraData(extra_list, PackedU64, end_extra_index).get(),
                 } };
             }
             break :ns .{ .declared = .{
-                .zir_index = extra.data.zir_index,
+                .zir_index = zir_index,
-                .captures = .{ .owned = if (extra.data.flags.any_captures) .{
+                .captures = .{ .owned = if (flags.any_captures) .{
                     .tid = unwrapped_index.tid,
-                    .start = extra.end + 1,
+                    .start = end_extra_index + 1,
-                    .len = extra_list.view().items(.@"0")[extra.end],
+                    .len = extra_items[end_extra_index],
                 } else CaptureValue.Slice.empty },
             } };
         } },
 @@ -5914,27 +6153,32 @@ fn extraFuncDecl(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Ke
 }
 fn extraFuncInstance(ip: *const InternPool, tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Key.Func {
-    const P = Tag.FuncInstance;
+    const extra_items = extra.view().items(.@"0");
-    const fi = extraDataTrail(extra, P, extra_index);
+    const analysis_extra_index = extra_index + std.meta.fieldIndex(Tag.FuncInstance, "analysis").?;
-    const func_decl = ip.funcDeclInfo(fi.data.generic_owner);
+    const analysis: FuncAnalysis = @bitCast(@atomicLoad(u32, &extra_items[analysis_extra_index], .monotonic));
+    const owner_decl: DeclIndex = @enumFromInt(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "owner_decl").?]);
+    const ty: Index = @enumFromInt(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "ty").?]);
+    const generic_owner: Index = @enumFromInt(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "generic_owner").?]);
+    const func_decl = ip.funcDeclInfo(generic_owner);
+    const end_extra_index = extra_index + @as(u32, @typeInfo(Tag.FuncInstance).Struct.fields.len);
     return .{
         .tid = tid,
-        .ty = fi.data.ty,
+        .ty = ty,
-        .uncoerced_ty = fi.data.ty,
+        .uncoerced_ty = ty,
-        .analysis_extra_index = extra_index + std.meta.fieldIndex(P, "analysis").?,
+        .analysis_extra_index = analysis_extra_index,
         .zir_body_inst_extra_index = func_decl.zir_body_inst_extra_index,
-        .resolved_error_set_extra_index = if (fi.data.analysis.inferred_error_set) fi.end else 0,
+        .resolved_error_set_extra_index = if (analysis.inferred_error_set) end_extra_index else 0,
-        .branch_quota_extra_index = extra_index + std.meta.fieldIndex(P, "branch_quota").?,
+        .branch_quota_extra_index = extra_index + std.meta.fieldIndex(Tag.FuncInstance, "branch_quota").?,
-        .owner_decl = fi.data.owner_decl,
+        .owner_decl = owner_decl,
         .zir_body_inst = func_decl.zir_body_inst,
         .lbrace_line = func_decl.lbrace_line,
         .rbrace_line = func_decl.rbrace_line,
         .lbrace_column = func_decl.lbrace_column,
         .rbrace_column = func_decl.rbrace_column,
-        .generic_owner = fi.data.generic_owner,
+        .generic_owner = generic_owner,
         .comptime_args = .{
             .tid = tid,
-            .start = fi.end + @intFromBool(fi.data.analysis.inferred_error_set),
+            .start = end_extra_index + @intFromBool(analysis.inferred_error_set),
             .len = ip.funcTypeParamsLen(func_decl.ty),
         },
     };
 @@ -6206,8 +6450,8 @@ pub fn get(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, key: Key) All
             assert(error_set_type.names_map == .none);
             assert(std.sort.isSorted(NullTerminatedString, error_set_type.names.get(ip), {}, NullTerminatedString.indexLessThan));
             const names = error_set_type.names.get(ip);
-            const names_map = try ip.addMap(gpa, names.len);
+            const names_map = try ip.addMap(gpa, tid, names.len);
-            addStringsToMap(ip, names_map, names);
+            ip.addStringsToMap(names_map, names);
             const names_len = error_set_type.names.len;
             try extra.ensureUnusedCapacity(@typeInfo(Tag.ErrorSet).Struct.fields.len + names_len);
             items.appendAssumeCapacity(.{
 @@ -7107,8 +7351,8 @@ pub fn getStructType(
     const items = local.getMutableItems(gpa);
     const extra = local.getMutableExtra(gpa);
-    const names_map = try ip.addMap(gpa, ini.fields_len);
+    const names_map = try ip.addMap(gpa, tid, ini.fields_len);
-    errdefer _ = ip.maps.pop();
+    errdefer local.mutate.maps.len -= 1;
     const zir_index = switch (ini.key) {
         inline else => |x| x.zir_index,
 @@ -7655,17 +7899,18 @@ pub fn getErrorSetType(
     const extra = local.getMutableExtra(gpa);
     try extra.ensureUnusedCapacity(@typeInfo(Tag.ErrorSet).Struct.fields.len + names.len);
+    const names_map = try ip.addMap(gpa, tid, names.len);
+    errdefer local.mutate.maps.len -= 1;
     // The strategy here is to add the type unconditionally, then to ask if it
     // already exists, and if so, revert the lengths of the mutated arrays.
     // This is similar to what `getOrPutTrailingString` does.
     const prev_extra_len = extra.mutate.len;
     errdefer extra.mutate.len = prev_extra_len;
-    const predicted_names_map: MapIndex = @enumFromInt(ip.maps.items.len);
     const error_set_extra_index = addExtraAssumeCapacity(extra, Tag.ErrorSet{
         .names_len = @intCast(names.len),
-        .names_map = predicted_names_map,
+        .names_map = names_map,
     });
     extra.appendSliceAssumeCapacity(.{@ptrCast(names)});
     errdefer extra.mutate.len = prev_extra_len;
 @@ -7685,11 +7930,7 @@ pub fn getErrorSetType(
     });
     errdefer items.mutate.len -= 1;
-    const names_map = try ip.addMap(gpa, names.len);
+    ip.addStringsToMap(names_map, names);
-    assert(names_map == predicted_names_map);
-    errdefer _ = ip.maps.pop();
-    addStringsToMap(ip, names_map, names);
     return gop.put();
 }
 @@ -7955,6 +8196,7 @@ fn finishFuncInstance(
     const fn_owner_decl = ip.declPtr(ip.funcDeclOwner(generic_owner));
     const decl_index = try ip.createDecl(gpa, tid, .{
         .name = undefined,
+        .fqn = undefined,
         .src_namespace = fn_owner_decl.src_namespace,
         .has_tv = true,
         .owns_tv = true,
 @@ -7980,6 +8222,8 @@ fn finishFuncInstance(
     decl.name = try ip.getOrPutStringFmt(gpa, tid, "{}__anon_{d}", .{
         fn_owner_decl.name.fmt(ip), @intFromEnum(decl_index),
     }, .no_embedded_nulls);
+    decl.fqn = try ip.namespacePtr(fn_owner_decl.src_namespace)
+        .internFullyQualifiedName(ip, gpa, tid, decl.name);
 }
 pub const EnumTypeInit = struct {
 @@ -8052,7 +8296,7 @@ pub const WipEnumType = struct {
             return null;
         }
         assert(ip.typeOf(value) == @as(Index, @enumFromInt(extra_items[wip.tag_ty_index])));
-        const map = &ip.maps.items[@intFromEnum(wip.values_map.unwrap().?)];
+        const map = wip.values_map.unwrap().?.get(ip);
         const field_index = map.count();
         const indexes = extra_items[wip.values_start..][0..field_index];
         const adapter: Index.Adapter = .{ .indexes = @ptrCast(indexes) };
 @@ -8098,8 +8342,8 @@ pub fn getEnumType(
     try items.ensureUnusedCapacity(1);
     const extra = local.getMutableExtra(gpa);
-    const names_map = try ip.addMap(gpa, ini.fields_len);
+    const names_map = try ip.addMap(gpa, tid, ini.fields_len);
-    errdefer _ = ip.maps.pop();
+    errdefer local.mutate.maps.len -= 1;
     switch (ini.tag_mode) {
         .auto => {
 @@ -8152,11 +8396,11 @@ pub fn getEnumType(
         },
         .explicit, .nonexhaustive => {
             const values_map: OptionalMapIndex = if (!ini.has_values) .none else m: {
-                const values_map = try ip.addMap(gpa, ini.fields_len);
+                const values_map = try ip.addMap(gpa, tid, ini.fields_len);
                 break :m values_map.toOptional();
             };
             errdefer if (ini.has_values) {
-                _ = ip.maps.pop();
+                local.mutate.maps.len -= 1;
             };
             try extra.ensureUnusedCapacity(@typeInfo(EnumExplicit).Struct.fields.len +
 @@ -8245,8 +8489,8 @@ pub fn getGeneratedTagEnumType(
     try items.ensureUnusedCapacity(1);
     const extra = local.getMutableExtra(gpa);
-    const names_map = try ip.addMap(gpa, ini.names.len);
+    const names_map = try ip.addMap(gpa, tid, ini.names.len);
-    errdefer _ = ip.maps.pop();
+    errdefer local.mutate.maps.len -= 1;
     ip.addStringsToMap(names_map, ini.names);
     const fields_len: u32 = @intCast(ini.names.len);
 @@ -8279,8 +8523,8 @@ pub fn getGeneratedTagEnumType(
                 ini.values.len); // field values
             const values_map: OptionalMapIndex = if (ini.values.len != 0) m: {
-                const map = try ip.addMap(gpa, ini.values.len);
+                const map = try ip.addMap(gpa, tid, ini.values.len);
-                addIndexesToMap(ip, map, ini.values);
+                ip.addIndexesToMap(map, ini.values);
                 break :m map.toOptional();
             } else .none;
             // We don't clean up the values map on error!
 @@ -8311,7 +8555,9 @@ pub fn getGeneratedTagEnumType(
     errdefer extra.mutate.len = prev_extra_len;
     errdefer switch (ini.tag_mode) {
         .auto => {},
-        .explicit, .nonexhaustive => _ = if (ini.values.len != 0) ip.maps.pop(),
+        .explicit, .nonexhaustive => if (ini.values.len != 0) {
+            local.mutate.maps.len -= 1;
+        },
     };
     var gop = try ip.getOrPutKey(gpa, tid, .{ .enum_type = .{
 @@ -8415,7 +8661,7 @@ fn addStringsToMap(
     map_index: MapIndex,
     strings: []const NullTerminatedString,
 ) void {
-    const map = &ip.maps.items[@intFromEnum(map_index)];
+    const map = map_index.get(ip);
     const adapter: NullTerminatedString.Adapter = .{ .strings = strings };
     for (strings) |string| {
         const gop = map.getOrPutAssumeCapacityAdapted(string, adapter);
 @@ -8428,7 +8674,7 @@ fn addIndexesToMap(
     map_index: MapIndex,
     indexes: []const Index,
 ) void {
-    const map = &ip.maps.items[@intFromEnum(map_index)];
+    const map = map_index.get(ip);
     const adapter: Index.Adapter = .{ .indexes = indexes };
     for (indexes) |index| {
         const gop = map.getOrPutAssumeCapacityAdapted(index, adapter);
 @@ -8436,12 +8682,14 @@ fn addIndexesToMap(
     }
 }
-fn addMap(ip: *InternPool, gpa: Allocator, cap: usize) Allocator.Error!MapIndex {
+fn addMap(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, cap: usize) Allocator.Error!MapIndex {
-    const ptr = try ip.maps.addOne(gpa);
+    const maps = ip.getLocal(tid).getMutableMaps(gpa);
-    errdefer _ = ip.maps.pop();
+    const unwrapped: MapIndex.Unwrapped = .{ .tid = tid, .index = maps.mutate.len };
-    ptr.* = .{};
+    const ptr = try maps.addOne();
-    try ptr.ensureTotalCapacity(gpa, cap);
+    errdefer maps.mutate.len = unwrapped.index;
-    return @enumFromInt(ip.maps.items.len - 1);
+    ptr[0].* = .{};
+    try ptr[0].ensureTotalCapacity(gpa, cap);
+    return unwrapped.wrap(ip);
 }
 /// This operation only happens under compile error conditions.
 @@ -9167,10 +9415,13 @@ pub fn errorUnionPayload(ip: *const InternPool, ty: Index) Index {
 /// The is only legal because the initializer is not part of the hash.
 pub fn mutateVarInit(ip: *InternPool, index: Index, init_index: Index) void {
     const unwrapped_index = index.unwrap(ip);
-    const extra_list = unwrapped_index.getExtra(ip);
+    const local = ip.getLocal(unwrapped_index.tid);
+    local.mutate.extra.mutex.lock();
+    defer local.mutate.extra.mutex.unlock();
+    const extra_items = local.shared.extra.view().items(.@"0");
     const item = unwrapped_index.getItem(ip);
     assert(item.tag == .variable);
-    @atomicStore(u32, &extra_list.view().items(.@"0")[item.data + std.meta.fieldIndex(Tag.Variable, "init").?], @intFromEnum(init_index), .release);
+    @atomicStore(u32, &extra_items[item.data + std.meta.fieldIndex(Tag.Variable, "init").?], @intFromEnum(init_index), .release);
 }
 pub fn dump(ip: *const InternPool) void {
 @@ -9185,14 +9436,14 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void {
     var decls_len: usize = 0;
     for (ip.locals) |*local| {
         items_len += local.mutate.items.len;
-        extra_len += local.mutate.extra.len;
+        extra_len += local.mutate.extra.list.len;
         limbs_len += local.mutate.limbs.len;
         decls_len += local.mutate.decls.buckets_list.len;
     }
     const items_size = (1 + 4) * items_len;
     const extra_size = 4 * extra_len;
     const limbs_size = 8 * limbs_len;
-    const decls_size = @sizeOf(Module.Decl) * decls_len;
+    const decls_size = @sizeOf(Zcu.Decl) * decls_len;
     // TODO: map overhead size is not taken into account
     const total_size = @sizeOf(InternPool) + items_size + extra_size + limbs_size + decls_size;
 @@ -9619,29 +9870,22 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator)
     try bw.flush();
 }
-pub fn declPtr(ip: *InternPool, decl_index: DeclIndex) *Module.Decl {
+pub fn declPtr(ip: *InternPool, decl_index: DeclIndex) *Zcu.Decl {
     return @constCast(ip.declPtrConst(decl_index));
 }
-pub fn declPtrConst(ip: *const InternPool, decl_index: DeclIndex) *const Module.Decl {
+pub fn declPtrConst(ip: *const InternPool, decl_index: DeclIndex) *const Zcu.Decl {
     const unwrapped_decl_index = decl_index.unwrap(ip);
     const decls = ip.getLocalShared(unwrapped_decl_index.tid).decls.acquire();
     const decls_bucket = decls.view().items(.@"0")[unwrapped_decl_index.bucket_index];
     return &decls_bucket[unwrapped_decl_index.index];
 }
-pub fn namespacePtr(ip: *InternPool, namespace_index: NamespaceIndex) *Module.Namespace {
-    const unwrapped_namespace_index = namespace_index.unwrap(ip);
-    const namespaces = ip.getLocalShared(unwrapped_namespace_index.tid).namespaces.acquire();
-    const namespaces_bucket = namespaces.view().items(.@"0")[unwrapped_namespace_index.bucket_index];
-    return &namespaces_bucket[unwrapped_namespace_index.index];
-}
 pub fn createDecl(
     ip: *InternPool,
     gpa: Allocator,
     tid: Zcu.PerThread.Id,
-    initialization: Module.Decl,
+    initialization: Zcu.Decl,
 ) Allocator.Error!DeclIndex {
     const local = ip.getLocal(tid);
     const free_list_next = local.mutate.decls.free_list;
 @@ -9658,7 +9902,7 @@ pub fn createDecl(
         var arena = decls.arena.promote(decls.gpa);
         defer decls.arena.* = arena.state;
         decls.appendAssumeCapacity(.{try arena.allocator().create(
-            [1 << Local.decls_bucket_width]Module.Decl,
+            [1 << Local.decls_bucket_width]Zcu.Decl,
         )});
     }
     const unwrapped_decl_index: DeclIndex.Unwrapped = .{
 @@ -9681,11 +9925,18 @@ pub fn destroyDecl(ip: *InternPool, tid: Zcu.PerThread.Id, decl_index: DeclIndex
     local.mutate.decls.free_list = @intFromEnum(decl_index);
 }
+pub fn namespacePtr(ip: *InternPool, namespace_index: NamespaceIndex) *Zcu.Namespace {
+    const unwrapped_namespace_index = namespace_index.unwrap(ip);
+    const namespaces = ip.getLocalShared(unwrapped_namespace_index.tid).namespaces.acquire();
+    const namespaces_bucket = namespaces.view().items(.@"0")[unwrapped_namespace_index.bucket_index];
+    return &namespaces_bucket[unwrapped_namespace_index.index];
+}
 pub fn createNamespace(
     ip: *InternPool,
     gpa: Allocator,
     tid: Zcu.PerThread.Id,
-    initialization: Module.Namespace,
+    initialization: Zcu.Namespace,
 ) Allocator.Error!NamespaceIndex {
     const local = ip.getLocal(tid);
     const free_list_next = local.mutate.namespaces.free_list;
 @@ -9703,7 +9954,7 @@ pub fn createNamespace(
         var arena = namespaces.arena.promote(namespaces.gpa);
         defer namespaces.arena.* = arena.state;
         namespaces.appendAssumeCapacity(.{try arena.allocator().create(
-            [1 << Local.namespaces_bucket_width]Module.Namespace,
+            [1 << Local.namespaces_bucket_width]Zcu.Namespace,
         )});
     }
     const unwrapped_namespace_index: NamespaceIndex.Unwrapped = .{
 @@ -9735,6 +9986,27 @@ pub fn destroyNamespace(
     local.mutate.namespaces.free_list = @intFromEnum(namespace_index);
 }
+pub fn filePtr(ip: *InternPool, file_index: FileIndex) *Zcu.File {
+    const file_index_unwrapped = file_index.unwrap(ip);
+    const files = ip.getLocalShared(file_index_unwrapped.tid).files.acquire();
+    return files.view().items(.file)[file_index_unwrapped.index];
+}
+pub fn createFile(
+    ip: *InternPool,
+    gpa: Allocator,
+    tid: Zcu.PerThread.Id,
+    file: File,
+) Allocator.Error!FileIndex {
+    const files = ip.getLocal(tid).getMutableFiles(gpa);
+    const file_index_unwrapped: FileIndex.Unwrapped = .{
+        .tid = tid,
+        .index = files.mutate.len,
+    };
+    try files.append(file);
+    return file_index_unwrapped.wrap(ip);
+}
 const EmbeddedNulls = enum {
     no_embedded_nulls,
     maybe_embedded_nulls,
 @@ -9813,7 +10085,7 @@ pub fn getOrPutTrailingString(
     }
     const key: []const u8 = strings.view().items(.@"0")[start..];
     const value: embedded_nulls.StringType() =
-        @enumFromInt(@as(u32, @intFromEnum(tid)) << ip.tid_shift_32 | start);
+        @enumFromInt(@intFromEnum((String.Unwrapped{ .tid = tid, .index = start }).wrap(ip)));
     const has_embedded_null = std.mem.indexOfScalar(u8, key, 0) != null;
     switch (embedded_nulls) {
         .no_embedded_nulls => assert(!has_embedded_null),
 @@ -9859,10 +10131,10 @@ pub fn getOrPutTrailingString(
     defer shard.mutate.string_map.len += 1;
     const map_header = map.header().*;
     if (shard.mutate.string_map.len < map_header.capacity * 3 / 5) {
+        strings.appendAssumeCapacity(.{0});
         const entry = &map.entries[map_index];
         entry.hash = hash;
         entry.release(@enumFromInt(@intFromEnum(value)));
-        strings.appendAssumeCapacity(.{0});
         return value;
     }
     const arena_state = &ip.getLocal(tid).mutate.arena;
 @@ -9901,12 +10173,12 @@ pub fn getOrPutTrailingString(
         map_index &= new_map_mask;
         if (map.entries[map_index].value == .none) break;
     }
+    strings.appendAssumeCapacity(.{0});
     map.entries[map_index] = .{
         .value = @enumFromInt(@intFromEnum(value)),
         .hash = hash,
     };
     shard.shared.string_map.release(new_map);
-    strings.appendAssumeCapacity(.{0});
     return value;
 }
 @@ -10654,7 +10926,7 @@ pub fn addFieldName(
     name: NullTerminatedString,
 ) ?u32 {
     const extra_items = extra.view().items(.@"0");
-    const map = &ip.maps.items[@intFromEnum(names_map)];
+    const map = names_map.get(ip);
     const field_index = map.count();
     const strings = extra_items[names_start..][0..field_index];
     const adapter: NullTerminatedString.Adapter = .{ .strings = @ptrCast(strings) };
 @@ -10672,3 +10944,160 @@ fn ptrsHaveSameAlignment(ip: *InternPool, a_ty: Index, a_info: Key.PtrType, b_ty
     return a_info.flags.alignment == b_info.flags.alignment and
         (a_info.child == b_info.child or a_info.flags.alignment != .none);
 }
+const GlobalErrorSet = struct {
+    shared: struct {
+        names: Names,
+        map: Shard.Map(GlobalErrorSet.Index),
+    } align(std.atomic.cache_line),
+    mutate: Local.MutexListMutate align(std.atomic.cache_line),
+    const Names = Local.List(struct { NullTerminatedString });
+    const empty: GlobalErrorSet = .{
+        .shared = .{
+            .names = Names.empty,
+            .map = Shard.Map(GlobalErrorSet.Index).empty,
+        },
+        .mutate = Local.MutexListMutate.empty,
+    };
+    const Index = enum(Zcu.ErrorInt) {
+        none = 0,
+        _,
+    };
+    /// Not thread-safe, may only be called from the main thread.
+    pub fn getNamesFromMainThread(ges: *const GlobalErrorSet) []const NullTerminatedString {
+        const len = ges.mutate.list.len;
+        return if (len > 0) ges.shared.names.view().items(.@"0")[0..len] else &.{};
+    }
+    fn getErrorValue(
+        ges: *GlobalErrorSet,
+        gpa: Allocator,
+        arena_state: *std.heap.ArenaAllocator.State,
+        name: NullTerminatedString,
+    ) Allocator.Error!GlobalErrorSet.Index {
+        if (name == .empty) return .none;
+        const hash = std.hash.uint32(@intFromEnum(name));
+        var map = ges.shared.map.acquire();
+        const Map = @TypeOf(map);
+        var map_mask = map.header().mask();
+        const names = ges.shared.names.acquire();
+        var map_index = hash;
+        while (true) : (map_index += 1) {
+            map_index &= map_mask;
+            const entry = &map.entries[map_index];
+            const index = entry.acquire();
+            if (index == .none) break;
+            if (entry.hash != hash) continue;
+            if (names.view().items(.@"0")[@intFromEnum(index) - 1] == name) return index;
+        }
+        ges.mutate.mutex.lock();
+        defer ges.mutate.mutex.unlock();
+        if (map.entries != ges.shared.map.entries) {
+            map = ges.shared.map;
+            map_mask = map.header().mask();
+            map_index = hash;
+        }
+        while (true) : (map_index += 1) {
+            map_index &= map_mask;
+            const entry = &map.entries[map_index];
+            const index = entry.value;
+            if (index == .none) break;
+            if (entry.hash != hash) continue;
+            if (names.view().items(.@"0")[@intFromEnum(index) - 1] == name) return index;
+        }
+        const mutable_names: Names.Mutable = .{
+            .gpa = gpa,
+            .arena = arena_state,
+            .mutate = &ges.mutate.list,
+            .list = &ges.shared.names,
+        };
+        try mutable_names.ensureUnusedCapacity(1);
+        const map_header = map.header().*;
+        if (ges.mutate.list.len < map_header.capacity * 3 / 5) {
+            mutable_names.appendAssumeCapacity(.{name});
+            const index: GlobalErrorSet.Index = @enumFromInt(mutable_names.mutate.len);
+            const entry = &map.entries[map_index];
+            entry.hash = hash;
+            entry.release(index);
+            return index;
+        }
+        var arena = arena_state.promote(gpa);
+        defer arena_state.* = arena.state;
+        const new_map_capacity = map_header.capacity * 2;
+        const new_map_buf = try arena.allocator().alignedAlloc(
+            u8,
+            Map.alignment,
+            Map.entries_offset + new_map_capacity * @sizeOf(Map.Entry),
+        );
+        const new_map: Map = .{ .entries = @ptrCast(new_map_buf[Map.entries_offset..].ptr) };
+        new_map.header().* = .{ .capacity = new_map_capacity };
+        @memset(new_map.entries[0..new_map_capacity], .{ .value = .none, .hash = undefined });
+        const new_map_mask = new_map.header().mask();
+        map_index = 0;
+        while (map_index < map_header.capacity) : (map_index += 1) {
+            const entry = &map.entries[map_index];
+            const index = entry.value;
+            if (index == .none) continue;
+            const item_hash = entry.hash;
+            var new_map_index = item_hash;
+            while (true) : (new_map_index += 1) {
+                new_map_index &= new_map_mask;
+                const new_entry = &new_map.entries[new_map_index];
+                if (new_entry.value != .none) continue;
+                new_entry.* = .{
+                    .value = index,
+                    .hash = item_hash,
+                };
+                break;
+            }
+        }
+        map = new_map;
+        map_index = hash;
+        while (true) : (map_index += 1) {
+            map_index &= new_map_mask;
+            if (map.entries[map_index].value == .none) break;
+        }
+        mutable_names.appendAssumeCapacity(.{name});
+        const index: GlobalErrorSet.Index = @enumFromInt(mutable_names.mutate.len);
+        map.entries[map_index] = .{ .value = index, .hash = hash };
+        ges.shared.map.release(new_map);
+        return index;
+    }
+    fn getErrorValueIfExists(
+        ges: *const GlobalErrorSet,
+        name: NullTerminatedString,
+    ) ?GlobalErrorSet.Index {
+        if (name == .empty) return .none;
+        const hash = std.hash.uint32(@intFromEnum(name));
+        const map = ges.shared.map.acquire();
+        const map_mask = map.header().mask();
+        const names_items = ges.shared.names.acquire().view().items(.@"0");
+        var map_index = hash;
+        while (true) : (map_index += 1) {
+            map_index &= map_mask;
+            const entry = &map.entries[map_index];
+            const index = entry.acquire();
+            if (index == .none) return null;
+            if (entry.hash != hash) continue;
+            if (names_items[@intFromEnum(index) - 1] == name) return index;
+        }
+    }
+};
+pub fn getErrorValue(
+    ip: *InternPool,
+    gpa: Allocator,
+    tid: Zcu.PerThread.Id,
+    name: NullTerminatedString,
+) Allocator.Error!Zcu.ErrorInt {
+    return @intFromEnum(try ip.global_error_set.getErrorValue(gpa, &ip.getLocal(tid).mutate.arena, name));
+}
+pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString) ?Zcu.ErrorInt {
+    return @intFromEnum(ip.global_error_set.getErrorValueIfExists(name) orelse return null);
+}

src/Sema.zig+59-54

 @@ -835,12 +835,11 @@ pub const Block = struct {
     }
     fn trackZir(block: *Block, inst: Zir.Inst.Index) Allocator.Error!InternPool.TrackedInst.Index {
-        const sema = block.sema;
+        const pt = block.sema.pt;
-        const gpa = sema.gpa;
+        return pt.zcu.intern_pool.trackZir(pt.zcu.gpa, pt.tid, .{
-        const zcu = sema.pt.zcu;
+            .file = block.getFileScopeIndex(pt.zcu),
-        const ip = &zcu.intern_pool;
+            .inst = inst,
-        const file_index = block.getFileScopeIndex(zcu);
+        });
-        return ip.trackZir(gpa, file_index, inst);
     }
 };
 @@ -2878,7 +2877,7 @@ fn createAnonymousDeclTypeNamed(
     switch (name_strategy) {
         .anon => {}, // handled after switch
         .parent => {
-            try zcu.initNewAnonDecl(new_decl_index, val, block.type_name_ctx);
+            try pt.initNewAnonDecl(new_decl_index, val, block.type_name_ctx, .none);
             return new_decl_index;
         },
         .func => func_strat: {
 @@ -2923,7 +2922,7 @@ fn createAnonymousDeclTypeNamed(
             try writer.writeByte(')');
             const name = try ip.getOrPutString(gpa, pt.tid, buf.items, .no_embedded_nulls);
-            try zcu.initNewAnonDecl(new_decl_index, val, name);
+            try pt.initNewAnonDecl(new_decl_index, val, name, .none);
             return new_decl_index;
         },
         .dbg_var => {
 @@ -2937,7 +2936,7 @@ fn createAnonymousDeclTypeNamed(
                     const name = try ip.getOrPutStringFmt(gpa, pt.tid, "{}.{s}", .{
                         block.type_name_ctx.fmt(ip), zir_data[i].str_op.getStr(sema.code),
                     }, .no_embedded_nulls);
-                    try zcu.initNewAnonDecl(new_decl_index, val, name);
+                    try pt.initNewAnonDecl(new_decl_index, val, name, .none);
                     return new_decl_index;
                 },
                 else => {},
 @@ -2958,7 +2957,7 @@ fn createAnonymousDeclTypeNamed(
     const name = ip.getOrPutStringFmt(gpa, pt.tid, "{}__{s}_{d}", .{
         block.type_name_ctx.fmt(ip), anon_prefix, @intFromEnum(new_decl_index),
     }, .no_embedded_nulls) catch unreachable;
-    try zcu.initNewAnonDecl(new_decl_index, val, name);
+    try pt.initNewAnonDecl(new_decl_index, val, name, .none);
     return new_decl_index;
 }
 @@ -3474,7 +3473,7 @@ fn zirErrorSetDecl(
         const name_index: Zir.NullTerminatedString = @enumFromInt(sema.code.extra[extra_index]);
         const name = sema.code.nullTerminatedString(name_index);
         const name_ip = try mod.intern_pool.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
-        _ = try mod.getErrorValue(name_ip);
+        _ = try pt.getErrorValue(name_ip);
         const result = names.getOrPutAssumeCapacity(name_ip);
         assert(!result.found_existing); // verified in AstGen
     }
 @@ -5527,13 +5526,12 @@ fn failWithBadStructFieldAccess(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const decl = zcu.declPtr(struct_type.decl.unwrap().?);
-    const fqn = try decl.fullyQualifiedName(pt);
     const msg = msg: {
         const msg = try sema.errMsg(
             field_src,
             "no field named '{}' in struct '{}'",
-            .{ field_name.fmt(ip), fqn.fmt(ip) },
+            .{ field_name.fmt(ip), decl.fqn.fmt(ip) },
         );
         errdefer msg.destroy(sema.gpa);
         try sema.errNote(struct_ty.srcLoc(zcu), msg, "struct declared here", .{});
 @@ -5554,15 +5552,13 @@ fn failWithBadUnionFieldAccess(
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
     const gpa = sema.gpa;
     const decl = zcu.declPtr(union_obj.decl);
-    const fqn = try decl.fullyQualifiedName(pt);
     const msg = msg: {
         const msg = try sema.errMsg(
             field_src,
             "no field named '{}' in union '{}'",
-            .{ field_name.fmt(ip), fqn.fmt(ip) },
+            .{ field_name.fmt(ip), decl.fqn.fmt(ip) },
         );
         errdefer msg.destroy(gpa);
         try sema.errNote(union_ty.srcLoc(zcu), msg, "union declared here", .{});
 @@ -6059,7 +6055,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
         else => |e| return e,
     };
-    const result = zcu.importPkg(c_import_mod) catch |err|
+    const result = pt.importPkg(c_import_mod) catch |err|
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
     const path_digest = zcu.filePathDigest(result.file_index);
 @@ -6721,13 +6717,7 @@ fn addDbgVar(
     if (block.need_debug_scope) |ptr| ptr.* = true;
     // Add the name to the AIR.
-    const name_extra_index: u32 = @intCast(sema.air_extra.items.len);
+    const name_extra_index = try sema.appendAirString(name);
-    const elements_used = name.len / 4 + 1;
-    try sema.air_extra.ensureUnusedCapacity(sema.gpa, elements_used);
-    const buffer = mem.sliceAsBytes(sema.air_extra.unusedCapacitySlice());
-    @memcpy(buffer[0..name.len], name);
-    buffer[name.len] = 0;
-    sema.air_extra.items.len += elements_used;
     _ = try block.addInst(.{
         .tag = air_tag,
 @@ -6738,6 +6728,16 @@ fn addDbgVar(
     });
 }
+pub fn appendAirString(sema: *Sema, str: []const u8) Allocator.Error!u32 {
+    const str_extra_index: u32 = @intCast(sema.air_extra.items.len);
+    const elements_used = str.len / 4 + 1;
+    const elements = try sema.air_extra.addManyAsSlice(sema.gpa, elements_used);
+    const buffer = mem.sliceAsBytes(elements);
+    @memcpy(buffer[0..str.len], str);
+    buffer[str.len] = 0;
+    return str_extra_index;
+}
 fn zirDeclRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const mod = pt.zcu;
 @@ -8357,13 +8357,6 @@ fn instantiateGenericCall(
             }
         } else {
             // The parameter is runtime-known.
-            child_sema.inst_map.putAssumeCapacityNoClobber(param_inst, try child_block.addInst(.{
-                .tag = .arg,
-                .data = .{ .arg = .{
-                    .ty = Air.internedToRef(arg_ty.toIntern()),
-                    .src_index = @intCast(arg_index),
-                } },
-            }));
             const param_name: Zir.NullTerminatedString = switch (param_tag) {
                 .param_anytype => fn_zir.instructions.items(.data)[@intFromEnum(param_inst)].str_tok.start,
                 .param => name: {
 @@ -8373,6 +8366,16 @@ fn instantiateGenericCall(
                 },
                 else => unreachable,
             };
+            child_sema.inst_map.putAssumeCapacityNoClobber(param_inst, try child_block.addInst(.{
+                .tag = .arg,
+                .data = .{ .arg = .{
+                    .ty = Air.internedToRef(arg_ty.toIntern()),
+                    .name = if (child_block.ownerModule().strip)
+                        .none
+                    else
+                        @enumFromInt(try sema.appendAirString(fn_zir.nullTerminatedString(param_name))),
+                } },
+            }));
             try child_block.params.append(sema.arena, .{
                 .ty = arg_ty.toIntern(), // This is the type after coercion
                 .is_comptime = false, // We're adding only runtime args to the instantiation
 @@ -8702,7 +8705,7 @@ fn zirErrorValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
         inst_data.get(sema.code),
         .no_embedded_nulls,
     );
-    _ = try pt.zcu.getErrorValue(name);
+    _ = try pt.getErrorValue(name);
     // Create an error set type with only this error value, and return the value.
     const error_set_type = try pt.singleErrorSetType(name);
     return Air.internedToRef((try pt.intern(.{ .err = .{
 @@ -8732,7 +8735,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
         const err_name = ip.indexToKey(val.toIntern()).err.name;
         return Air.internedToRef((try pt.intValue(
             err_int_ty,
-            try mod.getErrorValue(err_name),
+            try pt.getErrorValue(err_name),
         )).toIntern());
     }
 @@ -8743,10 +8746,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
             const names = ip.indexToKey(err_set_ty_index).error_set_type.names;
             switch (names.len) {
                 0 => return Air.internedToRef((try pt.intValue(err_int_ty, 0)).toIntern()),
-                1 => {
+                1 => return pt.intRef(err_int_ty, ip.getErrorValueIfExists(names.get(ip)[0]).?),
-                    const int: Module.ErrorInt = @intCast(mod.global_error_set.getIndex(names.get(ip)[0]).?);
-                    return pt.intRef(err_int_ty, int);
-                },
                 else => {},
             }
         },
 @@ -8762,6 +8762,7 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     const pt = sema.pt;
     const mod = pt.zcu;
+    const ip = &mod.intern_pool;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const src = block.nodeOffset(extra.node);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 @@ -8771,11 +8772,16 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
     if (try sema.resolveDefinedValue(block, operand_src, operand)) |value| {
         const int = try sema.usizeCast(block, operand_src, try value.toUnsignedIntSema(pt));
-        if (int > mod.global_error_set.count() or int == 0)
+        if (int > len: {
+            const mutate = &ip.global_error_set.mutate;
+            mutate.mutex.lock();
+            defer mutate.mutex.unlock();
+            break :len mutate.list.len;
+        } or int == 0)
             return sema.fail(block, operand_src, "integer value '{d}' represents no error", .{int});
         return Air.internedToRef((try pt.intern(.{ .err = .{
             .ty = .anyerror_type,
-            .name = mod.global_error_set.keys()[int],
+            .name = ip.global_error_set.shared.names.acquire().view().items(.@"0")[int - 1],
         } })));
     }
     try sema.requireRuntimeBlock(block, src, operand_src);
 @@ -13943,7 +13949,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const operand_src = block.tokenOffset(inst_data.src_tok);
     const operand = inst_data.get(sema.code);
-    const result = zcu.importFile(block.getFileScope(zcu), operand) catch |err| switch (err) {
+    const result = pt.importFile(block.getFileScope(zcu), operand) catch |err| switch (err) {
         error.ImportOutsideModulePath => {
             return sema.fail(block, operand_src, "import of file outside module path: '{s}'", .{operand});
         },
 @@ -14002,7 +14008,7 @@ fn zirRetErrValueCode(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.R
         inst_data.get(sema.code),
         .no_embedded_nulls,
     );
-    _ = try mod.getErrorValue(name);
+    _ = try pt.getErrorValue(name);
     const error_set_type = try pt.singleErrorSetType(name);
     return Air.internedToRef((try pt.intern(.{ .err = .{
         .ty = error_set_type.toIntern(),
 @@ -19561,7 +19567,7 @@ fn zirRetErrValue(
         inst_data.get(sema.code),
         .no_embedded_nulls,
     );
-    _ = try mod.getErrorValue(err_name);
+    _ = try pt.getErrorValue(err_name);
     // Return the error code from the function.
     const error_set_type = try pt.singleErrorSetType(err_name);
     const result_inst = Air.internedToRef((try pt.intern(.{ .err = .{
 @@ -21604,7 +21610,7 @@ fn zirReify(
                 const name = try sema.sliceToIpString(block, src, name_val, .{
                     .needed_comptime_reason = "error set contents must be comptime-known",
                 });
-                _ = try mod.getErrorValue(name);
+                _ = try pt.getErrorValue(name);
                 const gop = names.getOrPutAssumeCapacity(name);
                 if (gop.found_existing) {
                     return sema.fail(block, src, "duplicate error '{}'", .{
 @@ -26500,7 +26506,7 @@ fn zirBuiltinExtern(
     const new_decl_index = try pt.allocateNewDecl(sema.owner_decl.src_namespace);
     errdefer pt.destroyDecl(new_decl_index);
     const new_decl = mod.declPtr(new_decl_index);
-    try mod.initNewAnonDecl(
+    try pt.initNewAnonDecl(
         new_decl_index,
         Value.fromInterned(
             if (Type.fromInterned(ptr_info.child).zigTypeTag(mod) == .Fn)
 @@ -26522,6 +26528,7 @@ fn zirBuiltinExtern(
                 } }),
         ),
         options.name,
+        .none,
     );
     new_decl.owns_tv = true;
     // Note that this will queue the anon decl for codegen, so that the backend can
 @@ -27481,7 +27488,7 @@ fn fieldVal(
                         },
                         .simple_type => |t| {
                             assert(t == .anyerror);
-                            _ = try mod.getErrorValue(field_name);
+                            _ = try pt.getErrorValue(field_name);
                         },
                         else => unreachable,
                     }
 @@ -27721,7 +27728,7 @@ fn fieldPtr(
                         },
                         .simple_type => |t| {
                             assert(t == .anyerror);
-                            _ = try mod.getErrorValue(field_name);
+                            _ = try pt.getErrorValue(field_name);
                         },
                         else => unreachable,
                     }
 @@ -36735,24 +36742,23 @@ fn generateUnionTagTypeNumbered(
     const new_decl_index = try pt.allocateNewDecl(block.namespace);
     errdefer pt.destroyDecl(new_decl_index);
-    const fqn = try union_owner_decl.fullyQualifiedName(pt);
     const name = try ip.getOrPutStringFmt(
         gpa,
         pt.tid,
         "@typeInfo({}).Union.tag_type.?",
-        .{fqn.fmt(ip)},
+        .{union_owner_decl.fqn.fmt(ip)},
         .no_embedded_nulls,
     );
-    try mod.initNewAnonDecl(
+    try pt.initNewAnonDecl(
         new_decl_index,
         Value.@"unreachable",
         name,
+        name.toOptional(),
     );
     errdefer pt.abortAnonDecl(new_decl_index);
     const new_decl = mod.declPtr(new_decl_index);
     new_decl.owns_tv = true;
-    new_decl.name_fully_qualified = true;
     const enum_ty = try ip.getGeneratedTagEnumType(gpa, pt.tid, .{
         .decl = new_decl_index,
 @@ -36784,22 +36790,21 @@ fn generateUnionTagTypeSimple(
     const gpa = sema.gpa;
     const new_decl_index = new_decl_index: {
-        const fqn = try union_owner_decl.fullyQualifiedName(pt);
         const new_decl_index = try pt.allocateNewDecl(block.namespace);
         errdefer pt.destroyDecl(new_decl_index);
         const name = try ip.getOrPutStringFmt(
             gpa,
             pt.tid,
             "@typeInfo({}).Union.tag_type.?",
-            .{fqn.fmt(ip)},
+            .{union_owner_decl.fqn.fmt(ip)},
             .no_embedded_nulls,
         );
-        try mod.initNewAnonDecl(
+        try pt.initNewAnonDecl(
             new_decl_index,
             Value.@"unreachable",
             name,
+            name.toOptional(),
         );
-        mod.declPtr(new_decl_index).name_fully_qualified = true;
         break :new_decl_index new_decl_index;
     };
     errdefer pt.abortAnonDecl(new_decl_index);

src/Type.zig+9-9

 @@ -268,10 +268,10 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
             return;
         },
         .inferred_error_set_type => |func_index| {
-            try writer.writeAll("@typeInfo(@typeInfo(@TypeOf(");
             const owner_decl = mod.funcOwnerDeclPtr(func_index);
-            try owner_decl.renderFullyQualifiedName(mod, writer);
+            try writer.print("@typeInfo(@typeInfo(@TypeOf({})).Fn.return_type.?).ErrorUnion.error_set", .{
-            try writer.writeAll(")).Fn.return_type.?).ErrorUnion.error_set");
+                owner_decl.fqn.fmt(ip),
+            });
         },
         .error_set_type => |error_set_type| {
             const names = error_set_type.names;
 @@ -334,10 +334,10 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
             const struct_type = ip.loadStructType(ty.toIntern());
             if (struct_type.decl.unwrap()) |decl_index| {
                 const decl = mod.declPtr(decl_index);
-                try decl.renderFullyQualifiedName(mod, writer);
+                try writer.print("{}", .{decl.fqn.fmt(ip)});
             } else if (ip.loadStructType(ty.toIntern()).namespace.unwrap()) |namespace_index| {
                 const namespace = mod.namespacePtr(namespace_index);
-                try namespace.renderFullyQualifiedName(mod, .empty, writer);
+                try namespace.renderFullyQualifiedName(ip, .empty, writer);
             } else {
                 try writer.writeAll("@TypeOf(.{})");
             }
 @@ -367,15 +367,15 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
         .union_type => {
             const decl = mod.declPtr(ip.loadUnionType(ty.toIntern()).decl);
-            try decl.renderFullyQualifiedName(mod, writer);
+            try writer.print("{}", .{decl.fqn.fmt(ip)});
         },
         .opaque_type => {
             const decl = mod.declPtr(ip.loadOpaqueType(ty.toIntern()).decl);
-            try decl.renderFullyQualifiedName(mod, writer);
+            try writer.print("{}", .{decl.fqn.fmt(ip)});
         },
         .enum_type => {
             const decl = mod.declPtr(ip.loadEnumType(ty.toIntern()).decl);
-            try decl.renderFullyQualifiedName(mod, writer);
+            try writer.print("{}", .{decl.fqn.fmt(ip)});
         },
         .func_type => |fn_info| {
             if (fn_info.is_noinline) {
 @@ -3451,7 +3451,7 @@ pub fn typeDeclInst(ty: Type, zcu: *const Zcu) ?InternPool.TrackedInst.Index {
     };
 }
-pub fn typeDeclSrcLine(ty: Type, zcu: *const Zcu) ?u32 {
+pub fn typeDeclSrcLine(ty: Type, zcu: *Zcu) ?u32 {
     const ip = &zcu.intern_pool;
     const tracked = switch (ip.indexToKey(ty.toIntern())) {
         .struct_type, .union_type, .opaque_type, .enum_type => |info| switch (info) {

src/Value.zig+5-5

src/Zcu.zig+61-312

...	@@ -102,7 +102,7 @@ multi_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {	...	@@ -102,7 +102,7 @@ multi_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {
102	/// `Compilation.update` of the process for a given `Compilation`.	102	/// `Compilation.update` of the process for a given `Compilation`.
103	///	103	///
104	/// Indexes correspond 1:1 to `files`.	104	/// Indexes correspond 1:1 to `files`.
105	import_table: std.StringArrayHashMapUnmanaged(*File) = .{},	105	import_table: std.StringArrayHashMapUnmanaged(File.Index) = .{},
106		106
107	/// The set of all the files which have been loaded with `@embedFile` in the Module.	107	/// The set of all the files which have been loaded with `@embedFile` in the Module.
108	/// We keep track of this in order to iterate over it and check which files have been	108	/// We keep track of this in order to iterate over it and check which files have been
...	@@ -141,9 +141,6 @@ failed_exports: std.AutoArrayHashMapUnmanaged(u32, *ErrorMsg) = .{},	...	@@ -141,9 +141,6 @@ failed_exports: std.AutoArrayHashMapUnmanaged(u32, *ErrorMsg) = .{},
141	/// are stored here.	141	/// are stored here.
142	cimport_errors: std.AutoArrayHashMapUnmanaged(AnalUnit, std.zig.ErrorBundle) = .{},	142	cimport_errors: std.AutoArrayHashMapUnmanaged(AnalUnit, std.zig.ErrorBundle) = .{},
143		143
144	/// Key is the error name, index is the error tag value. Index 0 has a length-0 string.
145	global_error_set: GlobalErrorSet = .{},
146
147	/// Maximum amount of distinct error values, set by --error-limit	144	/// Maximum amount of distinct error values, set by --error-limit
148	error_limit: ErrorInt,	145	error_limit: ErrorInt,
149		146
...	@@ -326,7 +323,10 @@ pub const Reference = struct {	...	@@ -326,7 +323,10 @@ pub const Reference = struct {
326	};	323	};
327		324
328	pub const Decl = struct {	325	pub const Decl = struct {
		326	/// Equal to `fqn` if already fully qualified.
329	name: InternPool.NullTerminatedString,	327	name: InternPool.NullTerminatedString,
		328	/// Fully qualified name.
		329	fqn: InternPool.NullTerminatedString,
330	/// The most recent Value of the Decl after a successful semantic analysis.	330	/// The most recent Value of the Decl after a successful semantic analysis.
331	/// Populated when `has_tv`.	331	/// Populated when `has_tv`.
332	val: Value,	332	val: Value,
...	@@ -384,8 +384,6 @@ pub const Decl = struct {	...	@@ -384,8 +384,6 @@ pub const Decl = struct {
384	is_pub: bool,	384	is_pub: bool,
385	/// Whether the corresponding AST decl has a `export` keyword.	385	/// Whether the corresponding AST decl has a `export` keyword.
386	is_exported: bool,	386	is_exported: bool,
387	/// If true `name` is already fully qualified.
388	name_fully_qualified: bool = false,
389	/// What kind of a declaration is this.	387	/// What kind of a declaration is this.
390	kind: Kind,	388	kind: Kind,
391		389
...	@@ -408,25 +406,6 @@ pub const Decl = struct {	...	@@ -408,25 +406,6 @@ pub const Decl = struct {
408	return extra.data.getBodies(@intCast(extra.end), zir);	406	return extra.data.getBodies(@intCast(extra.end), zir);
409	}	407	}
410		408
411	pub fn renderFullyQualifiedName(decl: Decl, zcu: *Zcu, writer: anytype) !void {
412	if (decl.name_fully_qualified) {
413	try writer.print("{}", .{decl.name.fmt(&zcu.intern_pool)});
414	} else {
415	try zcu.namespacePtr(decl.src_namespace).renderFullyQualifiedName(zcu, decl.name, writer);
416	}
417	}
418
419	pub fn renderFullyQualifiedDebugName(decl: Decl, zcu: *Zcu, writer: anytype) !void {
420	return zcu.namespacePtr(decl.src_namespace).renderFullyQualifiedDebugName(zcu, decl.name, writer);
421	}
422
423	pub fn fullyQualifiedName(decl: Decl, pt: Zcu.PerThread) !InternPool.NullTerminatedString {
424	return if (decl.name_fully_qualified)
425	decl.name
426	else
427	pt.zcu.namespacePtr(decl.src_namespace).fullyQualifiedName(pt, decl.name);
428	}
429
430	pub fn typeOf(decl: Decl, zcu: *const Zcu) Type {	409	pub fn typeOf(decl: Decl, zcu: *const Zcu) Type {
431	assert(decl.has_tv);	410	assert(decl.has_tv);
432	return decl.val.typeOf(zcu);	411	return decl.val.typeOf(zcu);
...	@@ -646,23 +625,27 @@ pub const Namespace = struct {	...	@@ -646,23 +625,27 @@ pub const Namespace = struct {
646	return zcu.fileByIndex(ns.file_scope);	625	return zcu.fileByIndex(ns.file_scope);
647	}	626	}
648		627
		628	pub fn fileScopeIp(ns: Namespace, ip: InternPool) File {
		629	return ip.filePtr(ns.file_scope);
		630	}
		631
649	// This renders e.g. "std.fs.Dir.OpenOptions"	632	// This renders e.g. "std.fs.Dir.OpenOptions"
650	pub fn renderFullyQualifiedName(	633	pub fn renderFullyQualifiedName(
651	ns: Namespace,	634	ns: Namespace,
652	zcu: *Zcu,	635	ip: *InternPool,
653	name: InternPool.NullTerminatedString,	636	name: InternPool.NullTerminatedString,
654	writer: anytype,	637	writer: anytype,
655	) @TypeOf(writer).Error!void {	638	) @TypeOf(writer).Error!void {
656	if (ns.parent.unwrap()) \|parent\| {	639	if (ns.parent.unwrap()) \|parent\| {
657	try zcu.namespacePtr(parent).renderFullyQualifiedName(	640	try ip.namespacePtr(parent).renderFullyQualifiedName(
658	zcu,	641	ip,
659	zcu.declPtr(ns.decl_index).name,	642	ip.declPtr(ns.decl_index).name,
660	writer,	643	writer,
661	);	644	);
662	} else {	645	} else {
663	try ns.fileScope(zcu).renderFullyQualifiedName(writer);	646	try ns.fileScopeIp(ip).renderFullyQualifiedName(writer);
664	}	647	}
665	if (name != .empty) try writer.print(".{}", .{name.fmt(&zcu.intern_pool)});	648	if (name != .empty) try writer.print(".{}", .{name.fmt(ip)});
666	}	649	}
667		650
668	/// This renders e.g. "std/fs.zig:Dir.OpenOptions"	651	/// This renders e.g. "std/fs.zig:Dir.OpenOptions"
...	@@ -686,46 +669,45 @@ pub const Namespace = struct {	...	@@ -686,46 +669,45 @@ pub const Namespace = struct {
686	if (name != .empty) try writer.print("{c}{}", .{ sep, name.fmt(&zcu.intern_pool) });	669	if (name != .empty) try writer.print("{c}{}", .{ sep, name.fmt(&zcu.intern_pool) });
687	}	670	}
688		671
689	pub fn fullyQualifiedName(	672	pub fn internFullyQualifiedName(
690	ns: Namespace,	673	ns: Namespace,
691	pt: Zcu.PerThread,	674	ip: *InternPool,
		675	gpa: Allocator,
		676	tid: Zcu.PerThread.Id,
692	name: InternPool.NullTerminatedString,	677	name: InternPool.NullTerminatedString,
693	) !InternPool.NullTerminatedString {	678	) !InternPool.NullTerminatedString {
694	const zcu = pt.zcu;	679	const strings = ip.getLocal(tid).getMutableStrings(gpa);
695	const ip = &zcu.intern_pool;
696
697	const gpa = zcu.gpa;
698	const strings = ip.getLocal(pt.tid).getMutableStrings(gpa);
699	// Protects reads of interned strings from being reallocated during the call to	680	// Protects reads of interned strings from being reallocated during the call to
700	// renderFullyQualifiedName.	681	// renderFullyQualifiedName.
701	const slice = try strings.addManyAsSlice(count: {	682	const slice = try strings.addManyAsSlice(count: {
702	var count: usize = name.length(ip) + 1;	683	var count: usize = name.length(ip) + 1;
703	var cur_ns = &ns;	684	var cur_ns = &ns;
704	while (true) {	685	while (true) {
705	const decl = zcu.declPtr(cur_ns.decl_index);	686	const decl = ip.declPtr(cur_ns.decl_index);
706	cur_ns = zcu.namespacePtr(cur_ns.parent.unwrap() orelse {	687	cur_ns = ip.namespacePtr(cur_ns.parent.unwrap() orelse {
707	count += ns.fileScope(zcu).fullyQualifiedNameLen();	688	count += ns.fileScopeIp(ip).fullyQualifiedNameLen();
708	break :count count;	689	break :count count;
709	});	690	});
710	count += decl.name.length(ip) + 1;	691	count += decl.name.length(ip) + 1;
711	}	692	}
712	});	693	});
713	var fbs = std.io.fixedBufferStream(slice[0]);	694	var fbs = std.io.fixedBufferStream(slice[0]);
714	ns.renderFullyQualifiedName(zcu, name, fbs.writer()) catch unreachable;	695	ns.renderFullyQualifiedName(ip, name, fbs.writer()) catch unreachable;
715	assert(fbs.pos == slice[0].len);	696	assert(fbs.pos == slice[0].len);
716		697
717	// Sanitize the name for nvptx which is more restrictive.	698	// Sanitize the name for nvptx which is more restrictive.
718	// TODO This should be handled by the backend, not the frontend. Have a	699	// TODO This should be handled by the backend, not the frontend. Have a
719	// look at how the C backend does it for inspiration.	700	// look at how the C backend does it for inspiration.
720	const cpu_arch = zcu.root_mod.resolved_target.result.cpu.arch;	701	// FIXME This has bitrotted and is no longer able to be implemented here.
721	if (cpu_arch.isNvptx()) {	702	//const cpu_arch = zcu.root_mod.resolved_target.result.cpu.arch;
722	for (slice[0]) \|byte\| switch (byte.) {	703	//if (cpu_arch.isNvptx()) {
723	'{', '}', '', '[', ']', '(', ')', ',', ' ', '\'' => byte. = '_',	704	// for (slice[0]) \|byte\| switch (byte.) {
724	else => {},	705	// '{', '}', '', '[', ']', '(', ')', ',', ' ', '\'' => byte. = '_',
725	};	706	// else => {},
726	}	707	// };
		708	//}
727		709
728	return ip.getOrPutTrailingString(gpa, pt.tid, @intCast(slice[0].len), .no_embedded_nulls);	710	return ip.getOrPutTrailingString(gpa, tid, @intCast(slice[0].len), .no_embedded_nulls);
729	}	711	}
730		712
731	pub fn getType(ns: Namespace, zcu: *Zcu) Type {	713	pub fn getType(ns: Namespace, zcu: *Zcu) Type {
...	@@ -882,7 +864,7 @@ pub const File = struct {	...	@@ -882,7 +864,7 @@ pub const File = struct {
882	};	864	};
883	}	865	}
884		866
885	pub fn fullyQualifiedName(file: File, pt: Zcu.PerThread) !InternPool.NullTerminatedString {	867	pub fn internFullyQualifiedName(file: File, pt: Zcu.PerThread) !InternPool.NullTerminatedString {
886	const gpa = pt.zcu.gpa;	868	const gpa = pt.zcu.gpa;
887	const ip = &pt.zcu.intern_pool;	869	const ip = &pt.zcu.intern_pool;
888	const strings = ip.getLocal(pt.tid).getMutableStrings(gpa);	870	const strings = ip.getLocal(pt.tid).getMutableStrings(gpa);
...	@@ -910,7 +892,7 @@ pub const File = struct {	...	@@ -910,7 +892,7 @@ pub const File = struct {
910	}	892	}
911		893
912	/// Add a reference to this file during AstGen.	894	/// Add a reference to this file during AstGen.
913	pub fn addReference(file: *File, zcu: Zcu, ref: File.Reference) !void {	895	pub fn addReference(file: File, zcu: Zcu, ref: File.Reference) !void {
914	// Don't add the same module root twice. Note that since we always add module roots at the	896	// Don't add the same module root twice. Note that since we always add module roots at the
915	// front of the references array (see below), this loop is actually O(1) on valid code.	897	// front of the references array (see below), this loop is actually O(1) on valid code.
916	if (ref == .root) {	898	if (ref == .root) {
...	@@ -942,7 +924,7 @@ pub const File = struct {	...	@@ -942,7 +924,7 @@ pub const File = struct {
942		924
943	/// Mark this file and every file referenced by it as multi_pkg and report an	925	/// Mark this file and every file referenced by it as multi_pkg and report an
944	/// astgen_failure error for them. AstGen must have completed in its entirety.	926	/// astgen_failure error for them. AstGen must have completed in its entirety.
945	pub fn recursiveMarkMultiPkg(file: File, mod: Module) void {	927	pub fn recursiveMarkMultiPkg(file: *File, pt: Zcu.PerThread) void {
946	file.multi_pkg = true;	928	file.multi_pkg = true;
947	file.status = .astgen_failure;	929	file.status = .astgen_failure;
948		930
...	@@ -962,9 +944,9 @@ pub const File = struct {	...	@@ -962,9 +944,9 @@ pub const File = struct {
962	const import_path = file.zir.nullTerminatedString(item.data.name);	944	const import_path = file.zir.nullTerminatedString(item.data.name);
963	if (mem.eql(u8, import_path, "builtin")) continue;	945	if (mem.eql(u8, import_path, "builtin")) continue;
964		946
965	const res = mod.importFile(file, import_path) catch continue;	947	const res = pt.importFile(file, import_path) catch continue;
966	if (!res.is_pkg and !res.file.multi_pkg) {	948	if (!res.is_pkg and !res.file.multi_pkg) {
967	res.file.recursiveMarkMultiPkg(mod);	949	res.file.recursiveMarkMultiPkg(pt);
968	}	950	}
969	}	951	}
970	}	952	}
...	@@ -1033,6 +1015,14 @@ pub const ErrorMsg = struct {	...	@@ -1033,6 +1015,14 @@ pub const ErrorMsg = struct {
1033	}	1015	}
1034	};	1016	};
1035		1017
		1018	pub const AstGenSrc = union(enum) {
		1019	root,
		1020	import: struct {
		1021	importing_file: Zcu.File.Index,
		1022	import_tok: std.zig.Ast.TokenIndex,
		1023	},
		1024	};
		1025
1036	/// Canonical reference to a position within a source file.	1026	/// Canonical reference to a position within a source file.
1037	pub const SrcLoc = struct {	1027	pub const SrcLoc = struct {
1038	file_scope: *File,	1028	file_scope: *File,
...	@@ -2406,7 +2396,6 @@ pub const CompileError = error{	...	@@ -2406,7 +2396,6 @@ pub const CompileError = error{
2406	pub fn init(mod: *Module, thread_count: usize) !void {	2396	pub fn init(mod: *Module, thread_count: usize) !void {
2407	const gpa = mod.gpa;	2397	const gpa = mod.gpa;
2408	try mod.intern_pool.init(gpa, thread_count);	2398	try mod.intern_pool.init(gpa, thread_count);
2409	try mod.global_error_set.put(gpa, .empty, {});
2410	}	2399	}
2411		2400
2412	pub fn deinit(zcu: *Zcu) void {	2401	pub fn deinit(zcu: *Zcu) void {
...	@@ -2421,8 +2410,7 @@ pub fn deinit(zcu: *Zcu) void {	...	@@ -2421,8 +2410,7 @@ pub fn deinit(zcu: *Zcu) void {
2421	for (zcu.import_table.keys()) \|key\| {	2410	for (zcu.import_table.keys()) \|key\| {
2422	gpa.free(key);	2411	gpa.free(key);
2423	}	2412	}
2424	for (0..zcu.import_table.entries.len) \|file_index_usize\| {	2413	for (zcu.import_table.values()) \|file_index\| {
2425	const file_index: File.Index = @enumFromInt(file_index_usize);
2426	pt.destroyFile(file_index);	2414	pt.destroyFile(file_index);
2427	}	2415	}
2428	zcu.import_table.deinit(gpa);	2416	zcu.import_table.deinit(gpa);
...	@@ -2479,8 +2467,6 @@ pub fn deinit(zcu: *Zcu) void {	...	@@ -2479,8 +2467,6 @@ pub fn deinit(zcu: *Zcu) void {
2479	zcu.single_exports.deinit(gpa);	2467	zcu.single_exports.deinit(gpa);
2480	zcu.multi_exports.deinit(gpa);	2468	zcu.multi_exports.deinit(gpa);
2481		2469
2482	zcu.global_error_set.deinit(gpa);
2483
2484	zcu.potentially_outdated.deinit(gpa);	2470	zcu.potentially_outdated.deinit(gpa);
2485	zcu.outdated.deinit(gpa);	2471	zcu.outdated.deinit(gpa);
2486	zcu.outdated_ready.deinit(gpa);	2472	zcu.outdated_ready.deinit(gpa);
...	@@ -3020,183 +3006,7 @@ pub const ImportFileResult = struct {	...	@@ -3020,183 +3006,7 @@ pub const ImportFileResult = struct {
3020	is_pkg: bool,	3006	is_pkg: bool,
3021	};	3007	};
3022		3008
3023	pub fn importPkg(zcu: Zcu, mod: Package.Module) !ImportFileResult {	3009	pub fn computePathDigest(zcu: Zcu, mod: Package.Module, sub_file_path: []const u8) Cache.BinDigest {
3024	const gpa = zcu.gpa;
3025
3026	// The resolved path is used as the key in the import table, to detect if
3027	// an import refers to the same as another, despite different relative paths
3028	// or differently mapped package names.
3029	const resolved_path = try std.fs.path.resolve(gpa, &.{
3030	mod.root.root_dir.path orelse ".",
3031	mod.root.sub_path,
3032	mod.root_src_path,
3033	});
3034	var keep_resolved_path = false;
3035	defer if (!keep_resolved_path) gpa.free(resolved_path);
3036
3037	const gop = try zcu.import_table.getOrPut(gpa, resolved_path);
3038	errdefer _ = zcu.import_table.pop();
3039	if (gop.found_existing) {
3040	try gop.value_ptr..addReference(zcu., .{ .root = mod });
3041	return .{
3042	.file = gop.value_ptr.*,
3043	.file_index = @enumFromInt(gop.index),
3044	.is_new = false,
3045	.is_pkg = true,
3046	};
3047	}
3048
3049	const ip = &zcu.intern_pool;
3050
3051	try ip.files.ensureUnusedCapacity(gpa, 1);
3052
3053	if (mod.builtin_file) \|builtin_file\| {
3054	keep_resolved_path = true; // It's now owned by import_table.
3055	gop.value_ptr.* = builtin_file;
3056	try builtin_file.addReference(zcu.*, .{ .root = mod });
3057	const path_digest = computePathDigest(zcu, mod, builtin_file.sub_file_path);
3058	ip.files.putAssumeCapacityNoClobber(path_digest, .none);
3059	return .{
3060	.file = builtin_file,
3061	.file_index = @enumFromInt(ip.files.entries.len - 1),
3062	.is_new = false,
3063	.is_pkg = true,
3064	};
3065	}
3066
3067	const sub_file_path = try gpa.dupe(u8, mod.root_src_path);
3068	errdefer gpa.free(sub_file_path);
3069
3070	const new_file = try gpa.create(File);
3071	errdefer gpa.destroy(new_file);
3072
3073	keep_resolved_path = true; // It's now owned by import_table.
3074	gop.value_ptr.* = new_file;
3075	new_file.* = .{
3076	.sub_file_path = sub_file_path,
3077	.source = undefined,
3078	.source_loaded = false,
3079	.tree_loaded = false,
3080	.zir_loaded = false,
3081	.stat = undefined,
3082	.tree = undefined,
3083	.zir = undefined,
3084	.status = .never_loaded,
3085	.mod = mod,
3086	};
3087
3088	const path_digest = computePathDigest(zcu, mod, sub_file_path);
3089
3090	try new_file.addReference(zcu.*, .{ .root = mod });
3091	ip.files.putAssumeCapacityNoClobber(path_digest, .none);
3092	return .{
3093	.file = new_file,
3094	.file_index = @enumFromInt(ip.files.entries.len - 1),
3095	.is_new = true,
3096	.is_pkg = true,
3097	};
3098	}
3099
3100	/// Called from a worker thread during AstGen.
3101	/// Also called from Sema during semantic analysis.
3102	pub fn importFile(
3103	zcu: *Zcu,
3104	cur_file: *File,
3105	import_string: []const u8,
3106	) !ImportFileResult {
3107	const mod = cur_file.mod;
3108
3109	if (std.mem.eql(u8, import_string, "std")) {
3110	return zcu.importPkg(zcu.std_mod);
3111	}
3112	if (std.mem.eql(u8, import_string, "root")) {
3113	return zcu.importPkg(zcu.root_mod);
3114	}
3115	if (mod.deps.get(import_string)) \|pkg\| {
3116	return zcu.importPkg(pkg);
3117	}
3118	if (!mem.endsWith(u8, import_string, ".zig")) {
3119	return error.ModuleNotFound;
3120	}
3121	const gpa = zcu.gpa;
3122
3123	// The resolved path is used as the key in the import table, to detect if
3124	// an import refers to the same as another, despite different relative paths
3125	// or differently mapped package names.
3126	const resolved_path = try std.fs.path.resolve(gpa, &.{
3127	mod.root.root_dir.path orelse ".",
3128	mod.root.sub_path,
3129	cur_file.sub_file_path,
3130	"..",
3131	import_string,
3132	});
3133
3134	var keep_resolved_path = false;
3135	defer if (!keep_resolved_path) gpa.free(resolved_path);
3136
3137	const gop = try zcu.import_table.getOrPut(gpa, resolved_path);
3138	errdefer _ = zcu.import_table.pop();
3139	if (gop.found_existing) return .{
3140	.file = gop.value_ptr.*,
3141	.file_index = @enumFromInt(gop.index),
3142	.is_new = false,
3143	.is_pkg = false,
3144	};
3145
3146	const ip = &zcu.intern_pool;
3147
3148	try ip.files.ensureUnusedCapacity(gpa, 1);
3149
3150	const new_file = try gpa.create(File);
3151	errdefer gpa.destroy(new_file);
3152
3153	const resolved_root_path = try std.fs.path.resolve(gpa, &.{
3154	mod.root.root_dir.path orelse ".",
3155	mod.root.sub_path,
3156	});
3157	defer gpa.free(resolved_root_path);
3158
3159	const sub_file_path = p: {
3160	const relative = try std.fs.path.relative(gpa, resolved_root_path, resolved_path);
3161	errdefer gpa.free(relative);
3162
3163	if (!isUpDir(relative) and !std.fs.path.isAbsolute(relative)) {
3164	break :p relative;
3165	}
3166	return error.ImportOutsideModulePath;
3167	};
3168	errdefer gpa.free(sub_file_path);
3169
3170	log.debug("new importFile. resolved_root_path={s}, resolved_path={s}, sub_file_path={s}, import_string={s}", .{
3171	resolved_root_path, resolved_path, sub_file_path, import_string,
3172	});
3173
3174	keep_resolved_path = true; // It's now owned by import_table.
3175	gop.value_ptr.* = new_file;
3176	new_file.* = .{
3177	.sub_file_path = sub_file_path,
3178	.source = undefined,
3179	.source_loaded = false,
3180	.tree_loaded = false,
3181	.zir_loaded = false,
3182	.stat = undefined,
3183	.tree = undefined,
3184	.zir = undefined,
3185	.status = .never_loaded,
3186	.mod = mod,
3187	};
3188
3189	const path_digest = computePathDigest(zcu, mod, sub_file_path);
3190	ip.files.putAssumeCapacityNoClobber(path_digest, .none);
3191	return .{
3192	.file = new_file,
3193	.file_index = @enumFromInt(ip.files.entries.len - 1),
3194	.is_new = true,
3195	.is_pkg = false,
3196	};
3197	}
3198
3199	fn computePathDigest(zcu: Zcu, mod: Package.Module, sub_file_path: []const u8) Cache.BinDigest {
3200	const want_local_cache = mod == zcu.main_mod;	3010	const want_local_cache = mod == zcu.main_mod;
3201	var path_hash: Cache.HashHelper = .{};	3011	var path_hash: Cache.HashHelper = .{};
3202	path_hash.addBytes(build_options.version);	3012	path_hash.addBytes(build_options.version);
...	@@ -3292,43 +3102,11 @@ pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit	...	@@ -3292,43 +3102,11 @@ pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit
3292	gop.value_ptr.* = @intCast(ref_idx);	3102	gop.value_ptr.* = @intCast(ref_idx);
3293	}	3103	}
3294		3104
3295	pub fn getErrorValue(
3296	mod: *Module,
3297	name: InternPool.NullTerminatedString,
3298	) Allocator.Error!ErrorInt {
3299	const gop = try mod.global_error_set.getOrPut(mod.gpa, name);
3300	return @as(ErrorInt, @intCast(gop.index));
3301	}
3302
3303	pub fn getErrorValueFromSlice(
3304	mod: *Module,
3305	name: []const u8,
3306	) Allocator.Error!ErrorInt {
3307	const interned_name = try mod.intern_pool.getOrPutString(mod.gpa, name);
3308	return getErrorValue(mod, interned_name);
3309	}
3310
3311	pub fn errorSetBits(mod: *Module) u16 {	3105	pub fn errorSetBits(mod: *Module) u16 {
3312	if (mod.error_limit == 0) return 0;	3106	if (mod.error_limit == 0) return 0;
3313	return std.math.log2_int_ceil(ErrorInt, mod.error_limit + 1); // +1 for no error	3107	return std.math.log2_int_ceil(ErrorInt, mod.error_limit + 1); // +1 for no error
3314	}	3108	}
3315		3109
3316	pub fn initNewAnonDecl(
3317	mod: *Module,
3318	new_decl_index: Decl.Index,
3319	val: Value,
3320	name: InternPool.NullTerminatedString,
3321	) Allocator.Error!void {
3322	const new_decl = mod.declPtr(new_decl_index);
3323
3324	new_decl.name = name;
3325	new_decl.val = val;
3326	new_decl.alignment = .none;
3327	new_decl.@"linksection" = .none;
3328	new_decl.has_tv = true;
3329	new_decl.analysis = .complete;
3330	}
3331
3332	pub fn errNote(	3110	pub fn errNote(
3333	mod: *Module,	3111	mod: *Module,
3334	src_loc: LazySrcLoc,	3112	src_loc: LazySrcLoc,
...	@@ -3394,41 +3172,6 @@ pub fn handleUpdateExports(	...	@@ -3394,41 +3172,6 @@ pub fn handleUpdateExports(
3394	};	3172	};
3395	}	3173	}
3396		3174
3397	pub fn reportRetryableFileError(
3398	zcu: *Zcu,
3399	file_index: File.Index,
3400	comptime format: []const u8,
3401	args: anytype,
3402	) error{OutOfMemory}!void {
3403	const gpa = zcu.gpa;
3404	const ip = &zcu.intern_pool;
3405
3406	const file = zcu.fileByIndex(file_index);
3407	file.status = .retryable_failure;
3408
3409	const err_msg = try ErrorMsg.create(
3410	gpa,
3411	.{
3412	.base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
3413	.offset = .entire_file,
3414	},
3415	format,
3416	args,
3417	);
3418	errdefer err_msg.destroy(gpa);
3419
3420	zcu.comp.mutex.lock();
3421	defer zcu.comp.mutex.unlock();
3422
3423	const gop = try zcu.failed_files.getOrPut(gpa, file);
3424	if (gop.found_existing) {
3425	if (gop.value_ptr.*) \|old_err_msg\| {
3426	old_err_msg.destroy(gpa);
3427	}
3428	}
3429	gop.value_ptr.* = err_msg;
3430	}
3431
3432	pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u8) !void {	3175	pub fn addGlobalAssembly(mod: *Module, decl_index: Decl.Index, source: []const u8) !void {
3433	const gop = try mod.global_assembly.getOrPut(mod.gpa, decl_index);	3176	const gop = try mod.global_assembly.getOrPut(mod.gpa, decl_index);
3434	if (gop.found_existing) {	3177	if (gop.found_existing) {
...	@@ -3744,22 +3487,28 @@ pub fn resolveReferences(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, Resolved	...	@@ -3744,22 +3487,28 @@ pub fn resolveReferences(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, Resolved
3744	return result;	3487	return result;
3745	}	3488	}
3746		3489
3747	pub fn fileByIndex(zcu: const Zcu, i: File.Index) File {	3490	pub fn fileByIndex(zcu: Zcu, file_index: File.Index) File {
3748	return zcu.import_table.values()[@intFromEnum(i)];	3491	return zcu.intern_pool.filePtr(file_index);
3749	}	3492	}
3750		3493
3751	/// Returns the `Decl` of the struct that represents this `File`.	3494	/// Returns the `Decl` of the struct that represents this `File`.
3752	pub fn fileRootDecl(zcu: *const Zcu, i: File.Index) Decl.OptionalIndex {	3495	pub fn fileRootDecl(zcu: *const Zcu, file_index: File.Index) Decl.OptionalIndex {
3753	const ip = &zcu.intern_pool;	3496	const ip = &zcu.intern_pool;
3754	return ip.files.values()[@intFromEnum(i)];	3497	const file_index_unwrapped = file_index.unwrap(ip);
		3498	const files = ip.getLocalShared(file_index_unwrapped.tid).files.acquire();
		3499	return files.view().items(.root_decl)[file_index_unwrapped.index];
3755	}	3500	}
3756		3501
3757	pub fn setFileRootDecl(zcu: *Zcu, i: File.Index, root_decl: Decl.OptionalIndex) void {	3502	pub fn setFileRootDecl(zcu: *Zcu, file_index: File.Index, root_decl: Decl.OptionalIndex) void {
3758	const ip = &zcu.intern_pool;	3503	const ip = &zcu.intern_pool;
3759	ip.files.values()[@intFromEnum(i)] = root_decl;	3504	const file_index_unwrapped = file_index.unwrap(ip);
		3505	const files = ip.getLocalShared(file_index_unwrapped.tid).files.acquire();
		3506	files.view().items(.root_decl)[file_index_unwrapped.index] = root_decl;
3760	}	3507	}
3761		3508
3762	pub fn filePathDigest(zcu: *const Zcu, i: File.Index) Cache.BinDigest {	3509	pub fn filePathDigest(zcu: *const Zcu, file_index: File.Index) Cache.BinDigest {
3763	const ip = &zcu.intern_pool;	3510	const ip = &zcu.intern_pool;
3764	return ip.files.keys()[@intFromEnum(i)];	3511	const file_index_unwrapped = file_index.unwrap(ip);
		3512	const files = ip.getLocalShared(file_index_unwrapped.tid).files.acquire();
		3513	return files.view().items(.bin_digest)[file_index_unwrapped.index];
3765	}	3514	}

src/Zcu/PerThread.zig+458-137

...	@@ -342,6 +342,7 @@ pub fn astGenFile(	...	@@ -342,6 +342,7 @@ pub fn astGenFile(
342	/// the Compilation mutex when acting on shared state.	342	/// the Compilation mutex when acting on shared state.
343	fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index, old_zir: Zir) !void {	343	fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index, old_zir: Zir) !void {
344	const zcu = pt.zcu;	344	const zcu = pt.zcu;
		345	const ip = &zcu.intern_pool;
345	const gpa = zcu.gpa;	346	const gpa = zcu.gpa;
346	const new_zir = file.zir;	347	const new_zir = file.zir;
347		348
...	@@ -355,109 +356,117 @@ fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index,	...	@@ -355,109 +356,117 @@ fn updateZirRefs(pt: Zcu.PerThread, file: *Zcu.File, file_index: Zcu.File.Index,
355		356
356	// TODO: this should be done after all AstGen workers complete, to avoid	357	// TODO: this should be done after all AstGen workers complete, to avoid
357	// iterating over this full set for every updated file.	358	// iterating over this full set for every updated file.
358	for (zcu.intern_pool.tracked_insts.keys(), 0..) \|*ti, idx_raw\| {	359	for (ip.locals, 0..) \|*local, tid\| {
359	const ti_idx: InternPool.TrackedInst.Index = @enumFromInt(idx_raw);	360	local.mutate.tracked_insts.mutex.lock();
360	if (ti.file != file_index) continue;	361	defer local.mutate.tracked_insts.mutex.unlock();
361	const old_inst = ti.inst;	362	const tracked_insts_list = local.getMutableTrackedInsts(gpa);
362	ti.inst = inst_map.get(ti.inst) orelse {	363	for (tracked_insts_list.view().items(.@"0"), 0..) \|*tracked_inst, tracked_inst_unwrapped_index\| {
363	// Tracking failed for this instruction. Invalidate associated `src_hash` deps.	364	if (tracked_inst.file != file_index) continue;
364	zcu.comp.mutex.lock();	365	const old_inst = tracked_inst.inst;
365	defer zcu.comp.mutex.unlock();	366	const tracked_inst_index = (InternPool.TrackedInst.Index.Unwrapped{
366	log.debug("tracking failed for %{d}", .{old_inst});	367	.tid = @enumFromInt(tid),
367	try zcu.markDependeeOutdated(.{ .src_hash = ti_idx });	368	.index = @intCast(tracked_inst_unwrapped_index),
368	continue;	369	}).wrap(ip);
369	};	370	tracked_inst.inst = inst_map.get(old_inst) orelse {
		371	// Tracking failed for this instruction. Invalidate associated `src_hash` deps.
		372	zcu.comp.mutex.lock();
		373	defer zcu.comp.mutex.unlock();
		374	log.debug("tracking failed for %{d}", .{old_inst});
		375	try zcu.markDependeeOutdated(.{ .src_hash = tracked_inst_index });
		376	continue;
		377	};
370		378
371	if (old_zir.getAssociatedSrcHash(old_inst)) \|old_hash\| hash_changed: {	379	if (old_zir.getAssociatedSrcHash(old_inst)) \|old_hash\| hash_changed: {
372	if (new_zir.getAssociatedSrcHash(ti.inst)) \|new_hash\| {	380	if (new_zir.getAssociatedSrcHash(tracked_inst.inst)) \|new_hash\| {
373	if (std.zig.srcHashEql(old_hash, new_hash)) {	381	if (std.zig.srcHashEql(old_hash, new_hash)) {
374	break :hash_changed;	382	break :hash_changed;
		383	}
		384	log.debug("hash for (%{d} -> %{d}) changed: {} -> {}", .{
		385	old_inst,
		386	tracked_inst.inst,
		387	std.fmt.fmtSliceHexLower(&old_hash),
		388	std.fmt.fmtSliceHexLower(&new_hash),
		389	});
375	}	390	}
376	log.debug("hash for (%{d} -> %{d}) changed: {} -> {}", .{	391	// The source hash associated with this instruction changed - invalidate relevant dependencies.
377	old_inst,	392	zcu.comp.mutex.lock();
378	ti.inst,	393	defer zcu.comp.mutex.unlock();
379	std.fmt.fmtSliceHexLower(&old_hash),	394	try zcu.markDependeeOutdated(.{ .src_hash = tracked_inst_index });
380	std.fmt.fmtSliceHexLower(&new_hash),
381	});
382	}	395	}
383	// The source hash associated with this instruction changed - invalidate relevant dependencies.
384	zcu.comp.mutex.lock();
385	defer zcu.comp.mutex.unlock();
386	try zcu.markDependeeOutdated(.{ .src_hash = ti_idx });
387	}
388		396
389	// If this is a `struct_decl` etc, we must invalidate any outdated namespace dependencies.	397	// If this is a `struct_decl` etc, we must invalidate any outdated namespace dependencies.
390	const has_namespace = switch (old_tag[@intFromEnum(old_inst)]) {	398	const has_namespace = switch (old_tag[@intFromEnum(old_inst)]) {
391	.extended => switch (old_data[@intFromEnum(old_inst)].extended.opcode) {	399	.extended => switch (old_data[@intFromEnum(old_inst)].extended.opcode) {
392	.struct_decl, .union_decl, .opaque_decl, .enum_decl => true,	400	.struct_decl, .union_decl, .opaque_decl, .enum_decl => true,
		401	else => false,
		402	},
393	else => false,	403	else => false,
394	},	404	};
395	else => false,	405	if (!has_namespace) continue;
396	};	406
397	if (!has_namespace) continue;	407	var old_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void) = .{};
398		408	defer old_names.deinit(zcu.gpa);
399	var old_names: std.AutoArrayHashMapUnmanaged(InternPool.NullTerminatedString, void) = .{};	409	{
400	defer old_names.deinit(zcu.gpa);	410	var it = old_zir.declIterator(old_inst);
401	{	411	while (it.next()) \|decl_inst\| {
402	var it = old_zir.declIterator(old_inst);	412	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;
403	while (it.next()) \|decl_inst\| {	413	switch (decl_name) {
404	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;	414	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,
405	switch (decl_name) {	415	_ => if (decl_name.isNamedTest(old_zir)) continue,
406	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,	416	}
407	_ => if (decl_name.isNamedTest(old_zir)) continue,	417	const name_zir = decl_name.toString(old_zir).?;
		418	const name_ip = try zcu.intern_pool.getOrPutString(
		419	zcu.gpa,
		420	pt.tid,
		421	old_zir.nullTerminatedString(name_zir),
		422	.no_embedded_nulls,
		423	);
		424	try old_names.put(zcu.gpa, name_ip, {});
408	}	425	}
409	const name_zir = decl_name.toString(old_zir).?;
410	const name_ip = try zcu.intern_pool.getOrPutString(
411	zcu.gpa,
412	pt.tid,
413	old_zir.nullTerminatedString(name_zir),
414	.no_embedded_nulls,
415	);
416	try old_names.put(zcu.gpa, name_ip, {});
417	}	426	}
418	}	427	var any_change = false;
419	var any_change = false;	428	{
420	{	429	var it = new_zir.declIterator(tracked_inst.inst);
421	var it = new_zir.declIterator(ti.inst);	430	while (it.next()) \|decl_inst\| {
422	while (it.next()) \|decl_inst\| {	431	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;
423	const decl_name = old_zir.getDeclaration(decl_inst)[0].name;	432	switch (decl_name) {
424	switch (decl_name) {	433	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,
425	.@"comptime", .@"usingnamespace", .unnamed_test, .decltest => continue,	434	_ => if (decl_name.isNamedTest(old_zir)) continue,
426	_ => if (decl_name.isNamedTest(old_zir)) continue,	435	}
		436	const name_zir = decl_name.toString(old_zir).?;
		437	const name_ip = try zcu.intern_pool.getOrPutString(
		438	zcu.gpa,
		439	pt.tid,
		440	old_zir.nullTerminatedString(name_zir),
		441	.no_embedded_nulls,
		442	);
		443	if (!old_names.swapRemove(name_ip)) continue;
		444	// Name added
		445	any_change = true;
		446	zcu.comp.mutex.lock();
		447	defer zcu.comp.mutex.unlock();
		448	try zcu.markDependeeOutdated(.{ .namespace_name = .{
		449	.namespace = tracked_inst_index,
		450	.name = name_ip,
		451	} });
427	}	452	}
428	const name_zir = decl_name.toString(old_zir).?;	453	}
429	const name_ip = try zcu.intern_pool.getOrPutString(	454	// The only elements remaining in `old_names` now are any names which were removed.
430	zcu.gpa,	455	for (old_names.keys()) \|name_ip\| {
431	pt.tid,
432	old_zir.nullTerminatedString(name_zir),
433	.no_embedded_nulls,
434	);
435	if (!old_names.swapRemove(name_ip)) continue;
436	// Name added
437	any_change = true;	456	any_change = true;
438	zcu.comp.mutex.lock();	457	zcu.comp.mutex.lock();
439	defer zcu.comp.mutex.unlock();	458	defer zcu.comp.mutex.unlock();
440	try zcu.markDependeeOutdated(.{ .namespace_name = .{	459	try zcu.markDependeeOutdated(.{ .namespace_name = .{
441	.namespace = ti_idx,	460	.namespace = tracked_inst_index,
442	.name = name_ip,	461	.name = name_ip,
443	} });	462	} });
444	}	463	}
445	}
446	// The only elements remaining in `old_names` now are any names which were removed.
447	for (old_names.keys()) \|name_ip\| {
448	any_change = true;
449	zcu.comp.mutex.lock();
450	defer zcu.comp.mutex.unlock();
451	try zcu.markDependeeOutdated(.{ .namespace_name = .{
452	.namespace = ti_idx,
453	.name = name_ip,
454	} });
455	}
456		464
457	if (any_change) {	465	if (any_change) {
458	zcu.comp.mutex.lock();	466	zcu.comp.mutex.lock();
459	defer zcu.comp.mutex.unlock();	467	defer zcu.comp.mutex.unlock();
460	try zcu.markDependeeOutdated(.{ .namespace = ti_idx });	468	try zcu.markDependeeOutdated(.{ .namespace = tracked_inst_index });
		469	}
461	}	470	}
462	}	471	}
463	}	472	}
...	@@ -548,7 +557,7 @@ pub fn ensureDeclAnalyzed(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) Zcu.Sem	...	@@ -548,7 +557,7 @@ pub fn ensureDeclAnalyzed(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) Zcu.Sem
548	};	557	};
549	}	558	}
550		559
551	const decl_prog_node = mod.sema_prog_node.start((try decl.fullyQualifiedName(pt)).toSlice(ip), 0);	560	const decl_prog_node = mod.sema_prog_node.start(decl.fqn.toSlice(ip), 0);
552	defer decl_prog_node.end();	561	defer decl_prog_node.end();
553		562
554	break :blk pt.semaDecl(decl_index) catch \|err\| switch (err) {	563	break :blk pt.semaDecl(decl_index) catch \|err\| switch (err) {
...	@@ -747,10 +756,9 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai	...	@@ -747,10 +756,9 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai
747	defer liveness.deinit(gpa);	756	defer liveness.deinit(gpa);
748		757
749	if (build_options.enable_debug_extensions and comp.verbose_air) {	758	if (build_options.enable_debug_extensions and comp.verbose_air) {
750	const fqn = try decl.fullyQualifiedName(pt);	759	std.debug.print("# Begin Function AIR: {}:\n", .{decl.fqn.fmt(ip)});
751	std.debug.print("# Begin Function AIR: {}:\n", .{fqn.fmt(ip)});
752	@import("../print_air.zig").dump(pt, air, liveness);	760	@import("../print_air.zig").dump(pt, air, liveness);
753	std.debug.print("# End Function AIR: {}\n\n", .{fqn.fmt(ip)});	761	std.debug.print("# End Function AIR: {}\n\n", .{decl.fqn.fmt(ip)});
754	}	762	}
755		763
756	if (std.debug.runtime_safety) {	764	if (std.debug.runtime_safety) {
...	@@ -781,7 +789,7 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai	...	@@ -781,7 +789,7 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai
781	};	789	};
782	}	790	}
783		791
784	const codegen_prog_node = zcu.codegen_prog_node.start((try decl.fullyQualifiedName(pt)).toSlice(ip), 0);	792	const codegen_prog_node = zcu.codegen_prog_node.start(decl.fqn.toSlice(ip), 0);
785	defer codegen_prog_node.end();	793	defer codegen_prog_node.end();
786		794
787	if (!air.typesFullyResolved(zcu)) {	795	if (!air.typesFullyResolved(zcu)) {
...	@@ -818,7 +826,7 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai	...	@@ -818,7 +826,7 @@ pub fn linkerUpdateFunc(pt: Zcu.PerThread, func_index: InternPool.Index, air: Ai
818		826
819	/// https://github.com/ziglang/zig/issues/14307	827	/// https://github.com/ziglang/zig/issues/14307
820	pub fn semaPkg(pt: Zcu.PerThread, pkg: *Module) !void {	828	pub fn semaPkg(pt: Zcu.PerThread, pkg: *Module) !void {
821	const import_file_result = try pt.zcu.importPkg(pkg);	829	const import_file_result = try pt.importPkg(pkg);
822	const root_decl_index = pt.zcu.fileRootDecl(import_file_result.file_index);	830	const root_decl_index = pt.zcu.fileRootDecl(import_file_result.file_index);
823	if (root_decl_index == .none) {	831	if (root_decl_index == .none) {
824	return pt.semaFile(import_file_result.file_index);	832	return pt.semaFile(import_file_result.file_index);
...	@@ -855,7 +863,10 @@ fn getFileRootStruct(	...	@@ -855,7 +863,10 @@ fn getFileRootStruct(
855	const decls = file.zir.bodySlice(extra_index, decls_len);	863	const decls = file.zir.bodySlice(extra_index, decls_len);
856	extra_index += decls_len;	864	extra_index += decls_len;
857		865
858	const tracked_inst = try ip.trackZir(gpa, file_index, .main_struct_inst);	866	const tracked_inst = try ip.trackZir(gpa, pt.tid, .{
		867	.file = file_index,
		868	.inst = .main_struct_inst,
		869	});
859	const wip_ty = switch (try ip.getStructType(gpa, pt.tid, .{	870	const wip_ty = switch (try ip.getStructType(gpa, pt.tid, .{
860	.layout = .auto,	871	.layout = .auto,
861	.fields_len = fields_len,	872	.fields_len = fields_len,
...	@@ -996,8 +1007,8 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {	...	@@ -996,8 +1007,8 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
996	zcu.setFileRootDecl(file_index, new_decl_index.toOptional());	1007	zcu.setFileRootDecl(file_index, new_decl_index.toOptional());
997	zcu.namespacePtr(new_namespace_index).decl_index = new_decl_index;	1008	zcu.namespacePtr(new_namespace_index).decl_index = new_decl_index;
998		1009
999	new_decl.name = try file.fullyQualifiedName(pt);	1010	new_decl.fqn = try file.internFullyQualifiedName(pt);
1000	new_decl.name_fully_qualified = true;	1011	new_decl.name = new_decl.fqn;
1001	new_decl.is_pub = true;	1012	new_decl.is_pub = true;
1002	new_decl.is_exported = false;	1013	new_decl.is_exported = false;
1003	new_decl.alignment = .none;	1014	new_decl.alignment = .none;
...	@@ -1016,7 +1027,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {	...	@@ -1016,7 +1027,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
1016	switch (zcu.comp.cache_use) {	1027	switch (zcu.comp.cache_use) {
1017	.whole => \|whole\| if (whole.cache_manifest) \|man\| {	1028	.whole => \|whole\| if (whole.cache_manifest) \|man\| {
1018	const source = file.getSource(gpa) catch \|err\| {	1029	const source = file.getSource(gpa) catch \|err\| {
1019	try Zcu.reportRetryableFileError(zcu, file_index, "unable to load source: {s}", .{@errorName(err)});	1030	try pt.reportRetryableFileError(file_index, "unable to load source: {s}", .{@errorName(err)});
1020	return error.AnalysisFail;	1031	return error.AnalysisFail;
1021	};	1032	};
1022		1033
...	@@ -1025,7 +1036,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {	...	@@ -1025,7 +1036,7 @@ fn semaFile(pt: Zcu.PerThread, file_index: Zcu.File.Index) Zcu.SemaError!void {
1025	file.mod.root.sub_path,	1036	file.mod.root.sub_path,
1026	file.sub_file_path,	1037	file.sub_file_path,
1027	}) catch \|err\| {	1038	}) catch \|err\| {
1028	try Zcu.reportRetryableFileError(zcu, file_index, "unable to resolve path: {s}", .{@errorName(err)});	1039	try pt.reportRetryableFileError(file_index, "unable to resolve path: {s}", .{@errorName(err)});
1029	return error.AnalysisFail;	1040	return error.AnalysisFail;
1030	};	1041	};
1031	errdefer gpa.free(resolved_path);	1042	errdefer gpa.free(resolved_path);
...	@@ -1058,10 +1069,8 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {	...	@@ -1058,10 +1069,8 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {
1058	}	1069	}
1059		1070
1060	log.debug("semaDecl '{d}'", .{@intFromEnum(decl_index)});	1071	log.debug("semaDecl '{d}'", .{@intFromEnum(decl_index)});
1061	log.debug("decl name '{}'", .{(try decl.fullyQualifiedName(pt)).fmt(ip)});	1072	log.debug("decl name '{}'", .{decl.fqn.fmt(ip)});
1062	defer blk: {	1073	defer log.debug("finish decl name '{}'", .{decl.fqn.fmt(ip)});
1063	log.debug("finish decl name '{}'", .{(decl.fullyQualifiedName(pt) catch break :blk).fmt(ip)});
1064	}
1065		1074
1066	const old_has_tv = decl.has_tv;	1075	const old_has_tv = decl.has_tv;
1067	// The following values are ignored if `!old_has_tv`	1076	// The following values are ignored if `!old_has_tv`
...	@@ -1084,7 +1093,7 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {	...	@@ -1084,7 +1093,7 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {
1084	const std_mod = zcu.std_mod;	1093	const std_mod = zcu.std_mod;
1085	if (decl.getFileScope(zcu).mod != std_mod) break :ip_index .none;	1094	if (decl.getFileScope(zcu).mod != std_mod) break :ip_index .none;
1086	// We're in the std module.	1095	// We're in the std module.
1087	const std_file_imported = try zcu.importPkg(std_mod);	1096	const std_file_imported = try pt.importPkg(std_mod);
1088	const std_file_root_decl_index = zcu.fileRootDecl(std_file_imported.file_index);	1097	const std_file_root_decl_index = zcu.fileRootDecl(std_file_imported.file_index);
1089	const std_decl = zcu.declPtr(std_file_root_decl_index.unwrap().?);	1098	const std_decl = zcu.declPtr(std_file_root_decl_index.unwrap().?);
1090	const std_namespace = std_decl.getInnerNamespace(zcu).?;	1099	const std_namespace = std_decl.getInnerNamespace(zcu).?;
...	@@ -1151,11 +1160,10 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {	...	@@ -1151,11 +1160,10 @@ fn semaDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.SemaDeclResult {
1151	defer sema.deinit();	1160	defer sema.deinit();
1152		1161
1153	// Every Decl (other than file root Decls, which do not have a ZIR index) has a dependency on its own source.	1162	// Every Decl (other than file root Decls, which do not have a ZIR index) has a dependency on its own source.
1154	try sema.declareDependency(.{ .src_hash = try ip.trackZir(	1163	try sema.declareDependency(.{ .src_hash = try ip.trackZir(gpa, pt.tid, .{
1155	gpa,	1164	.file = decl.getFileScopeIndex(zcu),
1156	decl.getFileScopeIndex(zcu),	1165	.inst = decl_inst,
1157	decl_inst,	1166	}) });
1158	) });
1159		1167
1160	var block_scope: Sema.Block = .{	1168	var block_scope: Sema.Block = .{
1161	.parent = null,	1169	.parent = null,
...	@@ -1359,6 +1367,195 @@ pub fn semaAnonOwnerDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.Sem	...	@@ -1359,6 +1367,195 @@ pub fn semaAnonOwnerDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !Zcu.Sem
1359	};	1367	};
1360	}	1368	}
1361		1369
		1370	pub fn importPkg(pt: Zcu.PerThread, mod: *Module) !Zcu.ImportFileResult {
		1371	const zcu = pt.zcu;
		1372	const gpa = zcu.gpa;
		1373
		1374	// The resolved path is used as the key in the import table, to detect if
		1375	// an import refers to the same as another, despite different relative paths
		1376	// or differently mapped package names.
		1377	const resolved_path = try std.fs.path.resolve(gpa, &.{
		1378	mod.root.root_dir.path orelse ".",
		1379	mod.root.sub_path,
		1380	mod.root_src_path,
		1381	});
		1382	var keep_resolved_path = false;
		1383	defer if (!keep_resolved_path) gpa.free(resolved_path);
		1384
		1385	const gop = try zcu.import_table.getOrPut(gpa, resolved_path);
		1386	errdefer _ = zcu.import_table.pop();
		1387	if (gop.found_existing) {
		1388	const file_index = gop.value_ptr.*;
		1389	const file = zcu.fileByIndex(file_index);
		1390	try file.addReference(zcu, .{ .root = mod });
		1391	return .{
		1392	.file = file,
		1393	.file_index = file_index,
		1394	.is_new = false,
		1395	.is_pkg = true,
		1396	};
		1397	}
		1398
		1399	const ip = &zcu.intern_pool;
		1400	if (mod.builtin_file) \|builtin_file\| {
		1401	const path_digest = Zcu.computePathDigest(zcu, mod, builtin_file.sub_file_path);
		1402	const file_index = try ip.createFile(gpa, pt.tid, .{
		1403	.bin_digest = path_digest,
		1404	.file = builtin_file,
		1405	.root_decl = .none,
		1406	});
		1407	keep_resolved_path = true; // It's now owned by import_table.
		1408	gop.value_ptr.* = file_index;
		1409	try builtin_file.addReference(zcu, .{ .root = mod });
		1410	return .{
		1411	.file = builtin_file,
		1412	.file_index = file_index,
		1413	.is_new = false,
		1414	.is_pkg = true,
		1415	};
		1416	}
		1417
		1418	const sub_file_path = try gpa.dupe(u8, mod.root_src_path);
		1419	errdefer gpa.free(sub_file_path);
		1420
		1421	const new_file = try gpa.create(Zcu.File);
		1422	errdefer gpa.destroy(new_file);
		1423
		1424	const path_digest = zcu.computePathDigest(mod, sub_file_path);
		1425	const new_file_index = try ip.createFile(gpa, pt.tid, .{
		1426	.bin_digest = path_digest,
		1427	.file = new_file,
		1428	.root_decl = .none,
		1429	});
		1430	keep_resolved_path = true; // It's now owned by import_table.
		1431	gop.value_ptr.* = new_file_index;
		1432	new_file.* = .{
		1433	.sub_file_path = sub_file_path,
		1434	.source = undefined,
		1435	.source_loaded = false,
		1436	.tree_loaded = false,
		1437	.zir_loaded = false,
		1438	.stat = undefined,
		1439	.tree = undefined,
		1440	.zir = undefined,
		1441	.status = .never_loaded,
		1442	.mod = mod,
		1443	};
		1444
		1445	try new_file.addReference(zcu, .{ .root = mod });
		1446	return .{
		1447	.file = new_file,
		1448	.file_index = new_file_index,
		1449	.is_new = true,
		1450	.is_pkg = true,
		1451	};
		1452	}
		1453
		1454	/// Called from a worker thread during AstGen.
		1455	/// Also called from Sema during semantic analysis.
		1456	pub fn importFile(
		1457	pt: Zcu.PerThread,
		1458	cur_file: *Zcu.File,
		1459	import_string: []const u8,
		1460	) !Zcu.ImportFileResult {
		1461	const zcu = pt.zcu;
		1462	const mod = cur_file.mod;
		1463
		1464	if (std.mem.eql(u8, import_string, "std")) {
		1465	return pt.importPkg(zcu.std_mod);
		1466	}
		1467	if (std.mem.eql(u8, import_string, "root")) {
		1468	return pt.importPkg(zcu.root_mod);
		1469	}
		1470	if (mod.deps.get(import_string)) \|pkg\| {
		1471	return pt.importPkg(pkg);
		1472	}
		1473	if (!std.mem.endsWith(u8, import_string, ".zig")) {
		1474	return error.ModuleNotFound;
		1475	}
		1476	const gpa = zcu.gpa;
		1477
		1478	// The resolved path is used as the key in the import table, to detect if
		1479	// an import refers to the same as another, despite different relative paths
		1480	// or differently mapped package names.
		1481	const resolved_path = try std.fs.path.resolve(gpa, &.{
		1482	mod.root.root_dir.path orelse ".",
		1483	mod.root.sub_path,
		1484	cur_file.sub_file_path,
		1485	"..",
		1486	import_string,
		1487	});
		1488
		1489	var keep_resolved_path = false;
		1490	defer if (!keep_resolved_path) gpa.free(resolved_path);
		1491
		1492	const gop = try zcu.import_table.getOrPut(gpa, resolved_path);
		1493	errdefer _ = zcu.import_table.pop();
		1494	if (gop.found_existing) {
		1495	const file_index = gop.value_ptr.*;
		1496	return .{
		1497	.file = zcu.fileByIndex(file_index),
		1498	.file_index = file_index,
		1499	.is_new = false,
		1500	.is_pkg = false,
		1501	};
		1502	}
		1503
		1504	const ip = &zcu.intern_pool;
		1505
		1506	const new_file = try gpa.create(Zcu.File);
		1507	errdefer gpa.destroy(new_file);
		1508
		1509	const resolved_root_path = try std.fs.path.resolve(gpa, &.{
		1510	mod.root.root_dir.path orelse ".",
		1511	mod.root.sub_path,
		1512	});
		1513	defer gpa.free(resolved_root_path);
		1514
		1515	const sub_file_path = p: {
		1516	const relative = try std.fs.path.relative(gpa, resolved_root_path, resolved_path);
		1517	errdefer gpa.free(relative);
		1518
		1519	if (!isUpDir(relative) and !std.fs.path.isAbsolute(relative)) {
		1520	break :p relative;
		1521	}
		1522	return error.ImportOutsideModulePath;
		1523	};
		1524	errdefer gpa.free(sub_file_path);
		1525
		1526	log.debug("new importFile. resolved_root_path={s}, resolved_path={s}, sub_file_path={s}, import_string={s}", .{
		1527	resolved_root_path, resolved_path, sub_file_path, import_string,
		1528	});
		1529
		1530	const path_digest = zcu.computePathDigest(mod, sub_file_path);
		1531	const new_file_index = try ip.createFile(gpa, pt.tid, .{
		1532	.bin_digest = path_digest,
		1533	.file = new_file,
		1534	.root_decl = .none,
		1535	});
		1536	keep_resolved_path = true; // It's now owned by import_table.
		1537	gop.value_ptr.* = new_file_index;
		1538	new_file.* = .{
		1539	.sub_file_path = sub_file_path,
		1540	.source = undefined,
		1541	.source_loaded = false,
		1542	.tree_loaded = false,
		1543	.zir_loaded = false,
		1544	.stat = undefined,
		1545	.tree = undefined,
		1546	.zir = undefined,
		1547	.status = .never_loaded,
		1548	.mod = mod,
		1549	};
		1550
		1551	return .{
		1552	.file = new_file,
		1553	.file_index = new_file_index,
		1554	.is_new = true,
		1555	.is_pkg = false,
		1556	};
		1557	}
		1558
1362	pub fn embedFile(	1559	pub fn embedFile(
1363	pt: Zcu.PerThread,	1560	pt: Zcu.PerThread,
1364	cur_file: *Zcu.File,	1561	cur_file: *Zcu.File,
...	@@ -1432,20 +1629,6 @@ pub fn embedFile(	...	@@ -1432,20 +1629,6 @@ pub fn embedFile(
1432	return pt.newEmbedFile(cur_file.mod, sub_file_path, resolved_path, gop.value_ptr, src_loc);	1629	return pt.newEmbedFile(cur_file.mod, sub_file_path, resolved_path, gop.value_ptr, src_loc);
1433	}	1630	}
1434		1631
1435	/// Cancel the creation of an anon decl and delete any references to it.
1436	/// If other decls depend on this decl, they must be aborted first.
1437	pub fn abortAnonDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) void {
1438	assert(!pt.zcu.declIsRoot(decl_index));
1439	pt.destroyDecl(decl_index);
1440	}
1441
1442	/// Finalize the creation of an anon decl.
1443	pub fn finalizeAnonDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) Allocator.Error!void {
1444	if (pt.zcu.declPtr(decl_index).typeOf(pt.zcu).isFnOrHasRuntimeBits(pt)) {
1445	try pt.zcu.comp.work_queue.writeItem(.{ .codegen_decl = decl_index });
1446	}
1447	}
1448
1449	/// https://github.com/ziglang/zig/issues/14307	1632	/// https://github.com/ziglang/zig/issues/14307
1450	fn newEmbedFile(	1633	fn newEmbedFile(
1451	pt: Zcu.PerThread,	1634	pt: Zcu.PerThread,
...	@@ -1718,7 +1901,10 @@ const ScanDeclIter = struct {	...	@@ -1718,7 +1901,10 @@ const ScanDeclIter = struct {
1718	}	1901	}
1719		1902
1720	const parent_file_scope_index = iter.parent_decl.getFileScopeIndex(zcu);	1903	const parent_file_scope_index = iter.parent_decl.getFileScopeIndex(zcu);
1721	const tracked_inst = try ip.trackZir(gpa, parent_file_scope_index, decl_inst);	1904	const tracked_inst = try ip.trackZir(gpa, pt.tid, .{
		1905	.file = parent_file_scope_index,
		1906	.inst = decl_inst,
		1907	});
1722		1908
1723	// We create a Decl for it regardless of analysis status.	1909	// We create a Decl for it regardless of analysis status.
1724		1910
...	@@ -1728,6 +1914,7 @@ const ScanDeclIter = struct {	...	@@ -1728,6 +1914,7 @@ const ScanDeclIter = struct {
1728	const was_exported = decl.is_exported;	1914	const was_exported = decl.is_exported;
1729	assert(decl.kind == kind); // ZIR tracking should preserve this	1915	assert(decl.kind == kind); // ZIR tracking should preserve this
1730	decl.name = decl_name;	1916	decl.name = decl_name;
		1917	decl.fqn = try namespace.internFullyQualifiedName(ip, gpa, pt.tid, decl_name);
1731	decl.is_pub = declaration.flags.is_pub;	1918	decl.is_pub = declaration.flags.is_pub;
1732	decl.is_exported = declaration.flags.is_export;	1919	decl.is_exported = declaration.flags.is_export;
1733	break :decl_index .{ was_exported, decl_index };	1920	break :decl_index .{ was_exported, decl_index };
...	@@ -1737,6 +1924,7 @@ const ScanDeclIter = struct {	...	@@ -1737,6 +1924,7 @@ const ScanDeclIter = struct {
1737	const new_decl = zcu.declPtr(new_decl_index);	1924	const new_decl = zcu.declPtr(new_decl_index);
1738	new_decl.kind = kind;	1925	new_decl.kind = kind;
1739	new_decl.name = decl_name;	1926	new_decl.name = decl_name;
		1927	new_decl.fqn = try namespace.internFullyQualifiedName(ip, gpa, pt.tid, decl_name);
1740	new_decl.is_pub = declaration.flags.is_pub;	1928	new_decl.is_pub = declaration.flags.is_pub;
1741	new_decl.is_exported = declaration.flags.is_export;	1929	new_decl.is_exported = declaration.flags.is_export;
1742	new_decl.zir_decl_index = tracked_inst.toOptional();	1930	new_decl.zir_decl_index = tracked_inst.toOptional();
...	@@ -1761,10 +1949,9 @@ const ScanDeclIter = struct {	...	@@ -1761,10 +1949,9 @@ const ScanDeclIter = struct {
1761	if (!comp.config.is_test) break :a false;	1949	if (!comp.config.is_test) break :a false;
1762	if (decl_mod != zcu.main_mod) break :a false;	1950	if (decl_mod != zcu.main_mod) break :a false;
1763	if (is_named_test and comp.test_filters.len > 0) {	1951	if (is_named_test and comp.test_filters.len > 0) {
1764	const decl_fqn = try namespace.fullyQualifiedName(pt, decl_name);	1952	const decl_fqn = decl.fqn.toSlice(ip);
1765	const decl_fqn_slice = decl_fqn.toSlice(ip);
1766	for (comp.test_filters) \|test_filter\| {	1953	for (comp.test_filters) \|test_filter\| {
1767	if (std.mem.indexOf(u8, decl_fqn_slice, test_filter)) \|_\| break;	1954	if (std.mem.indexOf(u8, decl_fqn, test_filter)) \|_\| break;
1768	} else break :a false;	1955	} else break :a false;
1769	}	1956	}
1770	zcu.test_functions.putAssumeCapacity(decl_index, {}); // may clobber on incremental update	1957	zcu.test_functions.putAssumeCapacity(decl_index, {}); // may clobber on incremental update
...	@@ -1794,6 +1981,20 @@ const ScanDeclIter = struct {	...	@@ -1794,6 +1981,20 @@ const ScanDeclIter = struct {
1794	}	1981	}
1795	};	1982	};
1796		1983
		1984	/// Cancel the creation of an anon decl and delete any references to it.
		1985	/// If other decls depend on this decl, they must be aborted first.
		1986	pub fn abortAnonDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) void {
		1987	assert(!pt.zcu.declIsRoot(decl_index));
		1988	pt.destroyDecl(decl_index);
		1989	}
		1990
		1991	/// Finalize the creation of an anon decl.
		1992	pub fn finalizeAnonDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) Allocator.Error!void {
		1993	if (pt.zcu.declPtr(decl_index).typeOf(pt.zcu).isFnOrHasRuntimeBits(pt)) {
		1994	try pt.zcu.comp.work_queue.writeItem(.{ .codegen_decl = decl_index });
		1995	}
		1996	}
		1997
1797	pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: Allocator) Zcu.SemaError!Air {	1998	pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: Allocator) Zcu.SemaError!Air {
1798	const tracy = trace(@src());	1999	const tracy = trace(@src());
1799	defer tracy.end();	2000	defer tracy.end();
...	@@ -1805,12 +2006,10 @@ pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: All	...	@@ -1805,12 +2006,10 @@ pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: All
1805	const decl_index = func.owner_decl;	2006	const decl_index = func.owner_decl;
1806	const decl = mod.declPtr(decl_index);	2007	const decl = mod.declPtr(decl_index);
1807		2008
1808	log.debug("func name '{}'", .{(try decl.fullyQualifiedName(pt)).fmt(ip)});	2009	log.debug("func name '{}'", .{decl.fqn.fmt(ip)});
1809	defer blk: {	2010	defer log.debug("finish func name '{}'", .{decl.fqn.fmt(ip)});
1810	log.debug("finish func name '{}'", .{(decl.fullyQualifiedName(pt) catch break :blk).fmt(ip)});
1811	}
1812		2011
1813	const decl_prog_node = mod.sema_prog_node.start((try decl.fullyQualifiedName(pt)).toSlice(ip), 0);	2012	const decl_prog_node = mod.sema_prog_node.start(decl.fqn.toSlice(ip), 0);
1814	defer decl_prog_node.end();	2013	defer decl_prog_node.end();
1815		2014
1816	mod.intern_pool.removeDependenciesForDepender(gpa, InternPool.AnalUnit.wrap(.{ .func = func_index }));	2015	mod.intern_pool.removeDependenciesForDepender(gpa, InternPool.AnalUnit.wrap(.{ .func = func_index }));
...	@@ -1911,10 +2110,17 @@ pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: All	...	@@ -1911,10 +2110,17 @@ pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: All
1911	runtime_params_len;	2110	runtime_params_len;
1912		2111
1913	var runtime_param_index: usize = 0;	2112	var runtime_param_index: usize = 0;
1914	for (fn_info.param_body[0..src_params_len], 0..) \|inst, src_param_index\| {	2113	for (fn_info.param_body[0..src_params_len]) \|inst\| {
1915	const gop = sema.inst_map.getOrPutAssumeCapacity(inst);	2114	const gop = sema.inst_map.getOrPutAssumeCapacity(inst);
1916	if (gop.found_existing) continue; // provided above by comptime arg	2115	if (gop.found_existing) continue; // provided above by comptime arg
1917		2116
		2117	const inst_info = sema.code.instructions.get(@intFromEnum(inst));
		2118	const param_name: Zir.NullTerminatedString = switch (inst_info.tag) {
		2119	.param_anytype => inst_info.data.str_tok.start,
		2120	.param => sema.code.extraData(Zir.Inst.Param, inst_info.data.pl_tok.payload_index).data.name,
		2121	else => unreachable,
		2122	};
		2123
1918	const param_ty = fn_ty_info.param_types.get(ip)[runtime_param_index];	2124	const param_ty = fn_ty_info.param_types.get(ip)[runtime_param_index];
1919	runtime_param_index += 1;	2125	runtime_param_index += 1;
1920		2126
...	@@ -1935,7 +2141,10 @@ pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: All	...	@@ -1935,7 +2141,10 @@ pub fn analyzeFnBody(pt: Zcu.PerThread, func_index: InternPool.Index, arena: All
1935	.tag = .arg,	2141	.tag = .arg,
1936	.data = .{ .arg = .{	2142	.data = .{ .arg = .{
1937	.ty = Air.internedToRef(param_ty),	2143	.ty = Air.internedToRef(param_ty),
1938	.src_index = @intCast(src_param_index),	2144	.name = if (inner_block.ownerModule().strip)
		2145	.none
		2146	else
		2147	@enumFromInt(try sema.appendAirString(sema.code.nullTerminatedString(param_name))),
1939	} },	2148	} },
1940	});	2149	});
1941	}	2150	}
...	@@ -2053,6 +2262,7 @@ pub fn allocateNewDecl(pt: Zcu.PerThread, namespace: Zcu.Namespace.Index) !Zcu.D	...	@@ -2053,6 +2262,7 @@ pub fn allocateNewDecl(pt: Zcu.PerThread, namespace: Zcu.Namespace.Index) !Zcu.D
2053	const gpa = zcu.gpa;	2262	const gpa = zcu.gpa;
2054	const decl_index = try zcu.intern_pool.createDecl(gpa, pt.tid, .{	2263	const decl_index = try zcu.intern_pool.createDecl(gpa, pt.tid, .{
2055	.name = undefined,	2264	.name = undefined,
		2265	.fqn = undefined,
2056	.src_namespace = namespace,	2266	.src_namespace = namespace,
2057	.has_tv = false,	2267	.has_tv = false,
2058	.owns_tv = false,	2268	.owns_tv = false,
...	@@ -2077,6 +2287,36 @@ pub fn allocateNewDecl(pt: Zcu.PerThread, namespace: Zcu.Namespace.Index) !Zcu.D	...	@@ -2077,6 +2287,36 @@ pub fn allocateNewDecl(pt: Zcu.PerThread, namespace: Zcu.Namespace.Index) !Zcu.D
2077	return decl_index;	2287	return decl_index;
2078	}	2288	}
2079		2289
		2290	pub fn getErrorValue(
		2291	pt: Zcu.PerThread,
		2292	name: InternPool.NullTerminatedString,
		2293	) Allocator.Error!Zcu.ErrorInt {
		2294	return pt.zcu.intern_pool.getErrorValue(pt.zcu.gpa, pt.tid, name);
		2295	}
		2296
		2297	pub fn getErrorValueFromSlice(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Zcu.ErrorInt {
		2298	return pt.getErrorValue(try pt.zcu.intern_pool.getOrPutString(pt.zcu.gpa, name));
		2299	}
		2300
		2301	pub fn initNewAnonDecl(
		2302	pt: Zcu.PerThread,
		2303	new_decl_index: Zcu.Decl.Index,
		2304	val: Value,
		2305	name: InternPool.NullTerminatedString,
		2306	fqn: InternPool.OptionalNullTerminatedString,
		2307	) Allocator.Error!void {
		2308	const new_decl = pt.zcu.declPtr(new_decl_index);
		2309
		2310	new_decl.name = name;
		2311	new_decl.fqn = fqn.unwrap() orelse try pt.zcu.namespacePtr(new_decl.src_namespace)
		2312	.internFullyQualifiedName(&pt.zcu.intern_pool, pt.zcu.gpa, pt.tid, name);
		2313	new_decl.val = val;
		2314	new_decl.alignment = .none;
		2315	new_decl.@"linksection" = .none;
		2316	new_decl.has_tv = true;
		2317	new_decl.analysis = .complete;
		2318	}
		2319
2080	fn lockAndClearFileCompileError(pt: Zcu.PerThread, file: *Zcu.File) void {	2320	fn lockAndClearFileCompileError(pt: Zcu.PerThread, file: *Zcu.File) void {
2081	switch (file.status) {	2321	switch (file.status) {
2082	.success_zir, .retryable_failure => {},	2322	.success_zir, .retryable_failure => {},
...	@@ -2229,7 +2469,7 @@ pub fn populateTestFunctions(	...	@@ -2229,7 +2469,7 @@ pub fn populateTestFunctions(
2229	const gpa = zcu.gpa;	2469	const gpa = zcu.gpa;
2230	const ip = &zcu.intern_pool;	2470	const ip = &zcu.intern_pool;
2231	const builtin_mod = zcu.root_mod.getBuiltinDependency();	2471	const builtin_mod = zcu.root_mod.getBuiltinDependency();
2232	const builtin_file_index = (zcu.importPkg(builtin_mod) catch unreachable).file_index;	2472	const builtin_file_index = (pt.importPkg(builtin_mod) catch unreachable).file_index;
2233	const root_decl_index = zcu.fileRootDecl(builtin_file_index);	2473	const root_decl_index = zcu.fileRootDecl(builtin_file_index);
2234	const root_decl = zcu.declPtr(root_decl_index.unwrap().?);	2474	const root_decl = zcu.declPtr(root_decl_index.unwrap().?);
2235	const builtin_namespace = zcu.namespacePtr(root_decl.src_namespace);	2475	const builtin_namespace = zcu.namespacePtr(root_decl.src_namespace);
...	@@ -2260,7 +2500,7 @@ pub fn populateTestFunctions(	...	@@ -2260,7 +2500,7 @@ pub fn populateTestFunctions(
2260		2500
2261	for (test_fn_vals, zcu.test_functions.keys()) \|*test_fn_val, test_decl_index\| {	2501	for (test_fn_vals, zcu.test_functions.keys()) \|*test_fn_val, test_decl_index\| {
2262	const test_decl = zcu.declPtr(test_decl_index);	2502	const test_decl = zcu.declPtr(test_decl_index);
2263	const test_decl_name = try test_decl.fullyQualifiedName(pt);	2503	const test_decl_name = test_decl.fqn;
2264	const test_decl_name_len = test_decl_name.length(ip);	2504	const test_decl_name_len = test_decl_name.length(ip);
2265	const test_name_anon_decl: InternPool.Key.Ptr.BaseAddr.AnonDecl = n: {	2505	const test_name_anon_decl: InternPool.Key.Ptr.BaseAddr.AnonDecl = n: {
2266	const test_name_ty = try pt.arrayType(.{	2506	const test_name_ty = try pt.arrayType(.{
...	@@ -2366,7 +2606,7 @@ pub fn linkerUpdateDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !void {	...	@@ -2366,7 +2606,7 @@ pub fn linkerUpdateDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !void {
2366		2606
2367	const decl = zcu.declPtr(decl_index);	2607	const decl = zcu.declPtr(decl_index);
2368		2608
2369	const codegen_prog_node = zcu.codegen_prog_node.start((try decl.fullyQualifiedName(pt)).toSlice(&zcu.intern_pool), 0);	2609	const codegen_prog_node = zcu.codegen_prog_node.start(decl.fqn.toSlice(&zcu.intern_pool), 0);
2370	defer codegen_prog_node.end();	2610	defer codegen_prog_node.end();
2371		2611
2372	if (comp.bin_file) \|lf\| {	2612	if (comp.bin_file) \|lf\| {
...	@@ -2396,6 +2636,87 @@ pub fn linkerUpdateDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !void {	...	@@ -2396,6 +2636,87 @@ pub fn linkerUpdateDecl(pt: Zcu.PerThread, decl_index: Zcu.Decl.Index) !void {
2396	}	2636	}
2397	}	2637	}
2398		2638
		2639	pub fn reportRetryableAstGenError(
		2640	pt: Zcu.PerThread,
		2641	src: Zcu.AstGenSrc,
		2642	file_index: Zcu.File.Index,
		2643	err: anyerror,
		2644	) error{OutOfMemory}!void {
		2645	const zcu = pt.zcu;
		2646	const gpa = zcu.gpa;
		2647	const ip = &zcu.intern_pool;
		2648
		2649	const file = zcu.fileByIndex(file_index);
		2650	file.status = .retryable_failure;
		2651
		2652	const src_loc: Zcu.LazySrcLoc = switch (src) {
		2653	.root => .{
		2654	.base_node_inst = try ip.trackZir(gpa, pt.tid, .{
		2655	.file = file_index,
		2656	.inst = .main_struct_inst,
		2657	}),
		2658	.offset = .entire_file,
		2659	},
		2660	.import => \|info\| .{
		2661	.base_node_inst = try ip.trackZir(gpa, pt.tid, .{
		2662	.file = info.importing_file,
		2663	.inst = .main_struct_inst,
		2664	}),
		2665	.offset = .{ .token_abs = info.import_tok },
		2666	},
		2667	};
		2668
		2669	const err_msg = try Zcu.ErrorMsg.create(gpa, src_loc, "unable to load '{}{s}': {s}", .{
		2670	file.mod.root, file.sub_file_path, @errorName(err),
		2671	});
		2672	errdefer err_msg.destroy(gpa);
		2673
		2674	{
		2675	zcu.comp.mutex.lock();
		2676	defer zcu.comp.mutex.unlock();
		2677	try zcu.failed_files.putNoClobber(gpa, file, err_msg);
		2678	}
		2679	}
		2680
		2681	pub fn reportRetryableFileError(
		2682	pt: Zcu.PerThread,
		2683	file_index: Zcu.File.Index,
		2684	comptime format: []const u8,
		2685	args: anytype,
		2686	) error{OutOfMemory}!void {
		2687	const zcu = pt.zcu;
		2688	const gpa = zcu.gpa;
		2689	const ip = &zcu.intern_pool;
		2690
		2691	const file = zcu.fileByIndex(file_index);
		2692	file.status = .retryable_failure;
		2693
		2694	const err_msg = try Zcu.ErrorMsg.create(
		2695	gpa,
		2696	.{
		2697	.base_node_inst = try ip.trackZir(gpa, pt.tid, .{
		2698	.file = file_index,
		2699	.inst = .main_struct_inst,
		2700	}),
		2701	.offset = .entire_file,
		2702	},
		2703	format,
		2704	args,
		2705	);
		2706	errdefer err_msg.destroy(gpa);
		2707
		2708	zcu.comp.mutex.lock();
		2709	defer zcu.comp.mutex.unlock();
		2710
		2711	const gop = try zcu.failed_files.getOrPut(gpa, file);
		2712	if (gop.found_existing) {
		2713	if (gop.value_ptr.*) \|old_err_msg\| {
		2714	old_err_msg.destroy(gpa);
		2715	}
		2716	}
		2717	gop.value_ptr.* = err_msg;
		2718	}
		2719
2399	/// Shortcut for calling `intern_pool.get`.	2720	/// Shortcut for calling `intern_pool.get`.
2400	pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool.Index {	2721	pub fn intern(pt: Zcu.PerThread, key: InternPool.Key) Allocator.Error!InternPool.Index {
2401	return pt.zcu.intern_pool.get(pt.zcu.gpa, pt.tid, key);	2722	return pt.zcu.intern_pool.get(pt.zcu.gpa, pt.tid, key);
...	@@ -2897,7 +3218,7 @@ pub fn getBuiltinDecl(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Inter	...	@@ -2897,7 +3218,7 @@ pub fn getBuiltinDecl(pt: Zcu.PerThread, name: []const u8) Allocator.Error!Inter
2897	const zcu = pt.zcu;	3218	const zcu = pt.zcu;
2898	const gpa = zcu.gpa;	3219	const gpa = zcu.gpa;
2899	const ip = &zcu.intern_pool;	3220	const ip = &zcu.intern_pool;
2900	const std_file_imported = zcu.importPkg(zcu.std_mod) catch @panic("failed to import lib/std.zig");	3221	const std_file_imported = pt.importPkg(zcu.std_mod) catch @panic("failed to import lib/std.zig");
2901	const std_file_root_decl = zcu.fileRootDecl(std_file_imported.file_index).unwrap().?;	3222	const std_file_root_decl = zcu.fileRootDecl(std_file_imported.file_index).unwrap().?;
2902	const std_namespace = zcu.declPtr(std_file_root_decl).getOwnedInnerNamespace(zcu).?;	3223	const std_namespace = zcu.declPtr(std_file_root_decl).getOwnedInnerNamespace(zcu).?;
2903	const builtin_str = try ip.getOrPutString(gpa, pt.tid, "builtin", .no_embedded_nulls);	3224	const builtin_str = try ip.getOrPutString(gpa, pt.tid, "builtin", .no_embedded_nulls);

src/arch/aarch64/CodeGen.zig+10-10

 @@ -4231,19 +4231,19 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
     while (self.args[arg_index] == .none) arg_index += 1;
     self.arg_index = arg_index + 1;
-    const pt = self.pt;
-    const mod = pt.zcu;
     const ty = self.typeOfIndex(inst);
     const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
-    const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
-    const name = mod.getParamName(self.func_index, src_index);
-    try self.dbg_info_relocs.append(self.gpa, .{
+    const name_nts = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.name;
-        .tag = tag,
+    if (name_nts != .none) {
-        .ty = ty,
+        const name = self.air.nullTerminatedString(@intFromEnum(name_nts));
-        .name = name,
+        try self.dbg_info_relocs.append(self.gpa, .{
-        .mcv = self.args[arg_index],
+            .tag = tag,
-    });
+            .ty = ty,
+            .name = name,
+            .mcv = self.args[arg_index],
+        });
+    }
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else self.args[arg_index];
     return self.finishAir(inst, result, .{ .none, .none, .none });

src/arch/arm/CodeGen.zig+10-10

 @@ -4206,19 +4206,19 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
     while (self.args[arg_index] == .none) arg_index += 1;
     self.arg_index = arg_index + 1;
-    const pt = self.pt;
-    const mod = pt.zcu;
     const ty = self.typeOfIndex(inst);
     const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)];
-    const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
-    const name = mod.getParamName(self.func_index, src_index);
-    try self.dbg_info_relocs.append(self.gpa, .{
+    const name_nts = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.name;
-        .tag = tag,
+    if (name_nts != .none) {
-        .ty = ty,
+        const name = self.air.nullTerminatedString(@intFromEnum(name_nts));
-        .name = name,
+        try self.dbg_info_relocs.append(self.gpa, .{
-        .mcv = self.args[arg_index],
+            .tag = tag,
-    });
+            .ty = ty,
+            .name = name,
+            .mcv = self.args[arg_index],
+        });
+    }
     const result: MCValue = if (self.liveness.isUnused(inst)) .dead else self.args[arg_index];
     return self.finishAir(inst, result, .{ .none, .none, .none });

src/arch/riscv64/CodeGen.zig+3-2

...	@@ -933,7 +933,7 @@ fn formatDecl(	...	@@ -933,7 +933,7 @@ fn formatDecl(
933	_: std.fmt.FormatOptions,	933	_: std.fmt.FormatOptions,
934	writer: anytype,	934	writer: anytype,
935	) @TypeOf(writer).Error!void {	935	) @TypeOf(writer).Error!void {
936	try data.mod.declPtr(data.decl_index).renderFullyQualifiedName(data.mod, writer);	936	try writer.print("{}", .{data.mod.declPtr(data.decl_index).fqn.fmt(&data.mod.intern_pool)});
937	}	937	}
938	fn fmtDecl(func: *Func, decl_index: InternPool.DeclIndex) std.fmt.Formatter(formatDecl) {	938	fn fmtDecl(func: *Func, decl_index: InternPool.DeclIndex) std.fmt.Formatter(formatDecl) {
939	return .{ .data = .{	939	return .{ .data = .{
...	@@ -4051,7 +4051,8 @@ fn genArgDbgInfo(func: Func, inst: Air.Inst.Index, mcv: MCValue) !void {	...	@@ -4051,7 +4051,8 @@ fn genArgDbgInfo(func: Func, inst: Air.Inst.Index, mcv: MCValue) !void {
4051	const arg = func.air.instructions.items(.data)[@intFromEnum(inst)].arg;	4051	const arg = func.air.instructions.items(.data)[@intFromEnum(inst)].arg;
4052	const ty = arg.ty.toType();	4052	const ty = arg.ty.toType();
4053	const owner_decl = zcu.funcOwnerDeclIndex(func.func_index);	4053	const owner_decl = zcu.funcOwnerDeclIndex(func.func_index);
4054	const name = zcu.getParamName(func.func_index, arg.src_index);	4054	if (arg.name == .none) return;
		4055	const name = func.air.nullTerminatedString(@intFromEnum(arg.name));
4055		4056
4056	switch (func.debug_output) {	4057	switch (func.debug_output) {
4057	.dwarf => \|dw\| switch (mcv) {	4058	.dwarf => \|dw\| switch (mcv) {

src/arch/sparc64/CodeGen.zig+2-1

...	@@ -3614,7 +3614,8 @@ fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {	...	@@ -3614,7 +3614,8 @@ fn genArgDbgInfo(self: Self, inst: Air.Inst.Index, mcv: MCValue) !void {
3614	const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg;	3614	const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg;
3615	const ty = arg.ty.toType();	3615	const ty = arg.ty.toType();
3616	const owner_decl = mod.funcOwnerDeclIndex(self.func_index);	3616	const owner_decl = mod.funcOwnerDeclIndex(self.func_index);
3617	const name = mod.getParamName(self.func_index, arg.src_index);	3617	if (arg.name == .none) return;
		3618	const name = self.air.nullTerminatedString(@intFromEnum(arg.name));
3618		3619
3619	switch (self.debug_output) {	3620	switch (self.debug_output) {
3620	.dwarf => \|dw\| switch (mcv) {	3621	.dwarf => \|dw\| switch (mcv) {

src/arch/wasm/CodeGen.zig+18-21

 @@ -2585,11 +2585,13 @@ fn airArg(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     switch (func.debug_output) {
         .dwarf => |dwarf| {
-            const src_index = func.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
+            const name_nts = func.air.instructions.items(.data)[@intFromEnum(inst)].arg.name;
-            const name = mod.getParamName(func.func_index, src_index);
+            if (name_nts != .none) {
-            try dwarf.genArgDbgInfo(name, arg_ty, mod.funcOwnerDeclIndex(func.func_index), .{
+                const name = func.air.nullTerminatedString(@intFromEnum(name_nts));
-                .wasm_local = arg.local.value,
+                try dwarf.genArgDbgInfo(name, arg_ty, mod.funcOwnerDeclIndex(func.func_index), .{
-            });
+                    .wasm_local = arg.local.value,
+                });
+            }
         },
         else => {},
     }
 @@ -3302,7 +3304,7 @@ fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
             }
         },
         .err => |err| {
-            const int = try mod.getErrorValue(err.name);
+            const int = try pt.getErrorValue(err.name);
             return WValue{ .imm32 = int };
         },
         .error_union => |error_union| {
 @@ -3450,30 +3452,25 @@ fn emitUndefined(func: *CodeGen, ty: Type) InnerError!WValue {
 /// Returns a `Value` as a signed 32 bit value.
 /// It's illegal to provide a value with a type that cannot be represented
 /// as an integer value.
-fn valueAsI32(func: *const CodeGen, val: Value, ty: Type) i32 {
+fn valueAsI32(func: *const CodeGen, val: Value) i32 {
     const pt = func.pt;
     const mod = pt.zcu;
+    const ip = &mod.intern_pool;
-    switch (val.ip_index) {
+    switch (val.toIntern()) {
-        .none => {},
         .bool_true => return 1,
         .bool_false => return 0,
-        else => return switch (mod.intern_pool.indexToKey(val.ip_index)) {
+        else => return switch (ip.indexToKey(val.ip_index)) {
-            .enum_tag => |enum_tag| intIndexAsI32(&mod.intern_pool, enum_tag.int, pt),
+            .enum_tag => |enum_tag| intIndexAsI32(ip, enum_tag.int, pt),
             .int => |int| intStorageAsI32(int.storage, pt),
             .ptr => |ptr| {
                 assert(ptr.base_addr == .int);
                 return @intCast(ptr.byte_offset);
             },
-            .err => |err| @as(i32, @bitCast(@as(Zcu.ErrorInt, @intCast(mod.global_error_set.getIndex(err.name).?)))),
+            .err => |err| @bitCast(ip.getErrorValueIfExists(err.name).?),
             else => unreachable,
         },
     }
-    return switch (ty.zigTypeTag(mod)) {
-        .ErrorSet => @as(i32, @bitCast(val.getErrorInt(mod))),
-        else => unreachable, // Programmer called this function for an illegal type
-    };
 }
 fn intIndexAsI32(ip: *const InternPool, int: InternPool.Index, pt: Zcu.PerThread) i32 {
 @@ -4096,7 +4093,7 @@ fn airSwitchBr(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
         for (items, 0..) |ref, i| {
             const item_val = (try func.air.value(ref, pt)).?;
-            const int_val = func.valueAsI32(item_val, target_ty);
+            const int_val = func.valueAsI32(item_val);
             if (lowest_maybe == null or int_val < lowest_maybe.?) {
                 lowest_maybe = int_val;
             }
 @@ -7284,8 +7281,8 @@ fn getTagNameFunction(func: *CodeGen, enum_ty: Type) InnerError!u32 {
     defer arena_allocator.deinit();
     const arena = arena_allocator.allocator();
-    const fqn = try mod.declPtr(enum_decl_index).fullyQualifiedName(pt);
+    const decl = mod.declPtr(enum_decl_index);
-    const func_name = try std.fmt.allocPrintZ(arena, "__zig_tag_name_{}", .{fqn.fmt(ip)});
+    const func_name = try std.fmt.allocPrintZ(arena, "__zig_tag_name_{}", .{decl.fqn.fmt(ip)});
     // check if we already generated code for this.
     if (func.bin_file.findGlobalSymbol(func_name)) |loc| {
 @@ -7452,7 +7449,7 @@ fn airErrorSetHasValue(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     var lowest: ?u32 = null;
     var highest: ?u32 = null;
     for (0..names.len) |name_index| {
-        const err_int: Zcu.ErrorInt = @intCast(mod.global_error_set.getIndex(names.get(ip)[name_index]).?);
+        const err_int = ip.getErrorValueIfExists(names.get(ip)[name_index]).?;
         if (lowest) |*l| {
             if (err_int < l.*) {
                 l.* = err_int;

src/arch/x86_64/CodeGen.zig+8-6

...	@@ -1077,7 +1077,7 @@ fn formatDecl(	...	@@ -1077,7 +1077,7 @@ fn formatDecl(
1077	_: std.fmt.FormatOptions,	1077	_: std.fmt.FormatOptions,
1078	writer: anytype,	1078	writer: anytype,
1079	) @TypeOf(writer).Error!void {	1079	) @TypeOf(writer).Error!void {
1080	try data.zcu.declPtr(data.decl_index).renderFullyQualifiedName(data.zcu, writer);	1080	try writer.print("{}", .{data.zcu.declPtr(data.decl_index).fqn.fmt(&data.zcu.intern_pool)});
1081	}	1081	}
1082	fn fmtDecl(self: *Self, decl_index: InternPool.DeclIndex) std.fmt.Formatter(formatDecl) {	1082	fn fmtDecl(self: *Self, decl_index: InternPool.DeclIndex) std.fmt.Formatter(formatDecl) {
1083	return .{ .data = .{	1083	return .{ .data = .{
...	@@ -11920,9 +11920,11 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -11920,9 +11920,11 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
11920	else => return self.fail("TODO implement arg for {}", .{src_mcv}),	11920	else => return self.fail("TODO implement arg for {}", .{src_mcv}),
11921	};	11921	};
11922		11922
11923	const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;	11923	const name_nts = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.name;
11924	const name = mod.getParamName(self.owner.func_index, src_index);	11924	switch (name_nts) {
11925	try self.genArgDbgInfo(arg_ty, name, src_mcv);	11925	.none => {},
		11926	_ => try self.genArgDbgInfo(arg_ty, self.air.nullTerminatedString(@intFromEnum(name_nts)), src_mcv),
		11927	}
11926		11928
11927	break :result dst_mcv;	11929	break :result dst_mcv;
11928	};	11930	};
...	@@ -16433,7 +16435,7 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -16433,7 +16435,7 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
16433	.size = .dword,	16435	.size = .dword,
16434	.index = err_reg.to64(),	16436	.index = err_reg.to64(),
16435	.scale = .@"4",	16437	.scale = .@"4",
16436	.disp = 4,	16438	.disp = (1 - 1) * 4,
16437	} },	16439	} },
16438	},	16440	},
16439	);	16441	);
...	@@ -16446,7 +16448,7 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {	...	@@ -16446,7 +16448,7 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
16446	.size = .dword,	16448	.size = .dword,
16447	.index = err_reg.to64(),	16449	.index = err_reg.to64(),
16448	.scale = .@"4",	16450	.scale = .@"4",
16449	.disp = 8,	16451	.disp = (2 - 1) * 4,
16450	} },	16452	} },
16451	},	16453	},
16452	);	16454	);

src/codegen.zig+5-5

...	@@ -137,10 +137,10 @@ pub fn generateLazySymbol(	...	@@ -137,10 +137,10 @@ pub fn generateLazySymbol(
137		137
138	if (lazy_sym.ty.isAnyError(pt.zcu)) {	138	if (lazy_sym.ty.isAnyError(pt.zcu)) {
139	alignment.* = .@"4";	139	alignment.* = .@"4";
140	const err_names = pt.zcu.global_error_set.keys();	140	const err_names = ip.global_error_set.getNamesFromMainThread();
141	mem.writeInt(u32, try code.addManyAsArray(4), @intCast(err_names.len), endian);	141	mem.writeInt(u32, try code.addManyAsArray(4), @intCast(err_names.len), endian);
142	var offset = code.items.len;	142	var offset = code.items.len;
143	try code.resize((1 + err_names.len + 1) * 4);	143	try code.resize((err_names.len + 1) * 4);
144	for (err_names) \|err_name_nts\| {	144	for (err_names) \|err_name_nts\| {
145	const err_name = err_name_nts.toSlice(ip);	145	const err_name = err_name_nts.toSlice(ip);
146	mem.writeInt(u32, code.items[offset..][0..4], @intCast(code.items.len), endian);	146	mem.writeInt(u32, code.items[offset..][0..4], @intCast(code.items.len), endian);
...	@@ -243,13 +243,13 @@ pub fn generateSymbol(	...	@@ -243,13 +243,13 @@ pub fn generateSymbol(
243	int_val.writeTwosComplement(try code.addManyAsSlice(abi_size), endian);	243	int_val.writeTwosComplement(try code.addManyAsSlice(abi_size), endian);
244	},	244	},
245	.err => \|err\| {	245	.err => \|err\| {
246	const int = try mod.getErrorValue(err.name);	246	const int = try pt.getErrorValue(err.name);
247	try code.writer().writeInt(u16, @intCast(int), endian);	247	try code.writer().writeInt(u16, @intCast(int), endian);
248	},	248	},
249	.error_union => \|error_union\| {	249	.error_union => \|error_union\| {
250	const payload_ty = ty.errorUnionPayload(mod);	250	const payload_ty = ty.errorUnionPayload(mod);
251	const err_val: u16 = switch (error_union.val) {	251	const err_val: u16 = switch (error_union.val) {
252	.err_name => \|err_name\| @intCast(try mod.getErrorValue(err_name)),	252	.err_name => \|err_name\| @intCast(try pt.getErrorValue(err_name)),
253	.payload => 0,	253	.payload => 0,
254	};	254	};
255		255
...	@@ -1058,7 +1058,7 @@ pub fn genTypedValue(	...	@@ -1058,7 +1058,7 @@ pub fn genTypedValue(
1058	},	1058	},
1059	.ErrorSet => {	1059	.ErrorSet => {
1060	const err_name = ip.indexToKey(val.toIntern()).err.name;	1060	const err_name = ip.indexToKey(val.toIntern()).err.name;
1061	const error_index = zcu.global_error_set.getIndex(err_name).?;	1061	const error_index = try pt.getErrorValue(err_name);
1062	return GenResult.mcv(.{ .immediate = error_index });	1062	return GenResult.mcv(.{ .immediate = error_index });
1063	},	1063	},
1064	.ErrorUnion => {	1064	.ErrorUnion => {

src/codegen/c.zig+14-21

 @@ -2194,13 +2194,9 @@ pub const DeclGen = struct {
         }) else {
             // MSVC has a limit of 4095 character token length limit, and fmtIdent can (worst case),
             // expand to 3x the length of its input, but let's cut it off at a much shorter limit.
-            var name: [100]u8 = undefined;
+            const fqn_slice = decl.fqn.toSlice(ip);
-            var name_stream = std.io.fixedBufferStream(&name);
-            decl.renderFullyQualifiedName(zcu, name_stream.writer()) catch |err| switch (err) {
-                error.NoSpaceLeft => {},
-            };
             try writer.print("{}__{d}", .{
-                fmtIdent(name_stream.getWritten()),
+                fmtIdent(fqn_slice[0..@min(fqn_slice.len, 100)]),
                 @intFromEnum(decl_index),
             });
         }
 @@ -2587,11 +2583,9 @@ pub fn genTypeDecl(
                 try writer.writeByte(';');
                 const owner_decl = zcu.declPtr(owner_decl_index);
                 const owner_mod = zcu.namespacePtr(owner_decl.src_namespace).fileScope(zcu).mod;
-                if (!owner_mod.strip) {
+                if (!owner_mod.strip) try writer.print(" /* {} */", .{
-                    try writer.writeAll(" /* ");
+                    owner_decl.fqn.fmt(&zcu.intern_pool),
-                    try owner_decl.renderFullyQualifiedName(zcu, writer);
+                });
-                    try writer.writeAll(" */");
-                }
                 try writer.writeByte('\n');
             },
         },
 @@ -2628,10 +2622,11 @@ pub fn genErrDecls(o: *Object) !void {
     var max_name_len: usize = 0;
     // do not generate an invalid empty enum when the global error set is empty
-    if (zcu.global_error_set.keys().len > 1) {
+    const names = ip.global_error_set.getNamesFromMainThread();
+    if (names.len > 0) {
         try writer.writeAll("enum {\n");
         o.indent_writer.pushIndent();
-        for (zcu.global_error_set.keys()[1..], 1..) |name_nts, value| {
+        for (names, 1..) |name_nts, value| {
             const name = name_nts.toSlice(ip);
             max_name_len = @max(name.len, max_name_len);
             const err_val = try pt.intern(.{ .err = .{
 @@ -2650,7 +2645,7 @@ pub fn genErrDecls(o: *Object) !void {
     defer o.dg.gpa.free(name_buf);
     @memcpy(name_buf[0..name_prefix.len], name_prefix);
-    for (zcu.global_error_set.keys()) |name| {
+    for (names) |name| {
         const name_slice = name.toSlice(ip);
         @memcpy(name_buf[name_prefix.len..][0..name_slice.len], name_slice);
         const identifier = name_buf[0 .. name_prefix.len + name_slice.len];
 @@ -2680,7 +2675,7 @@ pub fn genErrDecls(o: *Object) !void {
     }
     const name_array_ty = try pt.arrayType(.{
-        .len = zcu.global_error_set.count(),
+        .len = 1 + names.len,
         .child = .slice_const_u8_sentinel_0_type,
     });
 @@ -2694,9 +2689,9 @@ pub fn genErrDecls(o: *Object) !void {
         .complete,
     );
     try writer.writeAll(" = {");
-    for (zcu.global_error_set.keys(), 0..) |name_nts, value| {
+    for (names, 1..) |name_nts, val| {
         const name = name_nts.toSlice(ip);
-        if (value != 0) try writer.writeByte(',');
+        if (val > 1) try writer.writeAll(", ");
         try writer.print("{{" ++ name_prefix ++ "{}, {}}}", .{
             fmtIdent(name),
             try o.dg.fmtIntLiteral(try pt.intValue(Type.usize, name.len), .StaticInitializer),
 @@ -4563,9 +4558,7 @@ fn airDbgInlineBlock(f: *Function, inst: Air.Inst.Index) !CValue {
     const extra = f.air.extraData(Air.DbgInlineBlock, ty_pl.payload);
     const owner_decl = zcu.funcOwnerDeclPtr(extra.data.func);
     const writer = f.object.writer();
-    try writer.writeAll("/* inline:");
+    try writer.print("/* inline:{} */\n", .{owner_decl.fqn.fmt(&zcu.intern_pool)});
-    try owner_decl.renderFullyQualifiedName(zcu, writer);
-    try writer.writeAll(" */\n");
     return lowerBlock(f, inst, @ptrCast(f.air.extra[extra.end..][0..extra.data.body_len]));
 }
 @@ -6881,7 +6874,7 @@ fn airErrorName(f: *Function, inst: Air.Inst.Index) !CValue {
     try writer.writeAll(" = zig_errorName[");
     try f.writeCValue(writer, operand, .Other);
-    try writer.writeAll("];\n");
+    try writer.writeAll(" - 1];\n");
     return local;
 }

src/codegen/llvm.zig+34-38

 @@ -1036,20 +1036,21 @@ pub const Object = struct {
         const pt = o.pt;
         const mod = pt.zcu;
+        const ip = &mod.intern_pool;
-        const error_name_list = mod.global_error_set.keys();
+        const error_name_list = ip.global_error_set.getNamesFromMainThread();
-        const llvm_errors = try mod.gpa.alloc(Builder.Constant, error_name_list.len);
+        const llvm_errors = try mod.gpa.alloc(Builder.Constant, 1 + error_name_list.len);
         defer mod.gpa.free(llvm_errors);
         // TODO: Address space
         const slice_ty = Type.slice_const_u8_sentinel_0;
         const llvm_usize_ty = try o.lowerType(Type.usize);
         const llvm_slice_ty = try o.lowerType(slice_ty);
-        const llvm_table_ty = try o.builder.arrayType(error_name_list.len, llvm_slice_ty);
+        const llvm_table_ty = try o.builder.arrayType(1 + error_name_list.len, llvm_slice_ty);
         llvm_errors[0] = try o.builder.undefConst(llvm_slice_ty);
-        for (llvm_errors[1..], error_name_list[1..]) |*llvm_error, name| {
+        for (llvm_errors[1..], error_name_list) |*llvm_error, name| {
-            const name_string = try o.builder.stringNull(name.toSlice(&mod.intern_pool));
+            const name_string = try o.builder.stringNull(name.toSlice(ip));
             const name_init = try o.builder.stringConst(name_string);
             const name_variable_index =
                 try o.builder.addVariable(.empty, name_init.typeOf(&o.builder), .default);
 @@ -1085,7 +1086,7 @@ pub const Object = struct {
         // If there is no such function in the module, it means the source code does not need it.
         const name = o.builder.strtabStringIfExists(lt_errors_fn_name) orelse return;
         const llvm_fn = o.builder.getGlobal(name) orelse return;
-        const errors_len = o.pt.zcu.global_error_set.count();
+        const errors_len = o.pt.zcu.intern_pool.global_error_set.mutate.list.len;
         var wip = try Builder.WipFunction.init(&o.builder, .{
             .function = llvm_fn.ptrConst(&o.builder).kind.function,
 @@ -1096,12 +1097,12 @@ pub const Object = struct {
         // Example source of the following LLVM IR:
         // fn __zig_lt_errors_len(index: u16) bool {
-        //     return index < total_errors_len;
+        //     return index <= total_errors_len;
         // }
         const lhs = wip.arg(0);
         const rhs = try o.builder.intValue(try o.errorIntType(), errors_len);
-        const is_lt = try wip.icmp(.ult, lhs, rhs, "");
+        const is_lt = try wip.icmp(.ule, lhs, rhs, "");
         _ = try wip.ret(is_lt);
         try wip.finish();
     }
 @@ -1744,7 +1745,7 @@ pub const Object = struct {
         if (export_indices.len != 0) {
             return updateExportedGlobal(self, zcu, global_index, export_indices);
         } else {
-            const fqn = try self.builder.strtabString((try decl.fullyQualifiedName(pt)).toSlice(ip));
+            const fqn = try self.builder.strtabString(decl.fqn.toSlice(ip));
             try global_index.rename(fqn, &self.builder);
             global_index.setLinkage(.internal, &self.builder);
             if (comp.config.dll_export_fns)
 @@ -2811,7 +2812,7 @@ pub const Object = struct {
         const zcu = pt.zcu;
         const std_mod = zcu.std_mod;
-        const std_file_imported = zcu.importPkg(std_mod) catch unreachable;
+        const std_file_imported = pt.importPkg(std_mod) catch unreachable;
         const builtin_str = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, "builtin", .no_embedded_nulls);
         const std_file_root_decl = zcu.fileRootDecl(std_file_imported.file_index);
 @@ -2863,10 +2864,7 @@ pub const Object = struct {
         const is_extern = decl.isExtern(zcu);
         const function_index = try o.builder.addFunction(
             try o.lowerType(zig_fn_type),
-            try o.builder.strtabString((if (is_extern)
+            try o.builder.strtabString((if (is_extern) decl.name else decl.fqn).toSlice(ip)),
-                decl.name
-            else
-                try decl.fullyQualifiedName(pt)).toSlice(ip)),
             toLlvmAddressSpace(decl.@"addrspace", target),
         );
         gop.value_ptr.* = function_index.ptrConst(&o.builder).global;
 @@ -3077,14 +3075,12 @@ pub const Object = struct {
         const pt = o.pt;
         const zcu = pt.zcu;
+        const ip = &zcu.intern_pool;
         const decl = zcu.declPtr(decl_index);
         const is_extern = decl.isExtern(zcu);
         const variable_index = try o.builder.addVariable(
-            try o.builder.strtabString((if (is_extern)
+            try o.builder.strtabString((if (is_extern) decl.name else decl.fqn).toSlice(ip)),
-                decl.name
-            else
-                try decl.fullyQualifiedName(pt)).toSlice(&zcu.intern_pool)),
             try o.lowerType(decl.typeOf(zcu)),
             toLlvmGlobalAddressSpace(decl.@"addrspace", zcu.getTarget()),
         );
 @@ -3312,7 +3308,7 @@ pub const Object = struct {
                         return int_ty;
                     }
-                    const fqn = try mod.declPtr(struct_type.decl.unwrap().?).fullyQualifiedName(pt);
+                    const decl = mod.declPtr(struct_type.decl.unwrap().?);
                     var llvm_field_types = std.ArrayListUnmanaged(Builder.Type){};
                     defer llvm_field_types.deinit(o.gpa);
 @@ -3377,7 +3373,7 @@ pub const Object = struct {
                         );
                     }
-                    const ty = try o.builder.opaqueType(try o.builder.string(fqn.toSlice(ip)));
+                    const ty = try o.builder.opaqueType(try o.builder.string(decl.fqn.toSlice(ip)));
                     try o.type_map.put(o.gpa, t.toIntern(), ty);
                     o.builder.namedTypeSetBody(
 @@ -3466,7 +3462,7 @@ pub const Object = struct {
                         return enum_tag_ty;
                     }
-                    const fqn = try mod.declPtr(union_obj.decl).fullyQualifiedName(pt);
+                    const decl = mod.declPtr(union_obj.decl);
                     const aligned_field_ty = Type.fromInterned(union_obj.field_types.get(ip)[layout.most_aligned_field]);
                     const aligned_field_llvm_ty = try o.lowerType(aligned_field_ty);
 @@ -3486,7 +3482,7 @@ pub const Object = struct {
                     };
                     if (layout.tag_size == 0) {
-                        const ty = try o.builder.opaqueType(try o.builder.string(fqn.toSlice(ip)));
+                        const ty = try o.builder.opaqueType(try o.builder.string(decl.fqn.toSlice(ip)));
                         try o.type_map.put(o.gpa, t.toIntern(), ty);
                         o.builder.namedTypeSetBody(
 @@ -3514,7 +3510,7 @@ pub const Object = struct {
                         llvm_fields_len += 1;
                     }
-                    const ty = try o.builder.opaqueType(try o.builder.string(fqn.toSlice(ip)));
+                    const ty = try o.builder.opaqueType(try o.builder.string(decl.fqn.toSlice(ip)));
                     try o.type_map.put(o.gpa, t.toIntern(), ty);
                     o.builder.namedTypeSetBody(
 @@ -3527,8 +3523,7 @@ pub const Object = struct {
                     const gop = try o.type_map.getOrPut(o.gpa, t.toIntern());
                     if (!gop.found_existing) {
                         const decl = mod.declPtr(ip.loadOpaqueType(t.toIntern()).decl);
-                        const fqn = try decl.fullyQualifiedName(pt);
+                        gop.value_ptr.* = try o.builder.opaqueType(try o.builder.string(decl.fqn.toSlice(ip)));
-                        gop.value_ptr.* = try o.builder.opaqueType(try o.builder.string(fqn.toSlice(ip)));
                     }
                     return gop.value_ptr.*;
                 },
 @@ -3826,7 +3821,7 @@ pub const Object = struct {
                 return lowerBigInt(o, ty, bigint);
             },
             .err => |err| {
-                const int = try mod.getErrorValue(err.name);
+                const int = try pt.getErrorValue(err.name);
                 const llvm_int = try o.builder.intConst(try o.errorIntType(), int);
                 return llvm_int;
             },
 @@ -4587,11 +4582,11 @@ pub const Object = struct {
         const usize_ty = try o.lowerType(Type.usize);
         const ret_ty = try o.lowerType(Type.slice_const_u8_sentinel_0);
-        const fqn = try zcu.declPtr(enum_type.decl).fullyQualifiedName(pt);
+        const decl = zcu.declPtr(enum_type.decl);
         const target = zcu.root_mod.resolved_target.result;
         const function_index = try o.builder.addFunction(
             try o.builder.fnType(ret_ty, &.{try o.lowerType(Type.fromInterned(enum_type.tag_ty))}, .normal),
-            try o.builder.strtabStringFmt("__zig_tag_name_{}", .{fqn.fmt(ip)}),
+            try o.builder.strtabStringFmt("__zig_tag_name_{}", .{decl.fqn.fmt(ip)}),
             toLlvmAddressSpace(.generic, target),
         );
 @@ -5175,8 +5170,6 @@ pub const FuncGen = struct {
             const line_number = decl.navSrcLine(zcu) + 1;
             self.inlined = self.wip.debug_location;
-            const fqn = try decl.fullyQualifiedName(pt);
             const fn_ty = try pt.funcType(.{
                 .param_types = &.{},
                 .return_type = .void_type,
 @@ -5185,7 +5178,7 @@ pub const FuncGen = struct {
             self.scope = try o.builder.debugSubprogram(
                 self.file,
                 try o.builder.metadataString(decl.name.toSlice(&zcu.intern_pool)),
-                try o.builder.metadataString(fqn.toSlice(&zcu.intern_pool)),
+                try o.builder.metadataString(decl.fqn.toSlice(&zcu.intern_pool)),
                 line_number,
                 line_number + func.lbrace_line,
                 try o.lowerDebugType(fn_ty),
 @@ -8867,19 +8860,21 @@ pub const FuncGen = struct {
         self.arg_index += 1;
         // llvm does not support debug info for naked function arguments
-        if (self.wip.strip or self.is_naked) return arg_val;
+        if (self.is_naked) return arg_val;
         const inst_ty = self.typeOfIndex(inst);
         if (needDbgVarWorkaround(o)) return arg_val;
-        const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;
+        const name = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.name;
+        if (name == .none) return arg_val;
         const func_index = self.dg.decl.getOwnedFunctionIndex();
         const func = mod.funcInfo(func_index);
         const lbrace_line = mod.declPtr(func.owner_decl).navSrcLine(mod) + func.lbrace_line + 1;
         const lbrace_col = func.lbrace_column + 1;
         const debug_parameter = try o.builder.debugParameter(
-            try o.builder.metadataString(mod.getParamName(func_index, src_index)),
+            try o.builder.metadataString(self.air.nullTerminatedString(@intFromEnum(name))),
             self.file,
             self.scope,
             lbrace_line,
 @@ -9664,7 +9659,7 @@ pub const FuncGen = struct {
         defer wip_switch.finish(&self.wip);
         for (0..names.len) |name_index| {
-            const err_int = mod.global_error_set.getIndex(names.get(ip)[name_index]).?;
+            const err_int = ip.getErrorValueIfExists(names.get(ip)[name_index]).?;
             const this_tag_int_value = try o.builder.intConst(try o.errorIntType(), err_int);
             try wip_switch.addCase(this_tag_int_value, valid_block, &self.wip);
         }
 @@ -9702,18 +9697,19 @@ pub const FuncGen = struct {
         const o = self.dg.object;
         const pt = o.pt;
         const zcu = pt.zcu;
-        const enum_type = zcu.intern_pool.loadEnumType(enum_ty.toIntern());
+        const ip = &zcu.intern_pool;
+        const enum_type = ip.loadEnumType(enum_ty.toIntern());
         // TODO: detect when the type changes and re-emit this function.
         const gop = try o.named_enum_map.getOrPut(o.gpa, enum_type.decl);
         if (gop.found_existing) return gop.value_ptr.*;
         errdefer assert(o.named_enum_map.remove(enum_type.decl));
-        const fqn = try zcu.declPtr(enum_type.decl).fullyQualifiedName(pt);
+        const decl = zcu.declPtr(enum_type.decl);
         const target = zcu.root_mod.resolved_target.result;
         const function_index = try o.builder.addFunction(
             try o.builder.fnType(.i1, &.{try o.lowerType(Type.fromInterned(enum_type.tag_ty))}, .normal),
-            try o.builder.strtabStringFmt("__zig_is_named_enum_value_{}", .{fqn.fmt(&zcu.intern_pool)}),
+            try o.builder.strtabStringFmt("__zig_is_named_enum_value_{}", .{decl.fqn.fmt(ip)}),
             toLlvmAddressSpace(.generic, target),
         );

src/codegen/spirv.zig+5-8

...	@@ -963,7 +963,7 @@ const DeclGen = struct {	...	@@ -963,7 +963,7 @@ const DeclGen = struct {
963	break :cache result_id;	963	break :cache result_id;
964	},	964	},
965	.err => \|err\| {	965	.err => \|err\| {
966	const value = try mod.getErrorValue(err.name);	966	const value = try pt.getErrorValue(err.name);
967	break :cache try self.constInt(ty, value, repr);	967	break :cache try self.constInt(ty, value, repr);
968	},	968	},
969	.error_union => \|error_union\| {	969	.error_union => \|error_union\| {
...	@@ -3012,12 +3012,11 @@ const DeclGen = struct {	...	@@ -3012,12 +3012,11 @@ const DeclGen = struct {
3012	// Append the actual code into the functions section.	3012	// Append the actual code into the functions section.
3013	try self.spv.addFunction(spv_decl_index, self.func);	3013	try self.spv.addFunction(spv_decl_index, self.func);
3014		3014
3015	const fqn = try decl.fullyQualifiedName(self.pt);	3015	try self.spv.debugName(result_id, decl.fqn.toSlice(ip));
3016	try self.spv.debugName(result_id, fqn.toSlice(ip));
3017		3016
3018	// Temporarily generate a test kernel declaration if this is a test function.	3017	// Temporarily generate a test kernel declaration if this is a test function.
3019	if (self.pt.zcu.test_functions.contains(self.decl_index)) {	3018	if (self.pt.zcu.test_functions.contains(self.decl_index)) {
3020	try self.generateTestEntryPoint(fqn.toSlice(ip), spv_decl_index);	3019	try self.generateTestEntryPoint(decl.fqn.toSlice(ip), spv_decl_index);
3021	}	3020	}
3022	},	3021	},
3023	.global => {	3022	.global => {
...	@@ -3041,8 +3040,7 @@ const DeclGen = struct {	...	@@ -3041,8 +3040,7 @@ const DeclGen = struct {
3041	.storage_class = final_storage_class,	3040	.storage_class = final_storage_class,
3042	});	3041	});
3043		3042
3044	const fqn = try decl.fullyQualifiedName(self.pt);	3043	try self.spv.debugName(result_id, decl.fqn.toSlice(ip));
3045	try self.spv.debugName(result_id, fqn.toSlice(ip));
3046	try self.spv.declareDeclDeps(spv_decl_index, &.{});	3044	try self.spv.declareDeclDeps(spv_decl_index, &.{});
3047	},	3045	},
3048	.invocation_global => {	3046	.invocation_global => {
...	@@ -3086,8 +3084,7 @@ const DeclGen = struct {	...	@@ -3086,8 +3084,7 @@ const DeclGen = struct {
3086	try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {});	3084	try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {});
3087	try self.spv.addFunction(spv_decl_index, self.func);	3085	try self.spv.addFunction(spv_decl_index, self.func);
3088		3086
3089	const fqn = try decl.fullyQualifiedName(self.pt);	3087	try self.spv.debugNameFmt(initializer_id, "initializer of {}", .{decl.fqn.fmt(ip)});
3090	try self.spv.debugNameFmt(initializer_id, "initializer of {}", .{fqn.fmt(ip)});
3091		3088
3092	try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpExtInst, .{	3089	try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpExtInst, .{
3093	.id_result_type = ptr_ty_id,	3090	.id_result_type = ptr_ty_id,

src/link/Coff.zig+8-9

 @@ -1176,9 +1176,10 @@ pub fn lowerUnnamedConst(self: *Coff, pt: Zcu.PerThread, val: Value, decl_index:
         gop.value_ptr.* = .{};
     }
     const unnamed_consts = gop.value_ptr;
-    const decl_name = try decl.fullyQualifiedName(pt);
     const index = unnamed_consts.items.len;
-    const sym_name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl_name.fmt(&mod.intern_pool), index });
+    const sym_name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{
+        decl.fqn.fmt(&mod.intern_pool), index,
+    });
     defer gpa.free(sym_name);
     const ty = val.typeOf(mod);
     const atom_index = switch (try self.lowerConst(pt, sym_name, val, ty.abiAlignment(pt), self.rdata_section_index.?, decl.navSrcLoc(mod))) {
 @@ -1427,9 +1428,7 @@ fn updateDeclCode(self: *Coff, pt: Zcu.PerThread, decl_index: InternPool.DeclInd
     const mod = pt.zcu;
     const decl = mod.declPtr(decl_index);
-    const decl_name = try decl.fullyQualifiedName(pt);
+    log.debug("updateDeclCode {}{*}", .{ decl.fqn.fmt(&mod.intern_pool), decl });
-    log.debug("updateDeclCode {}{*}", .{ decl_name.fmt(&mod.intern_pool), decl });
     const required_alignment: u32 = @intCast(decl.getAlignment(pt).toByteUnits() orelse 0);
     const decl_metadata = self.decls.get(decl_index).?;
 @@ -1441,7 +1440,7 @@ fn updateDeclCode(self: *Coff, pt: Zcu.PerThread, decl_index: InternPool.DeclInd
     if (atom.size != 0) {
         const sym = atom.getSymbolPtr(self);
-        try self.setSymbolName(sym, decl_name.toSlice(&mod.intern_pool));
+        try self.setSymbolName(sym, decl.fqn.toSlice(&mod.intern_pool));
         sym.section_number = @as(coff.SectionNumber, @enumFromInt(sect_index + 1));
         sym.type = .{ .complex_type = complex_type, .base_type = .NULL };
 @@ -1449,7 +1448,7 @@ fn updateDeclCode(self: *Coff, pt: Zcu.PerThread, decl_index: InternPool.DeclInd
         const need_realloc = code.len > capacity or !mem.isAlignedGeneric(u64, sym.value, required_alignment);
         if (need_realloc) {
             const vaddr = try self.growAtom(atom_index, code_len, required_alignment);
-            log.debug("growing {} from 0x{x} to 0x{x}", .{ decl_name.fmt(&mod.intern_pool), sym.value, vaddr });
+            log.debug("growing {} from 0x{x} to 0x{x}", .{ decl.fqn.fmt(&mod.intern_pool), sym.value, vaddr });
             log.debug("  (required alignment 0x{x}", .{required_alignment});
             if (vaddr != sym.value) {
 @@ -1465,13 +1464,13 @@ fn updateDeclCode(self: *Coff, pt: Zcu.PerThread, decl_index: InternPool.DeclInd
         self.getAtomPtr(atom_index).size = code_len;
     } else {
         const sym = atom.getSymbolPtr(self);
-        try self.setSymbolName(sym, decl_name.toSlice(&mod.intern_pool));
+        try self.setSymbolName(sym, decl.fqn.toSlice(&mod.intern_pool));
         sym.section_number = @as(coff.SectionNumber, @enumFromInt(sect_index + 1));
         sym.type = .{ .complex_type = complex_type, .base_type = .NULL };
         const vaddr = try self.allocateAtom(atom_index, code_len, required_alignment);
         errdefer self.freeAtom(atom_index);
-        log.debug("allocated atom for {} at 0x{x}", .{ decl_name.fmt(&mod.intern_pool), vaddr });
+        log.debug("allocated atom for {} at 0x{x}", .{ decl.fqn.fmt(&mod.intern_pool), vaddr });
         self.getAtomPtr(atom_index).size = code_len;
         sym.value = vaddr;

src/link/Dwarf.zig+4-6

...	@@ -1082,9 +1082,7 @@ pub fn initDeclState(self: *Dwarf, pt: Zcu.PerThread, decl_index: InternPool.Dec	...	@@ -1082,9 +1082,7 @@ pub fn initDeclState(self: *Dwarf, pt: Zcu.PerThread, decl_index: InternPool.Dec
1082	defer tracy.end();	1082	defer tracy.end();
1083		1083
1084	const decl = pt.zcu.declPtr(decl_index);	1084	const decl = pt.zcu.declPtr(decl_index);
1085	const decl_linkage_name = try decl.fullyQualifiedName(pt);	1085	log.debug("initDeclState {}{*}", .{ decl.fqn.fmt(&pt.zcu.intern_pool), decl });
1086
1087	log.debug("initDeclState {}{*}", .{ decl_linkage_name.fmt(&pt.zcu.intern_pool), decl });
1088		1086
1089	const gpa = self.allocator;	1087	const gpa = self.allocator;
1090	var decl_state: DeclState = .{	1088	var decl_state: DeclState = .{
...	@@ -1157,7 +1155,7 @@ pub fn initDeclState(self: *Dwarf, pt: Zcu.PerThread, decl_index: InternPool.Dec	...	@@ -1157,7 +1155,7 @@ pub fn initDeclState(self: *Dwarf, pt: Zcu.PerThread, decl_index: InternPool.Dec
1157		1155
1158	// .debug_info subprogram	1156	// .debug_info subprogram
1159	const decl_name_slice = decl.name.toSlice(&pt.zcu.intern_pool);	1157	const decl_name_slice = decl.name.toSlice(&pt.zcu.intern_pool);
1160	const decl_linkage_name_slice = decl_linkage_name.toSlice(&pt.zcu.intern_pool);	1158	const decl_linkage_name_slice = decl.fqn.toSlice(&pt.zcu.intern_pool);
1161	try dbg_info_buffer.ensureUnusedCapacity(1 + ptr_width_bytes + 4 + 4 +	1159	try dbg_info_buffer.ensureUnusedCapacity(1 + ptr_width_bytes + 4 + 4 +
1162	(decl_name_slice.len + 1) + (decl_linkage_name_slice.len + 1));	1160	(decl_name_slice.len + 1) + (decl_linkage_name_slice.len + 1));
1163		1161
...	@@ -2700,7 +2698,7 @@ pub fn flushModule(self: *Dwarf, pt: Zcu.PerThread) !void {	...	@@ -2700,7 +2698,7 @@ pub fn flushModule(self: *Dwarf, pt: Zcu.PerThread) !void {
2700	try addDbgInfoErrorSetNames(	2698	try addDbgInfoErrorSetNames(
2701	pt,	2699	pt,
2702	Type.anyerror,	2700	Type.anyerror,
2703	pt.zcu.global_error_set.keys(),	2701	pt.zcu.intern_pool.global_error_set.getNamesFromMainThread(),
2704	target,	2702	target,
2705	&dbg_info_buffer,	2703	&dbg_info_buffer,
2706	);	2704	);
...	@@ -2869,7 +2867,7 @@ fn addDbgInfoErrorSetNames(	...	@@ -2869,7 +2867,7 @@ fn addDbgInfoErrorSetNames(
2869	mem.writeInt(u64, dbg_info_buffer.addManyAsArrayAssumeCapacity(8), 0, target_endian);	2867	mem.writeInt(u64, dbg_info_buffer.addManyAsArrayAssumeCapacity(8), 0, target_endian);
2870		2868
2871	for (error_names) \|error_name\| {	2869	for (error_names) \|error_name\| {
2872	const int = try pt.zcu.getErrorValue(error_name);	2870	const int = try pt.getErrorValue(error_name);
2873	const error_name_slice = error_name.toSlice(&pt.zcu.intern_pool);	2871	const error_name_slice = error_name.toSlice(&pt.zcu.intern_pool);
2874	// DW.AT.enumerator	2872	// DW.AT.enumerator
2875	try dbg_info_buffer.ensureUnusedCapacity(error_name_slice.len + 2 + @sizeOf(u64));	2873	try dbg_info_buffer.ensureUnusedCapacity(error_name_slice.len + 2 + @sizeOf(u64));

src/link/Elf/ZigObject.zig+9-11

...	@@ -907,10 +907,10 @@ fn updateDeclCode(	...	@@ -907,10 +907,10 @@ fn updateDeclCode(
907	) !void {	907	) !void {
908	const gpa = elf_file.base.comp.gpa;	908	const gpa = elf_file.base.comp.gpa;
909	const mod = pt.zcu;	909	const mod = pt.zcu;
		910	const ip = &mod.intern_pool;
910	const decl = mod.declPtr(decl_index);	911	const decl = mod.declPtr(decl_index);
911	const decl_name = try decl.fullyQualifiedName(pt);
912		912
913	log.debug("updateDeclCode {}{*}", .{ decl_name.fmt(&mod.intern_pool), decl });	913	log.debug("updateDeclCode {}{*}", .{ decl.fqn.fmt(ip), decl });
914		914
915	const required_alignment = decl.getAlignment(pt).max(	915	const required_alignment = decl.getAlignment(pt).max(
916	target_util.minFunctionAlignment(mod.getTarget()),	916	target_util.minFunctionAlignment(mod.getTarget()),
...	@@ -923,7 +923,7 @@ fn updateDeclCode(	...	@@ -923,7 +923,7 @@ fn updateDeclCode(
923	sym.output_section_index = shdr_index;	923	sym.output_section_index = shdr_index;
924	atom_ptr.output_section_index = shdr_index;	924	atom_ptr.output_section_index = shdr_index;
925		925
926	sym.name_offset = try self.strtab.insert(gpa, decl_name.toSlice(&mod.intern_pool));	926	sym.name_offset = try self.strtab.insert(gpa, decl.fqn.toSlice(ip));
927	atom_ptr.flags.alive = true;	927	atom_ptr.flags.alive = true;
928	atom_ptr.name_offset = sym.name_offset;	928	atom_ptr.name_offset = sym.name_offset;
929	esym.st_name = sym.name_offset;	929	esym.st_name = sym.name_offset;
...	@@ -940,7 +940,7 @@ fn updateDeclCode(	...	@@ -940,7 +940,7 @@ fn updateDeclCode(
940	const need_realloc = code.len > capacity or !required_alignment.check(@intCast(atom_ptr.value));	940	const need_realloc = code.len > capacity or !required_alignment.check(@intCast(atom_ptr.value));
941	if (need_realloc) {	941	if (need_realloc) {
942	try atom_ptr.grow(elf_file);	942	try atom_ptr.grow(elf_file);
943	log.debug("growing {} from 0x{x} to 0x{x}", .{ decl_name.fmt(&mod.intern_pool), old_vaddr, atom_ptr.value });	943	log.debug("growing {} from 0x{x} to 0x{x}", .{ decl.fqn.fmt(ip), old_vaddr, atom_ptr.value });
944	if (old_vaddr != atom_ptr.value) {	944	if (old_vaddr != atom_ptr.value) {
945	sym.value = 0;	945	sym.value = 0;
946	esym.st_value = 0;	946	esym.st_value = 0;
...	@@ -1007,11 +1007,11 @@ fn updateTlv(	...	@@ -1007,11 +1007,11 @@ fn updateTlv(
1007	code: []const u8,	1007	code: []const u8,
1008	) !void {	1008	) !void {
1009	const mod = pt.zcu;	1009	const mod = pt.zcu;
		1010	const ip = &mod.intern_pool;
1010	const gpa = mod.gpa;	1011	const gpa = mod.gpa;
1011	const decl = mod.declPtr(decl_index);	1012	const decl = mod.declPtr(decl_index);
1012	const decl_name = try decl.fullyQualifiedName(pt);
1013		1013
1014	log.debug("updateTlv {} ({*})", .{ decl_name.fmt(&mod.intern_pool), decl });	1014	log.debug("updateTlv {} ({*})", .{ decl.fqn.fmt(ip), decl });
1015		1015
1016	const required_alignment = decl.getAlignment(pt);	1016	const required_alignment = decl.getAlignment(pt);
1017		1017
...	@@ -1023,7 +1023,7 @@ fn updateTlv(	...	@@ -1023,7 +1023,7 @@ fn updateTlv(
1023	sym.output_section_index = shndx;	1023	sym.output_section_index = shndx;
1024	atom_ptr.output_section_index = shndx;	1024	atom_ptr.output_section_index = shndx;
1025		1025
1026	sym.name_offset = try self.strtab.insert(gpa, decl_name.toSlice(&mod.intern_pool));	1026	sym.name_offset = try self.strtab.insert(gpa, decl.fqn.toSlice(ip));
1027	atom_ptr.flags.alive = true;	1027	atom_ptr.flags.alive = true;
1028	atom_ptr.name_offset = sym.name_offset;	1028	atom_ptr.name_offset = sym.name_offset;
1029	esym.st_value = 0;	1029	esym.st_value = 0;
...	@@ -1286,9 +1286,8 @@ pub fn lowerUnnamedConst(	...	@@ -1286,9 +1286,8 @@ pub fn lowerUnnamedConst(
1286	}	1286	}
1287	const unnamed_consts = gop.value_ptr;	1287	const unnamed_consts = gop.value_ptr;
1288	const decl = mod.declPtr(decl_index);	1288	const decl = mod.declPtr(decl_index);
1289	const decl_name = try decl.fullyQualifiedName(pt);
1290	const index = unnamed_consts.items.len;	1289	const index = unnamed_consts.items.len;
1291	const name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl_name.fmt(&mod.intern_pool), index });	1290	const name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl.fqn.fmt(&mod.intern_pool), index });
1292	defer gpa.free(name);	1291	defer gpa.free(name);
1293	const ty = val.typeOf(mod);	1292	const ty = val.typeOf(mod);
1294	const sym_index = switch (try self.lowerConst(	1293	const sym_index = switch (try self.lowerConst(
...	@@ -1473,9 +1472,8 @@ pub fn updateDeclLineNumber(	...	@@ -1473,9 +1472,8 @@ pub fn updateDeclLineNumber(
1473	defer tracy.end();	1472	defer tracy.end();
1474		1473
1475	const decl = pt.zcu.declPtr(decl_index);	1474	const decl = pt.zcu.declPtr(decl_index);
1476	const decl_name = try decl.fullyQualifiedName(pt);
1477		1475
1478	log.debug("updateDeclLineNumber {}{*}", .{ decl_name.fmt(&pt.zcu.intern_pool), decl });	1476	log.debug("updateDeclLineNumber {}{*}", .{ decl.fqn.fmt(&pt.zcu.intern_pool), decl });
1479		1477
1480	if (self.dwarf) \|*dw\| {	1478	if (self.dwarf) \|*dw\| {
1481	try dw.updateDeclLineNumber(pt.zcu, decl_index);	1479	try dw.updateDeclLineNumber(pt.zcu, decl_index);

src/link/MachO/ZigObject.zig+10-14

 @@ -809,10 +809,10 @@ fn updateDeclCode(
 ) !void {
     const gpa = macho_file.base.comp.gpa;
     const mod = pt.zcu;
+    const ip = &mod.intern_pool;
     const decl = mod.declPtr(decl_index);
-    const decl_name = try decl.fullyQualifiedName(pt);
-    log.debug("updateDeclCode {}{*}", .{ decl_name.fmt(&mod.intern_pool), decl });
+    log.debug("updateDeclCode {}{*}", .{ decl.fqn.fmt(ip), decl });
     const required_alignment = decl.getAlignment(pt);
 @@ -824,7 +824,7 @@ fn updateDeclCode(
     sym.out_n_sect = sect_index;
     atom.out_n_sect = sect_index;
-    sym.name = try self.strtab.insert(gpa, decl_name.toSlice(&mod.intern_pool));
+    sym.name = try self.strtab.insert(gpa, decl.fqn.toSlice(ip));
     atom.flags.alive = true;
     atom.name = sym.name;
     nlist.n_strx = sym.name;
 @@ -843,7 +843,7 @@ fn updateDeclCode(
         if (need_realloc) {
             try atom.grow(macho_file);
-            log.debug("growing {} from 0x{x} to 0x{x}", .{ decl_name.fmt(&mod.intern_pool), old_vaddr, atom.value });
+            log.debug("growing {} from 0x{x} to 0x{x}", .{ decl.fqn.fmt(ip), old_vaddr, atom.value });
             if (old_vaddr != atom.value) {
                 sym.value = 0;
                 nlist.n_value = 0;
 @@ -893,25 +893,22 @@ fn updateTlv(
     sect_index: u8,
     code: []const u8,
 ) !void {
+    const ip = &pt.zcu.intern_pool;
     const decl = pt.zcu.declPtr(decl_index);
-    const decl_name = try decl.fullyQualifiedName(pt);
-    log.debug("updateTlv {} ({*})", .{ decl_name.fmt(&pt.zcu.intern_pool), decl });
+    log.debug("updateTlv {} ({*})", .{ decl.fqn.fmt(&pt.zcu.intern_pool), decl });
-    const decl_name_slice = decl_name.toSlice(&pt.zcu.intern_pool);
-    const required_alignment = decl.getAlignment(pt);
     // 1. Lower TLV initializer
     const init_sym_index = try self.createTlvInitializer(
         macho_file,
-        decl_name_slice,
+        decl.fqn.toSlice(ip),
-        required_alignment,
+        decl.getAlignment(pt),
         sect_index,
         code,
     );
     // 2. Create TLV descriptor
-    try self.createTlvDescriptor(macho_file, sym_index, init_sym_index, decl_name_slice);
+    try self.createTlvDescriptor(macho_file, sym_index, init_sym_index, decl.fqn.toSlice(ip));
 }
 fn createTlvInitializer(
 @@ -1099,9 +1096,8 @@ pub fn lowerUnnamedConst(
     }
     const unnamed_consts = gop.value_ptr;
     const decl = mod.declPtr(decl_index);
-    const decl_name = try decl.fullyQualifiedName(pt);
     const index = unnamed_consts.items.len;
-    const name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl_name.fmt(&mod.intern_pool), index });
+    const name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl.fqn.fmt(&mod.intern_pool), index });
     defer gpa.free(name);
     const sym_index = switch (try self.lowerConst(
         macho_file,

src/link/Plan9.zig+1-3

 @@ -483,11 +483,9 @@ pub fn lowerUnnamedConst(self: *Plan9, pt: Zcu.PerThread, val: Value, decl_index
     }
     const unnamed_consts = gop.value_ptr;
-    const decl_name = try decl.fullyQualifiedName(pt);
     const index = unnamed_consts.items.len;
     // name is freed when the unnamed const is freed
-    const name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl_name.fmt(&mod.intern_pool), index });
+    const name = try std.fmt.allocPrint(gpa, "__unnamed_{}_{d}", .{ decl.fqn.fmt(&mod.intern_pool), index });
     const sym_index = try self.allocateSymbolIndex();
     const new_atom_idx = try self.createAtom();

src/link/SpirV.zig+4-4

...	@@ -227,9 +227,9 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n	...	@@ -227,9 +227,9 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
227	var error_info = std.ArrayList(u8).init(self.object.gpa);	227	var error_info = std.ArrayList(u8).init(self.object.gpa);
228	defer error_info.deinit();	228	defer error_info.deinit();
229		229
230	try error_info.appendSlice("zig_errors");	230	try error_info.appendSlice("zig_errors:");
231	const mod = self.base.comp.module.?;	231	const ip = &self.base.comp.module.?.intern_pool;
232	for (mod.global_error_set.keys()) \|name\| {	232	for (ip.global_error_set.getNamesFromMainThread()) \|name\| {
233	// Errors can contain pretty much any character - to encode them in a string we must escape	233	// Errors can contain pretty much any character - to encode them in a string we must escape
234	// them somehow. Easiest here is to use some established scheme, one which also preseves the	234	// them somehow. Easiest here is to use some established scheme, one which also preseves the
235	// name if it contains no strange characters is nice for debugging. URI encoding fits the bill.	235	// name if it contains no strange characters is nice for debugging. URI encoding fits the bill.
...	@@ -238,7 +238,7 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n	...	@@ -238,7 +238,7 @@ pub fn flushModule(self: *SpirV, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
238	try error_info.append(':');	238	try error_info.append(':');
239	try std.Uri.Component.percentEncode(	239	try std.Uri.Component.percentEncode(
240	error_info.writer(),	240	error_info.writer(),
241	name.toSlice(&mod.intern_pool),	241	name.toSlice(ip),
242	struct {	242	struct {
243	fn isValidChar(c: u8) bool {	243	fn isValidChar(c: u8) bool {
244	return switch (c) {	244	return switch (c) {

src/link/Wasm/ZigObject.zig+20-16

 @@ -346,8 +346,7 @@ fn finishUpdateDecl(
     const atom_index = decl_info.atom;
     const atom = wasm_file.getAtomPtr(atom_index);
     const sym = zig_object.symbol(atom.sym_index);
-    const full_name = try decl.fullyQualifiedName(pt);
+    sym.name = try zig_object.string_table.insert(gpa, decl.fqn.toSlice(ip));
-    sym.name = try zig_object.string_table.insert(gpa, full_name.toSlice(ip));
     try atom.code.appendSlice(gpa, code);
     atom.size = @intCast(code.len);
 @@ -387,7 +386,7 @@ fn finishUpdateDecl(
             // Will be freed upon freeing of decl or after cleanup of Wasm binary.
             const full_segment_name = try std.mem.concat(gpa, u8, &.{
                 segment_name,
-                full_name.toSlice(ip),
+                decl.fqn.toSlice(ip),
             });
             errdefer gpa.free(full_segment_name);
             sym.tag = .data;
 @@ -436,9 +435,8 @@ pub fn getOrCreateAtomForDecl(
         const sym_index = try zig_object.allocateSymbol(gpa);
         gop.value_ptr.* = .{ .atom = try wasm_file.createAtom(sym_index, zig_object.index) };
         const decl = pt.zcu.declPtr(decl_index);
-        const full_name = try decl.fullyQualifiedName(pt);
         const sym = zig_object.symbol(sym_index);
-        sym.name = try zig_object.string_table.insert(gpa, full_name.toSlice(&pt.zcu.intern_pool));
+        sym.name = try zig_object.string_table.insert(gpa, decl.fqn.toSlice(&pt.zcu.intern_pool));
     }
     return gop.value_ptr.atom;
 }
 @@ -494,9 +492,8 @@ pub fn lowerUnnamedConst(
     const parent_atom_index = try zig_object.getOrCreateAtomForDecl(wasm_file, pt, decl_index);
     const parent_atom = wasm_file.getAtom(parent_atom_index);
     const local_index = parent_atom.locals.items.len;
-    const fqn = try decl.fullyQualifiedName(pt);
     const name = try std.fmt.allocPrintZ(gpa, "__unnamed_{}_{d}", .{
-        fqn.fmt(&mod.intern_pool), local_index,
+        decl.fqn.fmt(&mod.intern_pool), local_index,
     });
     defer gpa.free(name);
 @@ -655,13 +652,22 @@ fn populateErrorNameTable(zig_object: *ZigObject, wasm_file: *Wasm, tid: Zcu.Per
     // Addend for each relocation to the table
     var addend: u32 = 0;
     const pt: Zcu.PerThread = .{ .zcu = wasm_file.base.comp.module.?, .tid = tid };
-    for (pt.zcu.global_error_set.keys()) |error_name| {
+    const slice_ty = Type.slice_const_u8_sentinel_0;
-        const atom = wasm_file.getAtomPtr(atom_index);
+    const atom = wasm_file.getAtomPtr(atom_index);
+    {
+        // TODO: remove this unreachable entry
+        try atom.code.appendNTimes(gpa, 0, 4);
+        try atom.code.writer(gpa).writeInt(u32, 0, .little);
+        atom.size += @intCast(slice_ty.abiSize(pt));
+        addend += 1;
-        const error_name_slice = error_name.toSlice(&pt.zcu.intern_pool);
+        try names_atom.code.append(gpa, 0);
+    }
+    const ip = &pt.zcu.intern_pool;
+    for (ip.global_error_set.getNamesFromMainThread()) |error_name| {
+        const error_name_slice = error_name.toSlice(ip);
         const len: u32 = @intCast(error_name_slice.len + 1); // names are 0-terminated
-        const slice_ty = Type.slice_const_u8_sentinel_0;
         const offset = @as(u32, @intCast(atom.code.items.len));
         // first we create the data for the slice of the name
         try atom.code.appendNTimes(gpa, 0, 4); // ptr to name, will be relocated
 @@ -680,7 +686,7 @@ fn populateErrorNameTable(zig_object: *ZigObject, wasm_file: *Wasm, tid: Zcu.Per
         try names_atom.code.ensureUnusedCapacity(gpa, len);
         names_atom.code.appendSliceAssumeCapacity(error_name_slice[0..len]);
-        log.debug("Populated error name: '{}'", .{error_name.fmt(&pt.zcu.intern_pool)});
+        log.debug("Populated error name: '{}'", .{error_name.fmt(ip)});
     }
     names_atom.size = addend;
     zig_object.error_names_atom = names_atom_index;
 @@ -1045,7 +1051,7 @@ fn setupErrorsLen(zig_object: *ZigObject, wasm_file: *Wasm) !void {
     const gpa = wasm_file.base.comp.gpa;
     const sym_index = zig_object.findGlobalSymbol("__zig_errors_len") orelse return;
-    const errors_len = wasm_file.base.comp.module.?.global_error_set.count();
+    const errors_len = 1 + wasm_file.base.comp.module.?.intern_pool.global_error_set.mutate.list.len;
     // overwrite existing atom if it already exists (maybe the error set has increased)
     // if not, allcoate a new atom.
     const atom_index = if (wasm_file.symbol_atom.get(.{ .file = zig_object.index, .index = sym_index })) |index| blk: {
 @@ -1127,9 +1133,7 @@ pub fn updateDeclLineNumber(
 ) !void {
     if (zig_object.dwarf) |*dw| {
         const decl = pt.zcu.declPtr(decl_index);
-        const decl_name = try decl.fullyQualifiedName(pt);
+        log.debug("updateDeclLineNumber {}{*}", .{ decl.fqn.fmt(&pt.zcu.intern_pool), decl });
-        log.debug("updateDeclLineNumber {}{*}", .{ decl_name.fmt(&pt.zcu.intern_pool), decl });
         try dw.updateDeclLineNumber(pt.zcu, decl_index);
     }
 }

src/print_air.zig+7-1

 @@ -356,7 +356,13 @@ const Writer = struct {
     fn writeArg(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {
         const arg = w.air.instructions.items(.data)[@intFromEnum(inst)].arg;
         try w.writeType(s, arg.ty.toType());
-        try s.print(", {d}", .{arg.src_index});
+        switch (arg.name) {
+            .none => {},
+            _ => {
+                const name = w.air.nullTerminatedString(@intFromEnum(arg.name));
+                try s.print(", \"{}\"", .{std.zig.fmtEscapes(name)});
+            },
+        }
     }
     fn writeTyOp(w: *Writer, s: anytype, inst: Air.Inst.Index) @TypeOf(s).Error!void {

src/print_value.zig+2-2

...	@@ -299,8 +299,8 @@ fn printPtrDerivation(derivation: Value.PointerDeriveStep, writer: anytype, leve	...	@@ -299,8 +299,8 @@ fn printPtrDerivation(derivation: Value.PointerDeriveStep, writer: anytype, leve
299	int.ptr_ty.fmt(pt),	299	int.ptr_ty.fmt(pt),
300	int.addr,	300	int.addr,
301	}),	301	}),
302	.decl_ptr => \|decl\| {	302	.decl_ptr => \|decl_index\| {
303	try zcu.declPtr(decl).renderFullyQualifiedName(zcu, writer);	303	try writer.print("{}", .{zcu.declPtr(decl_index).fqn.fmt(ip)});
304	},	304	},
305	.anon_decl_ptr => \|anon\| {	305	.anon_decl_ptr => \|anon\| {
306	const ty = Value.fromInterned(anon.val).typeOf(zcu);	306	const ty = Value.fromInterned(anon.val).typeOf(zcu);

...	@@ -417,7 +417,7 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro	...	@@ -417,7 +417,7 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro
417	var bigint_buffer: BigIntSpace = undefined;	417	var bigint_buffer: BigIntSpace = undefined;
418	const bigint = BigIntMutable.init(	418	const bigint = BigIntMutable.init(
419	&bigint_buffer.limbs,	419	&bigint_buffer.limbs,
420	mod.global_error_set.getIndex(name).?,	420	ip.getErrorValueIfExists(name).?,
421	).toConst();	421	).toConst();
422	bigint.writeTwosComplement(buffer[0..byte_count], endian);	422	bigint.writeTwosComplement(buffer[0..byte_count], endian);
423	},	423	},
...	@@ -427,7 +427,7 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro	...	@@ -427,7 +427,7 @@ pub fn writeToMemory(val: Value, ty: Type, pt: Zcu.PerThread, buffer: []u8) erro
427	if (val.unionTag(mod)) \|union_tag\| {	427	if (val.unionTag(mod)) \|union_tag\| {
428	const union_obj = mod.typeToUnion(ty).?;	428	const union_obj = mod.typeToUnion(ty).?;
429	const field_index = mod.unionTagFieldIndex(union_obj, union_tag).?;	429	const field_index = mod.unionTagFieldIndex(union_obj, union_tag).?;
430	const field_type = Type.fromInterned(union_obj.field_types.get(&mod.intern_pool)[field_index]);	430	const field_type = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
431	const field_val = try val.fieldValue(pt, field_index);	431	const field_val = try val.fieldValue(pt, field_index);
432	const byte_count: usize = @intCast(field_type.abiSize(pt));	432	const byte_count: usize = @intCast(field_type.abiSize(pt));
433	return writeToMemory(field_val, field_type, pt, buffer[0..byte_count]);	433	return writeToMemory(field_val, field_type, pt, buffer[0..byte_count]);
...	@@ -1455,9 +1455,9 @@ pub fn getErrorName(val: Value, mod: *const Module) InternPool.OptionalNullTermi	...	@@ -1455,9 +1455,9 @@ pub fn getErrorName(val: Value, mod: *const Module) InternPool.OptionalNullTermi
1455	};	1455	};
1456	}	1456	}
1457		1457
1458	pub fn getErrorInt(val: Value, mod: *const Module) Module.ErrorInt {	1458	pub fn getErrorInt(val: Value, zcu: *Zcu) Module.ErrorInt {
1459	return if (getErrorName(val, mod).unwrap()) \|err_name\|	1459	return if (getErrorName(val, zcu).unwrap()) \|err_name\|
1460	@intCast(mod.global_error_set.getIndex(err_name).?)	1460	zcu.intern_pool.getErrorValueIfExists(err_name).?
1461	else	1461	else
1462	0;	1462	0;
1463	}	1463	}