Commit 0f8561d099e4d08be0a6e547dd88f21026504490 | zig

author	Andrew Kelley <andrew@ziglang.org> 2024-07-04 23:13:22-04:00
committer	GitHub <noreply@github.com> 2024-07-04 23:13:22-04:00
log	0f8561d099e4d08be0a6e547dd88f21026504490
tree	69bdcb7800608daed4a8908406623f3bab38f0e4
parent	790b8428a26457e7ed9ea20485b9d3085011b989
parent	74346b0f79ca4bf67d61008030c7cc3565bff3f9
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #20487 from ziglang/incremental-serialization

Zcu: extract serializable state from File

22 files changed, 843 insertions(+), 705 deletions(-)

lib
- std
  - Build
    Cache.zig
  - debug.zig
src
- Compilation.zig
- InternPool.zig
- Package
  - Module.zig
- Sema.zig
- Type.zig
- Zcu.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
  - C.zig
  - Dwarf.zig
  - Wasm
    ZigObject.zig
- main.zig

lib/std/Build/Cache.zig+14-28

...	@@ -250,14 +250,7 @@ pub const HashHelper = struct {	...	@@ -250,14 +250,7 @@ pub const HashHelper = struct {
250	pub fn final(hh: *HashHelper) HexDigest {	250	pub fn final(hh: *HashHelper) HexDigest {
251	var bin_digest: BinDigest = undefined;	251	var bin_digest: BinDigest = undefined;
252	hh.hasher.final(&bin_digest);	252	hh.hasher.final(&bin_digest);
253		253	return binToHex(bin_digest);
254	var out_digest: HexDigest = undefined;
255	_ = fmt.bufPrint(
256	&out_digest,
257	"{s}",
258	.{fmt.fmtSliceHexLower(&bin_digest)},
259	) catch unreachable;
260	return out_digest;
261	}	254	}
262		255
263	pub fn oneShot(bytes: []const u8) [hex_digest_len]u8 {	256	pub fn oneShot(bytes: []const u8) [hex_digest_len]u8 {
...	@@ -265,16 +258,20 @@ pub const HashHelper = struct {	...	@@ -265,16 +258,20 @@ pub const HashHelper = struct {
265	hasher.update(bytes);	258	hasher.update(bytes);
266	var bin_digest: BinDigest = undefined;	259	var bin_digest: BinDigest = undefined;
267	hasher.final(&bin_digest);	260	hasher.final(&bin_digest);
268	var out_digest: [hex_digest_len]u8 = undefined;	261	return binToHex(bin_digest);
269	_ = fmt.bufPrint(
270	&out_digest,
271	"{s}",
272	.{fmt.fmtSliceHexLower(&bin_digest)},
273	) catch unreachable;
274	return out_digest;
275	}	262	}
276	};	263	};
277		264
		265	pub fn binToHex(bin_digest: BinDigest) HexDigest {
		266	var out_digest: HexDigest = undefined;
		267	_ = fmt.bufPrint(
		268	&out_digest,
		269	"{s}",
		270	.{fmt.fmtSliceHexLower(&bin_digest)},
		271	) catch unreachable;
		272	return out_digest;
		273	}
		274
278	pub const Lock = struct {	275	pub const Lock = struct {
279	manifest_file: fs.File,	276	manifest_file: fs.File,
280		277
...	@@ -426,11 +423,7 @@ pub const Manifest = struct {	...	@@ -426,11 +423,7 @@ pub const Manifest = struct {
426	var bin_digest: BinDigest = undefined;	423	var bin_digest: BinDigest = undefined;
427	self.hash.hasher.final(&bin_digest);	424	self.hash.hasher.final(&bin_digest);
428		425
429	_ = fmt.bufPrint(	426	self.hex_digest = binToHex(bin_digest);
430	&self.hex_digest,
431	"{s}",
432	.{fmt.fmtSliceHexLower(&bin_digest)},
433	) catch unreachable;
434		427
435	self.hash.hasher = hasher_init;	428	self.hash.hasher = hasher_init;
436	self.hash.hasher.update(&bin_digest);	429	self.hash.hasher.update(&bin_digest);
...	@@ -899,14 +892,7 @@ pub const Manifest = struct {	...	@@ -899,14 +892,7 @@ pub const Manifest = struct {
899	var bin_digest: BinDigest = undefined;	892	var bin_digest: BinDigest = undefined;
900	self.hash.hasher.final(&bin_digest);	893	self.hash.hasher.final(&bin_digest);
901		894
902	var out_digest: HexDigest = undefined;	895	return binToHex(bin_digest);
903	_ = fmt.bufPrint(
904	&out_digest,
905	"{s}",
906	.{fmt.fmtSliceHexLower(&bin_digest)},
907	) catch unreachable;
908
909	return out_digest;
910	}	896	}
911		897
912	/// If `want_shared_lock` is true, this function automatically downgrades the	898	/// If `want_shared_lock` is true, this function automatically downgrades the

lib/std/debug.zig+17-7

 @@ -398,20 +398,30 @@ pub fn dumpStackTrace(stack_trace: std.builtin.StackTrace) void {
     }
 }
-/// This function invokes undefined behavior when `ok` is `false`.
+/// Invokes detectable illegal behavior when `ok` is `false`.
+///
 /// In Debug and ReleaseSafe modes, calls to this function are always
 /// generated, and the `unreachable` statement triggers a panic.
-/// In ReleaseFast and ReleaseSmall modes, calls to this function are
+///
-/// optimized away, and in fact the optimizer is able to use the assertion
+/// In ReleaseFast and ReleaseSmall modes, calls to this function are optimized
-/// in its heuristics.
+/// away, and in fact the optimizer is able to use the assertion in its
-/// Inside a test block, it is best to use the `std.testing` module rather
+/// heuristics.
-/// than this function, because this function may not detect a test failure
+///
-/// in ReleaseFast and ReleaseSmall mode. Outside of a test block, this assert
+/// Inside a test block, it is best to use the `std.testing` module rather than
+/// this function, because this function may not detect a test failure in
+/// ReleaseFast and ReleaseSmall mode. Outside of a test block, this assert
 /// function is the correct function to use.
 pub fn assert(ok: bool) void {
     if (!ok) unreachable; // assertion failure
 }
+/// Invokes detectable illegal behavior when the provided slice is not mapped
+/// or lacks read permissions.
+pub fn assertReadable(slice: []const volatile u8) void {
+    if (!runtime_safety) return;
+    for (slice) |*byte| _ = byte.*;
+}
 pub fn panic(comptime format: []const u8, args: anytype) noreturn {
     @setCold(true);

src/Compilation.zig+136-101

 @@ -116,7 +116,7 @@ win32_resource_work_queue: if (build_options.only_core_functionality) void else
 /// These jobs are to tokenize, parse, and astgen files, which may be outdated
 /// since the last compilation, as well as scan for `@import` and queue up
 /// additional jobs corresponding to those new files.
-astgen_work_queue: std.fifo.LinearFifo(*Module.File, .Dynamic),
+astgen_work_queue: std.fifo.LinearFifo(Zcu.File.Index, .Dynamic),
 /// These jobs are to inspect the file system stat() and if the embedded file has changed
 /// on disk, mark the corresponding Decl outdated and queue up an `analyze_decl`
 /// task for it.
 @@ -1433,7 +1433,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
             .work_queue = std.fifo.LinearFifo(Job, .Dynamic).init(gpa),
             .c_object_work_queue = std.fifo.LinearFifo(*CObject, .Dynamic).init(gpa),
             .win32_resource_work_queue = if (build_options.only_core_functionality) {} else std.fifo.LinearFifo(*Win32Resource, .Dynamic).init(gpa),
-            .astgen_work_queue = std.fifo.LinearFifo(*Module.File, .Dynamic).init(gpa),
+            .astgen_work_queue = std.fifo.LinearFifo(Zcu.File.Index, .Dynamic).init(gpa),
             .embed_file_work_queue = std.fifo.LinearFifo(*Module.EmbedFile, .Dynamic).init(gpa),
             .c_source_files = options.c_source_files,
             .rc_source_files = options.rc_source_files,
 @@ -2095,13 +2095,13 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
         }
     }
-    if (comp.module) |module| {
+    if (comp.module) |zcu| {
-        module.compile_log_text.shrinkAndFree(gpa, 0);
+        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 = module.std_mod;
+        const std_mod = zcu.std_mod;
-        _ = try module.importPkg(std_mod);
+        _ = try zcu.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,
 @@ -2110,64 +2110,65 @@ 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 module.importPkg(module.main_mod);
+            _ = try zcu.importPkg(zcu.main_mod);
         }
-        if (module.root_mod.deps.get("compiler_rt")) |compiler_rt_mod| {
+        if (zcu.root_mod.deps.get("compiler_rt")) |compiler_rt_mod| {
-            _ = try module.importPkg(compiler_rt_mod);
+            _ = try zcu.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(module.import_table.count());
+        try comp.astgen_work_queue.ensureUnusedCapacity(zcu.import_table.count());
-        for (module.import_table.values()) |file| {
+        for (zcu.import_table.values(), 0..) |file, file_index_usize| {
+            const file_index: Zcu.File.Index = @enumFromInt(file_index_usize);
             if (file.mod.isBuiltin()) continue;
-            comp.astgen_work_queue.writeItemAssumeCapacity(file);
+            comp.astgen_work_queue.writeItemAssumeCapacity(file_index);
         }
         // Put a work item in for checking if any files used with `@embedFile` changed.
-        try comp.embed_file_work_queue.ensureUnusedCapacity(module.embed_table.count());
+        try comp.embed_file_work_queue.ensureUnusedCapacity(zcu.embed_table.count());
-        for (module.embed_table.values()) |embed_file| {
+        for (zcu.embed_table.values()) |embed_file| {
             comp.embed_file_work_queue.writeItemAssumeCapacity(embed_file);
         }
         try comp.work_queue.writeItem(.{ .analyze_mod = std_mod });
         if (comp.config.is_test) {
-            try comp.work_queue.writeItem(.{ .analyze_mod = module.main_mod });
+            try comp.work_queue.writeItem(.{ .analyze_mod = zcu.main_mod });
         }
-        if (module.root_mod.deps.get("compiler_rt")) |compiler_rt_mod| {
+        if (zcu.root_mod.deps.get("compiler_rt")) |compiler_rt_mod| {
             try comp.work_queue.writeItem(.{ .analyze_mod = compiler_rt_mod });
         }
     }
     try comp.performAllTheWork(main_progress_node);
-    if (comp.module) |module| {
+    if (comp.module) |zcu| {
         if (build_options.enable_debug_extensions and comp.verbose_intern_pool) {
             std.debug.print("intern pool stats for '{s}':\n", .{
                 comp.root_name,
             });
-            module.intern_pool.dump();
+            zcu.intern_pool.dump();
         }
         if (build_options.enable_debug_extensions and comp.verbose_generic_instances) {
             std.debug.print("generic instances for '{s}:0x{x}':\n", .{
                 comp.root_name,
-                @as(usize, @intFromPtr(module)),
+                @as(usize, @intFromPtr(zcu)),
             });
-            module.intern_pool.dumpGenericInstances(gpa);
+            zcu.intern_pool.dumpGenericInstances(gpa);
         }
         if (comp.config.is_test and comp.totalErrorCount() == 0) {
             // The `test_functions` decl has been intentionally postponed until now,
             // at which point we must populate it with the list of test functions that
             // have been discovered and not filtered out.
-            try module.populateTestFunctions(main_progress_node);
+            try zcu.populateTestFunctions(main_progress_node);
         }
-        try module.processExports();
+        try zcu.processExports();
     }
     if (comp.totalErrorCount() != 0) {
 @@ -2615,7 +2616,9 @@ fn resolveEmitLoc(
     return slice.ptr;
 }
-fn reportMultiModuleErrors(mod: *Module) !void {
+fn reportMultiModuleErrors(zcu: *Zcu) !void {
+    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
     // print all of, so we'll cap the number of these to emit.
     var num_errors: u32 = 0;
 @@ -2623,37 +2626,39 @@ fn reportMultiModuleErrors(mod: *Module) !void {
     // Attach the "some omitted" note to the final error message
     var last_err: ?*Module.ErrorMsg = null;
-    for (mod.import_table.values()) |file| {
+    for (zcu.import_table.values(), 0..) |file, file_index_usize| {
         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;
             const omitted = file.references.items.len -| max_notes;
             const num_notes = file.references.items.len - omitted;
-            const notes = try mod.gpa.alloc(Module.ErrorMsg, if (omitted > 0) num_notes + 1 else num_notes);
+            const notes = try gpa.alloc(Module.ErrorMsg, if (omitted > 0) num_notes + 1 else num_notes);
-            errdefer mod.gpa.free(notes);
+            errdefer gpa.free(notes);
             for (notes[0..num_notes], file.references.items[0..num_notes], 0..) |*note, ref, i| {
-                errdefer for (notes[0..i]) |*n| n.deinit(mod.gpa);
+                errdefer for (notes[0..i]) |*n| n.deinit(gpa);
                 note.* = switch (ref) {
                     .import => |import| try Module.ErrorMsg.init(
-                        mod.gpa,
+                        gpa,
                         .{
-                            .base_node_inst = try mod.intern_pool.trackZir(mod.gpa, import.file, .main_struct_inst),
+                            .base_node_inst = try ip.trackZir(gpa, import.file, .main_struct_inst),
                             .offset = .{ .token_abs = import.token },
                         },
                         "imported from module {s}",
-                        .{import.file.mod.fully_qualified_name},
+                        .{zcu.fileByIndex(import.file).mod.fully_qualified_name},
                     ),
                     .root => |pkg| try Module.ErrorMsg.init(
-                        mod.gpa,
+                        gpa,
                         .{
-                            .base_node_inst = try mod.intern_pool.trackZir(mod.gpa, file, .main_struct_inst),
+                            .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
                             .offset = .entire_file,
                         },
                         "root of module {s}",
 @@ -2661,25 +2666,25 @@ fn reportMultiModuleErrors(mod: *Module) !void {
                     ),
                 };
             }
-            errdefer for (notes[0..num_notes]) |*n| n.deinit(mod.gpa);
+            errdefer for (notes[0..num_notes]) |*n| n.deinit(gpa);
             if (omitted > 0) {
                 notes[num_notes] = try Module.ErrorMsg.init(
-                    mod.gpa,
+                    gpa,
                     .{
-                        .base_node_inst = try mod.intern_pool.trackZir(mod.gpa, file, .main_struct_inst),
+                        .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
                         .offset = .entire_file,
                     },
                     "{} more references omitted",
                     .{omitted},
                 );
             }
-            errdefer if (omitted > 0) notes[num_notes].deinit(mod.gpa);
+            errdefer if (omitted > 0) notes[num_notes].deinit(gpa);
             const err = try Module.ErrorMsg.create(
-                mod.gpa,
+                gpa,
                 .{
-                    .base_node_inst = try mod.intern_pool.trackZir(mod.gpa, file, .main_struct_inst),
+                    .base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
                     .offset = .entire_file,
                 },
                 "file exists in multiple modules",
 @@ -2688,8 +2693,8 @@ fn reportMultiModuleErrors(mod: *Module) !void {
             err.notes = notes;
             break :err_blk err;
         };
-        errdefer err.destroy(mod.gpa);
+        errdefer err.destroy(gpa);
-        try mod.failed_files.putNoClobber(mod.gpa, file, err);
+        try zcu.failed_files.putNoClobber(gpa, file, err);
         last_err = err;
     }
 @@ -2700,15 +2705,15 @@ fn reportMultiModuleErrors(mod: *Module) !void {
         // There isn't really any meaningful place to put this note, so just attach it to the
         // last failed file
         var note = try Module.ErrorMsg.init(
-            mod.gpa,
+            gpa,
             err.src_loc,
             "{} more errors omitted",
             .{num_errors - max_errors},
         );
-        errdefer note.deinit(mod.gpa);
+        errdefer note.deinit(gpa);
         const i = err.notes.len;
-        err.notes = try mod.gpa.realloc(err.notes, i + 1);
+        err.notes = try gpa.realloc(err.notes, i + 1);
         err.notes[i] = note;
     }
 @@ -2719,8 +2724,8 @@ fn reportMultiModuleErrors(mod: *Module) !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 (mod.import_table.values()) |file| {
+    for (zcu.import_table.values()) |file| {
-        if (file.multi_pkg) file.recursiveMarkMultiPkg(mod);
+        if (file.multi_pkg) file.recursiveMarkMultiPkg(zcu);
     }
 }
 @@ -2752,6 +2757,7 @@ const Header = extern struct {
         first_dependency_len: u32,
         dep_entries_len: u32,
         free_dep_entries_len: u32,
+        files_len: u32,
     },
 };
 @@ -2759,7 +2765,7 @@ const Header = extern struct {
 /// saved, such as the target and most CLI flags. A cache hit will only occur
 /// when subsequent compiler invocations use the same set of flags.
 pub fn saveState(comp: *Compilation) !void {
-    var bufs_list: [19]std.posix.iovec_const = undefined;
+    var bufs_list: [21]std.posix.iovec_const = undefined;
     var bufs_len: usize = 0;
     const lf = comp.bin_file orelse return;
 @@ -2780,6 +2786,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),
             },
         };
         addBuf(&bufs_list, &bufs_len, mem.asBytes(&header));
 @@ -2804,8 +2811,10 @@ 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.values()));
         // TODO: compilation errors
-        // TODO: files
         // TODO: namespaces
         // TODO: decls
         // TODO: linker state
 @@ -2827,6 +2836,9 @@ pub fn saveState(comp: *Compilation) !void {
 }
 fn addBuf(bufs_list: []std.posix.iovec_const, bufs_len: *usize, buf: []const u8) void {
+    // Even when len=0, the undefined pointer might cause EFAULT.
+    if (buf.len == 0) return;
     const i = bufs_len.*;
     bufs_len.* = i + 1;
     bufs_list[i] = .{
 @@ -3350,16 +3362,31 @@ pub fn performAllTheWork(
             }
         }
-        while (comp.astgen_work_queue.readItem()) |file| {
+        if (comp.module) |zcu| {
-            comp.thread_pool.spawnWg(&comp.astgen_wait_group, workerAstGenFile, .{
+            {
-                comp, file, zir_prog_node, &comp.astgen_wait_group, .root,
+                // Worker threads may append to zcu.files and zcu.import_table
-            });
+                // so we must hold the lock while spawning those tasks, since
-        }
+                // we access those tables in this loop.
+                comp.mutex.lock();
+                defer comp.mutex.unlock();
-        while (comp.embed_file_work_queue.readItem()) |embed_file| {
+                while (comp.astgen_work_queue.readItem()) |file_index| {
-            comp.thread_pool.spawnWg(&comp.astgen_wait_group, workerCheckEmbedFile, .{
+                    // Pre-load these things from our single-threaded context since they
-                comp, embed_file,
+                    // will be needed by the worker threads.
-            });
+                    const path_digest = zcu.filePathDigest(file_index);
+                    const root_decl = zcu.fileRootDecl(file_index);
+                    const file = zcu.fileByIndex(file_index);
+                    comp.thread_pool.spawnWg(&comp.astgen_wait_group, workerAstGenFile, .{
+                        comp, file, file_index, path_digest, root_decl, zir_prog_node, &comp.astgen_wait_group, .root,
+                    });
+                }
+            }
+            while (comp.embed_file_work_queue.readItem()) |embed_file| {
+                comp.thread_pool.spawnWg(&comp.astgen_wait_group, workerCheckEmbedFile, .{
+                    comp, embed_file,
+                });
+            }
         }
         while (comp.c_object_work_queue.readItem()) |c_object| {
 @@ -3423,8 +3450,8 @@ pub fn performAllTheWork(
 fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !void {
     switch (job) {
         .codegen_decl => |decl_index| {
-            const module = comp.module.?;
+            const zcu = comp.module.?;
-            const decl = module.declPtr(decl_index);
+            const decl = zcu.declPtr(decl_index);
             switch (decl.analysis) {
                 .unreferenced => unreachable,
 @@ -3442,7 +3469,7 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
                     assert(decl.has_tv);
-                    try module.linkerUpdateDecl(decl_index);
+                    try zcu.linkerUpdateDecl(decl_index);
                     return;
                 },
             }
 @@ -3451,16 +3478,16 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
             const named_frame = tracy.namedFrame("codegen_func");
             defer named_frame.end();
-            const module = comp.module.?;
+            const zcu = comp.module.?;
             // This call takes ownership of `func.air`.
-            try module.linkerUpdateFunc(func.func, func.air);
+            try zcu.linkerUpdateFunc(func.func, func.air);
         },
         .analyze_func => |func| {
             const named_frame = tracy.namedFrame("analyze_func");
             defer named_frame.end();
-            const module = comp.module.?;
+            const zcu = comp.module.?;
-            module.ensureFuncBodyAnalyzed(func) catch |err| switch (err) {
+            zcu.ensureFuncBodyAnalyzed(func) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => return,
             };
 @@ -3469,8 +3496,8 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
             if (true) @panic("regressed compiler feature: emit-h should hook into updateExports, " ++
                 "not decl analysis, which is too early to know about @export calls");
-            const module = comp.module.?;
+            const zcu = comp.module.?;
-            const decl = module.declPtr(decl_index);
+            const decl = zcu.declPtr(decl_index);
             switch (decl.analysis) {
                 .unreferenced => unreachable,
 @@ -3488,7 +3515,7 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
                     defer named_frame.end();
                     const gpa = comp.gpa;
-                    const emit_h = module.emit_h.?;
+                    const emit_h = zcu.emit_h.?;
                     _ = try emit_h.decl_table.getOrPut(gpa, decl_index);
                     const decl_emit_h = emit_h.declPtr(decl_index);
                     const fwd_decl = &decl_emit_h.fwd_decl;
 @@ -3496,10 +3523,12 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
                     var ctypes_arena = std.heap.ArenaAllocator.init(gpa);
                     defer ctypes_arena.deinit();
+                    const file_scope = zcu.namespacePtr(decl.src_namespace).fileScope(zcu);
                     var dg: c_codegen.DeclGen = .{
                         .gpa = gpa,
-                        .zcu = module,
+                        .zcu = zcu,
-                        .mod = module.namespacePtr(decl.src_namespace).file_scope.mod,
+                        .mod = file_scope.mod,
                         .error_msg = null,
                         .pass = .{ .decl = decl_index },
                         .is_naked_fn = false,
 @@ -3528,17 +3557,17 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
             }
         },
         .analyze_decl => |decl_index| {
-            const module = comp.module.?;
+            const zcu = comp.module.?;
-            module.ensureDeclAnalyzed(decl_index) catch |err| switch (err) {
+            zcu.ensureDeclAnalyzed(decl_index) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => return,
             };
-            const decl = module.declPtr(decl_index);
+            const decl = zcu.declPtr(decl_index);
             if (decl.kind == .@"test" and comp.config.is_test) {
                 // Tests are always emitted in test binaries. The decl_refs are created by
-                // Module.populateTestFunctions, but this will not queue body analysis, so do
+                // Zcu.populateTestFunctions, but this will not queue body analysis, so do
                 // that now.
-                try module.ensureFuncBodyAnalysisQueued(decl.val.toIntern());
+                try zcu.ensureFuncBodyAnalysisQueued(decl.val.toIntern());
             }
         },
         .resolve_type_fully => |ty| {
 @@ -3556,30 +3585,30 @@ fn processOneJob(comp: *Compilation, job: Job, prog_node: std.Progress.Node) !vo
             defer named_frame.end();
             const gpa = comp.gpa;
-            const module = comp.module.?;
+            const zcu = comp.module.?;
-            const decl = module.declPtr(decl_index);
+            const decl = zcu.declPtr(decl_index);
             const lf = comp.bin_file.?;
-            lf.updateDeclLineNumber(module, decl_index) catch |err| {
+            lf.updateDeclLineNumber(zcu, decl_index) catch |err| {
-                try module.failed_analysis.ensureUnusedCapacity(gpa, 1);
+                try zcu.failed_analysis.ensureUnusedCapacity(gpa, 1);
-                module.failed_analysis.putAssumeCapacityNoClobber(
+                zcu.failed_analysis.putAssumeCapacityNoClobber(
                     InternPool.AnalUnit.wrap(.{ .decl = decl_index }),
-                    try Module.ErrorMsg.create(
+                    try Zcu.ErrorMsg.create(
                         gpa,
-                        decl.navSrcLoc(module),
+                        decl.navSrcLoc(zcu),
                         "unable to update line number: {s}",
                         .{@errorName(err)},
                     ),
                 );
                 decl.analysis = .codegen_failure;
-                try module.retryable_failures.append(gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));
+                try zcu.retryable_failures.append(gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }));
             };
         },
         .analyze_mod => |pkg| {
             const named_frame = tracy.namedFrame("analyze_mod");
             defer named_frame.end();
-            const module = comp.module.?;
+            const zcu = comp.module.?;
-            module.semaPkg(pkg) catch |err| switch (err) {
+            zcu.semaPkg(pkg) catch |err| switch (err) {
                 error.OutOfMemory => return error.OutOfMemory,
                 error.AnalysisFail => return,
             };
 @@ -4012,14 +4041,17 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) anye
 const AstGenSrc = union(enum) {
     root,
     import: struct {
-        importing_file: *Module.File,
+        importing_file: Zcu.File.Index,
         import_tok: std.zig.Ast.TokenIndex,
     },
 };
 fn workerAstGenFile(
     comp: *Compilation,
-    file: *Module.File,
+    file: *Zcu.File,
+    file_index: Zcu.File.Index,
+    path_digest: Cache.BinDigest,
+    root_decl: Zcu.Decl.OptionalIndex,
     prog_node: std.Progress.Node,
     wg: *WaitGroup,
     src: AstGenSrc,
 @@ -4027,12 +4059,12 @@ fn workerAstGenFile(
     const child_prog_node = prog_node.start(file.sub_file_path, 0);
     defer child_prog_node.end();
-    const mod = comp.module.?;
+    const zcu = comp.module.?;
-    mod.astGenFile(file) catch |err| switch (err) {
+    zcu.astGenFile(file, file_index, path_digest, root_decl) catch |err| switch (err) {
         error.AnalysisFail => return,
         else => {
             file.status = .retryable_failure;
-            comp.reportRetryableAstGenError(src, file, err) catch |oom| switch (oom) {
+            comp.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 => {},
 @@ -4059,29 +4091,31 @@ fn workerAstGenFile(
             // `@import("builtin")` is handled specially.
             if (mem.eql(u8, import_path, "builtin")) continue;
-            const import_result = blk: {
+            const import_result, const imported_path_digest, const imported_root_decl = blk: {
                 comp.mutex.lock();
                 defer comp.mutex.unlock();
-                const res = mod.importFile(file, import_path) catch continue;
+                const res = zcu.importFile(file, import_path) catch continue;
                 if (!res.is_pkg) {
-                    res.file.addReference(mod.*, .{ .import = .{
+                    res.file.addReference(zcu.*, .{ .import = .{
-                        .file = file,
+                        .file = file_index,
                         .token = item.data.token,
                     } }) catch continue;
                 }
-                break :blk res;
+                const imported_path_digest = zcu.filePathDigest(res.file_index);
+                const imported_root_decl = zcu.fileRootDecl(res.file_index);
+                break :blk .{ res, imported_path_digest, imported_root_decl };
             };
             if (import_result.is_new) {
                 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 = .{
-                    .importing_file = file,
+                    .importing_file = file_index,
                     .import_tok = item.data.token,
                 } };
                 comp.thread_pool.spawnWg(wg, workerAstGenFile, .{
-                    comp, import_result.file, prog_node, wg, sub_src,
+                    comp, import_result.file, import_result.file_index, imported_path_digest, imported_root_decl, prog_node, wg, sub_src,
                 });
             }
         }
 @@ -4432,21 +4466,22 @@ fn reportRetryableWin32ResourceError(
 fn reportRetryableAstGenError(
     comp: *Compilation,
     src: AstGenSrc,
-    file: *Module.File,
+    file_index: Zcu.File.Index,
     err: anyerror,
 ) error{OutOfMemory}!void {
-    const mod = comp.module.?;
+    const zcu = comp.module.?;
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
+    const file = zcu.fileByIndex(file_index);
     file.status = .retryable_failure;
     const src_loc: Module.LazySrcLoc = switch (src) {
         .root => .{
-            .base_node_inst = try mod.intern_pool.trackZir(gpa, file, .main_struct_inst),
+            .base_node_inst = try zcu.intern_pool.trackZir(gpa, file_index, .main_struct_inst),
             .offset = .entire_file,
         },
         .import => |info| .{
-            .base_node_inst = try mod.intern_pool.trackZir(gpa, info.importing_file, .main_struct_inst),
+            .base_node_inst = try zcu.intern_pool.trackZir(gpa, info.importing_file, .main_struct_inst),
             .offset = .{ .token_abs = info.import_tok },
         },
     };
 @@ -4459,7 +4494,7 @@ fn reportRetryableAstGenError(
     {
         comp.mutex.lock();
         defer comp.mutex.unlock();
-        try mod.failed_files.putNoClobber(gpa, file, err_msg);
+        try zcu.failed_files.putNoClobber(gpa, file, err_msg);
     }
 }

src/InternPool.zig+26-4

 @@ -92,12 +92,27 @@ 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) = .{},
+pub const FileIndex = enum(u32) {
+    _,
+};
 pub const TrackedInst = extern struct {
-    path_digest: Cache.BinDigest,
+    file: FileIndex,
     inst: Zir.Inst.Index,
     comptime {
         // The fields should be tightly packed. See also serialiation logic in `Compilation.saveState`.
-        assert(@sizeOf(@This()) == Cache.bin_digest_len + @sizeOf(Zir.Inst.Index));
+        assert(@sizeOf(@This()) == @sizeOf(FileIndex) + @sizeOf(Zir.Inst.Index));
     }
     pub const Index = enum(u32) {
         _,
 @@ -123,9 +138,14 @@ pub const TrackedInst = extern struct {
     };
 };
-pub fn trackZir(ip: *InternPool, gpa: Allocator, file: *Module.File, inst: Zir.Inst.Index) Allocator.Error!TrackedInst.Index {
+pub fn trackZir(
+    ip: *InternPool,
+    gpa: Allocator,
+    file: FileIndex,
+    inst: Zir.Inst.Index,
+) Allocator.Error!TrackedInst.Index {
     const key: TrackedInst = .{
-        .path_digest = file.path_digest,
+        .file = file,
         .inst = inst,
     };
     const gop = try ip.tracked_insts.getOrPut(gpa, key);
 @@ -4592,6 +4612,8 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void {
     ip.dep_entries.deinit(gpa);
     ip.free_dep_entries.deinit(gpa);
+    ip.files.deinit(gpa);
     ip.* = undefined;
 }

src/Package/Module.zig+2-6

...	@@ -379,7 +379,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {	...	@@ -379,7 +379,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
379		379
380	const new_file = try arena.create(File);	380	const new_file = try arena.create(File);
381		381
382	const bin_digest, const hex_digest = digest: {	382	const hex_digest = digest: {
383	var hasher: Cache.Hasher = Cache.hasher_init;	383	var hasher: Cache.Hasher = Cache.hasher_init;
384	hasher.update(generated_builtin_source);	384	hasher.update(generated_builtin_source);
385		385
...	@@ -393,7 +393,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {	...	@@ -393,7 +393,7 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
393	.{std.fmt.fmtSliceHexLower(&bin_digest)},	393	.{std.fmt.fmtSliceHexLower(&bin_digest)},
394	) catch unreachable;	394	) catch unreachable;
395		395
396	break :digest .{ bin_digest, hex_digest };	396	break :digest hex_digest;
397	};	397	};
398		398
399	const builtin_sub_path = try arena.dupe(u8, "b" ++ std.fs.path.sep_str ++ hex_digest);	399	const builtin_sub_path = try arena.dupe(u8, "b" ++ std.fs.path.sep_str ++ hex_digest);
...	@@ -443,10 +443,6 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {	...	@@ -443,10 +443,6 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Package.Module {
443	.zir = undefined,	443	.zir = undefined,
444	.status = .never_loaded,	444	.status = .never_loaded,
445	.mod = new,	445	.mod = new,
446	.root_decl = .none,
447	// We might as well use this digest for the File `path digest`, since there's a
448	// one-to-one correspondence here between distinct paths and distinct contents.
449	.path_digest = bin_digest,
450	};	446	};
451	break :b new;	447	break :b new;
452	};	448	};

src/Sema.zig+123-106

 @@ -546,8 +546,12 @@ pub const Block = struct {
         };
     }
-    pub fn getFileScope(block: *Block, mod: *Module) *Module.File {
+    pub fn getFileScope(block: *Block, zcu: *Zcu) *Zcu.File {
-        return mod.namespacePtr(block.namespace).file_scope;
+        return zcu.fileByIndex(getFileScopeIndex(block, zcu));
+    }
+    pub fn getFileScopeIndex(block: *Block, zcu: *Zcu) Zcu.File.Index {
+        return zcu.namespacePtr(block.namespace).file_scope;
     }
     fn addTy(
 @@ -826,7 +830,16 @@ pub const Block = struct {
     pub fn ownerModule(block: Block) *Package.Module {
         const zcu = block.sema.mod;
-        return zcu.namespacePtr(block.namespace).file_scope.mod;
+        return zcu.namespacePtr(block.namespace).fileScope(zcu).mod;
+    }
+    fn trackZir(block: *Block, inst: Zir.Inst.Index) Allocator.Error!InternPool.TrackedInst.Index {
+        const sema = block.sema;
+        const gpa = sema.gpa;
+        const zcu = sema.mod;
+        const ip = &zcu.intern_pool;
+        const file_index = block.getFileScopeIndex(zcu);
+        return ip.trackZir(gpa, file_index, inst);
     }
 };
 @@ -979,7 +992,7 @@ fn analyzeBodyInner(
     try sema.inst_map.ensureSpaceForInstructions(sema.gpa, body);
-    const mod = sema.mod;
+    const zcu = sema.mod;
     const map = &sema.inst_map;
     const tags = sema.code.instructions.items(.tag);
     const datas = sema.code.instructions.items(.data);
 @@ -999,9 +1012,9 @@ fn analyzeBodyInner(
         // The hashmap lookup in here is a little expensive, and LLVM fails to optimize it away.
         if (build_options.enable_logging) {
             std.log.scoped(.sema_zir).debug("sema ZIR {s} %{d}", .{ sub_file_path: {
-                const path_digest = block.src_base_inst.resolveFull(&mod.intern_pool).path_digest;
+                const file_index = block.src_base_inst.resolveFull(&zcu.intern_pool).file;
-                const index = mod.path_digest_map.getIndex(path_digest).?;
+                const file = zcu.fileByIndex(file_index);
-                break :sub_file_path mod.import_table.values()[index].sub_file_path;
+                break :sub_file_path file.sub_file_path;
             }, inst });
         }
 @@ -1762,9 +1775,9 @@ fn analyzeBodyInner(
                 const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len);
                 const err_union = try sema.resolveInst(extra.data.operand);
                 const err_union_ty = sema.typeOf(err_union);
-                if (err_union_ty.zigTypeTag(mod) != .ErrorUnion) {
+                if (err_union_ty.zigTypeTag(zcu) != .ErrorUnion) {
                     return sema.fail(block, operand_src, "expected error union type, found '{}'", .{
-                        err_union_ty.fmt(mod),
+                        err_union_ty.fmt(zcu),
                     });
                 }
                 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);
 @@ -2730,7 +2743,7 @@ fn zirStructDecl(
     const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
     const extra = sema.code.extraData(Zir.Inst.StructDecl, extended.operand);
-    const tracked_inst = try ip.trackZir(gpa, block.getFileScope(mod), inst);
+    const tracked_inst = try block.trackZir(inst);
     const src: LazySrcLoc = .{
         .base_node_inst = tracked_inst,
         .offset = LazySrcLoc.Offset.nodeOffset(0),
 @@ -2806,7 +2819,7 @@ fn zirStructDecl(
         try ip.addDependency(
             sema.gpa,
             AnalUnit.wrap(.{ .decl = new_decl_index }),
-            .{ .src_hash = try ip.trackZir(sema.gpa, block.getFileScope(mod), inst) },
+            .{ .src_hash = try block.trackZir(inst) },
         );
     }
 @@ -2814,7 +2827,7 @@ fn zirStructDecl(
     const new_namespace_index: InternPool.OptionalNamespaceIndex = if (true or decls_len > 0) (try mod.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .decl_index = new_decl_index,
-        .file_scope = block.getFileScope(mod),
+        .file_scope = block.getFileScopeIndex(mod),
     })).toOptional() else .none;
     errdefer if (new_namespace_index.unwrap()) |ns| mod.destroyNamespace(ns);
 @@ -2947,7 +2960,7 @@ fn zirEnumDecl(
     const extra = sema.code.extraData(Zir.Inst.EnumDecl, extended.operand);
     var extra_index: usize = extra.end;
-    const tracked_inst = try ip.trackZir(gpa, block.getFileScope(mod), inst);
+    const tracked_inst = try block.trackZir(inst);
     const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(0) };
     const tag_ty_src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = .{ .node_offset_container_tag = 0 } };
 @@ -3040,9 +3053,9 @@ fn zirEnumDecl(
     if (sema.mod.comp.debug_incremental) {
         try mod.intern_pool.addDependency(
-            sema.gpa,
+            gpa,
             AnalUnit.wrap(.{ .decl = new_decl_index }),
-            .{ .src_hash = try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst) },
+            .{ .src_hash = try block.trackZir(inst) },
         );
     }
 @@ -3050,7 +3063,7 @@ fn zirEnumDecl(
     const new_namespace_index: InternPool.OptionalNamespaceIndex = if (true or decls_len > 0) (try mod.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .decl_index = new_decl_index,
-        .file_scope = block.getFileScope(mod),
+        .file_scope = block.getFileScopeIndex(mod),
     })).toOptional() else .none;
     errdefer if (!done) if (new_namespace_index.unwrap()) |ns| mod.destroyNamespace(ns);
 @@ -3232,7 +3245,7 @@ fn zirUnionDecl(
     const extra = sema.code.extraData(Zir.Inst.UnionDecl, extended.operand);
     var extra_index: usize = extra.end;
-    const tracked_inst = try ip.trackZir(gpa, block.getFileScope(mod), inst);
+    const tracked_inst = try block.trackZir(inst);
     const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(0) };
     extra_index += @intFromBool(small.has_tag_type);
 @@ -3306,9 +3319,9 @@ fn zirUnionDecl(
     if (sema.mod.comp.debug_incremental) {
         try mod.intern_pool.addDependency(
-            sema.gpa,
+            gpa,
             AnalUnit.wrap(.{ .decl = new_decl_index }),
-            .{ .src_hash = try mod.intern_pool.trackZir(sema.gpa, block.getFileScope(mod), inst) },
+            .{ .src_hash = try block.trackZir(inst) },
         );
     }
 @@ -3316,7 +3329,7 @@ fn zirUnionDecl(
     const new_namespace_index: InternPool.OptionalNamespaceIndex = if (true or decls_len > 0) (try mod.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .decl_index = new_decl_index,
-        .file_scope = block.getFileScope(mod),
+        .file_scope = block.getFileScopeIndex(mod),
     })).toOptional() else .none;
     errdefer if (new_namespace_index.unwrap()) |ns| mod.destroyNamespace(ns);
 @@ -3348,7 +3361,7 @@ fn zirOpaqueDecl(
     const extra = sema.code.extraData(Zir.Inst.OpaqueDecl, extended.operand);
     var extra_index: usize = extra.end;
-    const tracked_inst = try ip.trackZir(gpa, block.getFileScope(mod), inst);
+    const tracked_inst = try block.trackZir(inst);
     const src: LazySrcLoc = .{ .base_node_inst = tracked_inst, .offset = LazySrcLoc.Offset.nodeOffset(0) };
     const captures_len = if (small.has_captures_len) blk: {
 @@ -3397,14 +3410,14 @@ fn zirOpaqueDecl(
         try ip.addDependency(
             gpa,
             AnalUnit.wrap(.{ .decl = new_decl_index }),
-            .{ .src_hash = try ip.trackZir(gpa, block.getFileScope(mod), inst) },
+            .{ .src_hash = try block.trackZir(inst) },
         );
     }
     const new_namespace_index: InternPool.OptionalNamespaceIndex = if (decls_len > 0) (try mod.createNamespace(.{
         .parent = block.namespace.toOptional(),
         .decl_index = new_decl_index,
-        .file_scope = block.getFileScope(mod),
+        .file_scope = block.getFileScopeIndex(mod),
     })).toOptional() else .none;
     errdefer if (new_namespace_index.unwrap()) |ns| mod.destroyNamespace(ns);
 @@ -5893,8 +5906,8 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
     const tracy = trace(@src());
     defer tracy.end();
-    const mod = sema.mod;
+    const zcu = sema.mod;
-    const comp = mod.comp;
+    const comp = zcu.comp;
     const gpa = sema.gpa;
     const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node;
     const src = parent_block.nodeOffset(pl_node.src_node);
 @@ -5940,7 +5953,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
             if (!comp.config.link_libc)
                 try sema.errNote(src, msg, "libc headers not available; compilation does not link against libc", .{});
-            const gop = try mod.cimport_errors.getOrPut(gpa, sema.ownerUnit());
+            const gop = try zcu.cimport_errors.getOrPut(gpa, sema.ownerUnit());
             if (!gop.found_existing) {
                 gop.value_ptr.* = c_import_res.errors;
                 c_import_res.errors = std.zig.ErrorBundle.empty;
 @@ -5984,14 +5997,16 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
         else => |e| return e,
     };
-    const result = mod.importPkg(c_import_mod) catch |err|
+    const result = zcu.importPkg(c_import_mod) catch |err|
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
-    mod.astGenFile(result.file) catch |err|
+    const path_digest = zcu.filePathDigest(result.file_index);
+    const root_decl = zcu.fileRootDecl(result.file_index);
+    zcu.astGenFile(result.file, result.file_index, path_digest, root_decl) catch |err|
         return sema.fail(&child_block, src, "C import failed: {s}", .{@errorName(err)});
-    try mod.ensureFileAnalyzed(result.file);
+    try zcu.ensureFileAnalyzed(result.file_index);
-    const file_root_decl_index = result.file.root_decl.unwrap().?;
+    const file_root_decl_index = zcu.fileRootDecl(result.file_index).unwrap().?;
     return sema.analyzeDeclVal(parent_block, src, file_root_decl_index);
 }
 @@ -6730,7 +6745,9 @@ fn lookupInNamespace(
                 // Skip decls which are not marked pub, which are in a different
                 // file than the `a.b`/`@hasDecl` syntax.
                 const decl = mod.declPtr(decl_index);
-                if (decl.is_pub or (src_file == decl.getFileScope(mod) and checked_namespaces.values()[check_i])) {
+                if (decl.is_pub or (src_file == decl.getFileScopeIndex(mod) and
+                    checked_namespaces.values()[check_i]))
+                {
                     try candidates.append(gpa, decl_index);
                 }
             }
 @@ -6741,7 +6758,7 @@ fn lookupInNamespace(
                 if (sub_usingnamespace_decl_index == sema.owner_decl_index) continue;
                 const sub_usingnamespace_decl = mod.declPtr(sub_usingnamespace_decl_index);
                 const sub_is_pub = entry.value_ptr.*;
-                if (!sub_is_pub and src_file != sub_usingnamespace_decl.getFileScope(mod)) {
+                if (!sub_is_pub and src_file != sub_usingnamespace_decl.getFileScopeIndex(mod)) {
                     // Skip usingnamespace decls which are not marked pub, which are in
                     // a different file than the `a.b`/`@hasDecl` syntax.
                     continue;
 @@ -6749,7 +6766,7 @@ fn lookupInNamespace(
                 try sema.ensureDeclAnalyzed(sub_usingnamespace_decl_index);
                 const ns_ty = sub_usingnamespace_decl.val.toType();
                 const sub_ns = mod.namespacePtrUnwrap(ns_ty.getNamespaceIndex(mod)) orelse continue;
-                try checked_namespaces.put(gpa, sub_ns, src_file == sub_usingnamespace_decl.getFileScope(mod));
+                try checked_namespaces.put(gpa, sub_ns, src_file == sub_usingnamespace_decl.getFileScopeIndex(mod));
             }
         }
 @@ -8067,20 +8084,20 @@ fn instantiateGenericCall(
     call_tag: Air.Inst.Tag,
     call_dbg_node: ?Zir.Inst.Index,
 ) CompileError!Air.Inst.Ref {
-    const mod = sema.mod;
+    const zcu = sema.mod;
     const gpa = sema.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const func_val = try sema.resolveConstDefinedValue(block, func_src, func, .{
         .needed_comptime_reason = "generic function being called must be comptime-known",
     });
-    const generic_owner = switch (mod.intern_pool.indexToKey(func_val.toIntern())) {
+    const generic_owner = switch (zcu.intern_pool.indexToKey(func_val.toIntern())) {
         .func => func_val.toIntern(),
-        .ptr => |ptr| mod.declPtr(ptr.base_addr.decl).val.toIntern(),
+        .ptr => |ptr| zcu.declPtr(ptr.base_addr.decl).val.toIntern(),
         else => unreachable,
     };
-    const generic_owner_func = mod.intern_pool.indexToKey(generic_owner).func;
+    const generic_owner_func = zcu.intern_pool.indexToKey(generic_owner).func;
-    const generic_owner_ty_info = mod.typeToFunc(Type.fromInterned(generic_owner_func.ty)).?;
+    const generic_owner_ty_info = zcu.typeToFunc(Type.fromInterned(generic_owner_func.ty)).?;
     try sema.declareDependency(.{ .src_hash = generic_owner_func.zir_body_inst });
 @@ -8092,10 +8109,10 @@ fn instantiateGenericCall(
     // The actual monomorphization happens via adding `func_instance` to
     // `InternPool`.
-    const fn_owner_decl = mod.declPtr(generic_owner_func.owner_decl);
+    const fn_owner_decl = zcu.declPtr(generic_owner_func.owner_decl);
     const namespace_index = fn_owner_decl.src_namespace;
-    const namespace = mod.namespacePtr(namespace_index);
+    const namespace = zcu.namespacePtr(namespace_index);
-    const fn_zir = namespace.file_scope.zir;
+    const fn_zir = namespace.fileScope(zcu).zir;
     const fn_info = fn_zir.getFnInfo(generic_owner_func.zir_body_inst.resolve(ip));
     const comptime_args = try sema.arena.alloc(InternPool.Index, args_info.count());
 @@ -8110,7 +8127,7 @@ fn instantiateGenericCall(
     // `param_anytype_comptime` ZIR instructions to be ignored, resulting in a
     // new, monomorphized function, with the comptime parameters elided.
     var child_sema: Sema = .{
-        .mod = mod,
+        .mod = zcu,
         .gpa = gpa,
         .arena = sema.arena,
         .code = fn_zir,
 @@ -8199,7 +8216,7 @@ fn instantiateGenericCall(
         const arg_ref = try args_info.analyzeArg(sema, block, arg_index, param_ty, generic_owner_ty_info, func);
         try sema.validateRuntimeValue(block, args_info.argSrc(block, arg_index), arg_ref);
         const arg_ty = sema.typeOf(arg_ref);
-        if (arg_ty.zigTypeTag(mod) == .NoReturn) {
+        if (arg_ty.zigTypeTag(zcu) == .NoReturn) {
             // This terminates argument analysis.
             return arg_ref;
         }
 @@ -8283,12 +8300,12 @@ fn instantiateGenericCall(
     const new_func_inst = try child_sema.resolveInlineBody(&child_block, fn_info.param_body[args_info.count()..], fn_info.param_body_inst);
     const callee_index = (child_sema.resolveConstDefinedValue(&child_block, LazySrcLoc.unneeded, new_func_inst, undefined) catch unreachable).toIntern();
-    const callee = mod.funcInfo(callee_index);
+    const callee = zcu.funcInfo(callee_index);
     callee.branchQuota(ip).* = @max(callee.branchQuota(ip).*, sema.branch_quota);
     // Make a runtime call to the new function, making sure to omit the comptime args.
     const func_ty = Type.fromInterned(callee.ty);
-    const func_ty_info = mod.typeToFunc(func_ty).?;
+    const func_ty_info = zcu.typeToFunc(func_ty).?;
     // If the call evaluated to a return type that requires comptime, never mind
     // our generic instantiation. Instead we need to perform a comptime call.
 @@ -8304,13 +8321,13 @@ fn instantiateGenericCall(
     if (call_dbg_node) |some| try sema.zirDbgStmt(block, some);
     if (sema.owner_func_index != .none and
-        Type.fromInterned(func_ty_info.return_type).isError(mod))
+        Type.fromInterned(func_ty_info.return_type).isError(zcu))
     {
         ip.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn = true;
     }
     try sema.addReferenceEntry(call_src, AnalUnit.wrap(.{ .func = callee_index }));
-    try mod.ensureFuncBodyAnalysisQueued(callee_index);
+    try zcu.ensureFuncBodyAnalysisQueued(callee_index);
     try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.Call).Struct.fields.len + runtime_args.items.len);
     const result = try block.addInst(.{
 @@ -8333,7 +8350,7 @@ fn instantiateGenericCall(
     if (call_tag == .call_always_tail) {
         return sema.handleTailCall(block, call_src, func_ty, result);
     }
-    if (func_ty.fnReturnType(mod).isNoReturn(mod)) {
+    if (func_ty.fnReturnType(zcu).isNoReturn(zcu)) {
         _ = try block.addNoOp(.unreach);
         return .unreachable_value;
     }
 @@ -9653,7 +9670,7 @@ fn funcCommon(
             .is_generic = final_is_generic,
             .is_noinline = is_noinline,
-            .zir_body_inst = try ip.trackZir(gpa, block.getFileScope(mod), func_inst),
+            .zir_body_inst = try block.trackZir(func_inst),
             .lbrace_line = src_locs.lbrace_line,
             .rbrace_line = src_locs.rbrace_line,
             .lbrace_column = @as(u16, @truncate(src_locs.columns)),
 @@ -9731,7 +9748,7 @@ fn funcCommon(
             .ty = func_ty,
             .cc = cc,
             .is_noinline = is_noinline,
-            .zir_body_inst = try ip.trackZir(gpa, block.getFileScope(mod), func_inst),
+            .zir_body_inst = try block.trackZir(func_inst),
             .lbrace_line = src_locs.lbrace_line,
             .rbrace_line = src_locs.rbrace_line,
             .lbrace_column = @as(u16, @truncate(src_locs.columns)),
 @@ -13787,18 +13804,18 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     const tracy = trace(@src());
     defer tracy.end();
-    const mod = sema.mod;
+    const zcu = sema.mod;
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok;
     const operand_src = block.tokenOffset(inst_data.src_tok);
     const operand = inst_data.get(sema.code);
-    const result = mod.importFile(block.getFileScope(mod), operand) catch |err| switch (err) {
+    const result = zcu.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});
         },
         error.ModuleNotFound => {
             return sema.fail(block, operand_src, "no module named '{s}' available within module {s}", .{
-                operand, block.getFileScope(mod).mod.fully_qualified_name,
+                operand, block.getFileScope(zcu).mod.fully_qualified_name,
             });
         },
         else => {
 @@ -13807,8 +13824,8 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
             return sema.fail(block, operand_src, "unable to open '{s}': {s}", .{ operand, @errorName(err) });
         },
     };
-    try mod.ensureFileAnalyzed(result.file);
+    try zcu.ensureFileAnalyzed(result.file_index);
-    const file_root_decl_index = result.file.root_decl.unwrap().?;
+    const file_root_decl_index = zcu.fileRootDecl(result.file_index).unwrap().?;
     return sema.analyzeDeclVal(block, operand_src, file_root_decl_index);
 }
 @@ -21089,7 +21106,7 @@ fn zirReify(
     const ip = &mod.intern_pool;
     const name_strategy: Zir.Inst.NameStrategy = @enumFromInt(extended.small);
     const extra = sema.code.extraData(Zir.Inst.Reify, extended.operand).data;
-    const tracked_inst = try ip.trackZir(gpa, block.getFileScope(mod), inst);
+    const tracked_inst = try block.trackZir(inst);
     const src: LazySrcLoc = .{
         .base_node_inst = tracked_inst,
         .offset = LazySrcLoc.Offset.nodeOffset(0),
 @@ -21466,7 +21483,7 @@ fn zirReify(
             const wip_ty = switch (try ip.getOpaqueType(gpa, .{
                 .has_namespace = false,
                 .key = .{ .reified = .{
-                    .zir_index = try ip.trackZir(gpa, block.getFileScope(mod), inst),
+                    .zir_index = try block.trackZir(inst),
                 } },
             })) {
                 .existing => |ty| return Air.internedToRef(ty),
 @@ -21660,7 +21677,7 @@ fn reifyEnum(
         .tag_mode = if (is_exhaustive) .explicit else .nonexhaustive,
         .fields_len = fields_len,
         .key = .{ .reified = .{
-            .zir_index = try ip.trackZir(gpa, block.getFileScope(mod), inst),
+            .zir_index = try block.trackZir(inst),
             .type_hash = hasher.final(),
         } },
     })) {
 @@ -21810,7 +21827,7 @@ fn reifyUnion(
         .field_types = &.{}, // set later
         .field_aligns = &.{}, // set later
         .key = .{ .reified = .{
-            .zir_index = try ip.trackZir(gpa, block.getFileScope(mod), inst),
+            .zir_index = try block.trackZir(inst),
             .type_hash = hasher.final(),
         } },
     })) {
 @@ -22062,7 +22079,7 @@ fn reifyStruct(
         .inits_resolved = true,
         .has_namespace = false,
         .key = .{ .reified = .{
-            .zir_index = try ip.trackZir(gpa, block.getFileScope(mod), inst),
+            .zir_index = try block.trackZir(inst),
             .type_hash = hasher.final(),
         } },
     })) {
 @@ -34894,14 +34911,14 @@ pub fn resolveStructLayout(sema: *Sema, ty: Type) SemaError!void {
     _ = try sema.typeRequiresComptime(ty);
 }
-fn semaBackingIntType(mod: *Module, struct_type: InternPool.LoadedStructType) CompileError!void {
+fn semaBackingIntType(zcu: *Zcu, struct_type: InternPool.LoadedStructType) CompileError!void {
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const decl_index = struct_type.decl.unwrap().?;
-    const decl = mod.declPtr(decl_index);
+    const decl = zcu.declPtr(decl_index);
-    const zir = mod.namespacePtr(struct_type.namespace.unwrap().?).file_scope.zir;
+    const zir = zcu.namespacePtr(struct_type.namespace.unwrap().?).fileScope(zcu).zir;
     var analysis_arena = std.heap.ArenaAllocator.init(gpa);
     defer analysis_arena.deinit();
 @@ -34910,7 +34927,7 @@ fn semaBackingIntType(mod: *Module, struct_type: InternPool.LoadedStructType) Co
     defer comptime_err_ret_trace.deinit();
     var sema: Sema = .{
-        .mod = mod,
+        .mod = zcu,
         .gpa = gpa,
         .arena = analysis_arena.allocator(),
         .code = zir,
 @@ -34941,7 +34958,7 @@ fn semaBackingIntType(mod: *Module, struct_type: InternPool.LoadedStructType) Co
         var accumulator: u64 = 0;
         for (0..struct_type.field_types.len) |i| {
             const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
-            accumulator += try field_ty.bitSizeAdvanced(mod, .sema);
+            accumulator += try field_ty.bitSizeAdvanced(zcu, .sema);
         }
         break :blk accumulator;
     };
 @@ -34987,7 +35004,7 @@ fn semaBackingIntType(mod: *Module, struct_type: InternPool.LoadedStructType) Co
         if (fields_bit_sum > std.math.maxInt(u16)) {
             return sema.fail(&block, block.nodeOffset(0), "size of packed struct '{d}' exceeds maximum bit width of 65535", .{fields_bit_sum});
         }
-        const backing_int_ty = try mod.intType(.unsigned, @intCast(fields_bit_sum));
+        const backing_int_ty = try zcu.intType(.unsigned, @intCast(fields_bit_sum));
         struct_type.backingIntType(ip).* = backing_int_ty.toIntern();
     }
 @@ -35597,23 +35614,23 @@ fn structZirInfo(zir: Zir, zir_index: Zir.Inst.Index) struct {
 }
 fn semaStructFields(
-    mod: *Module,
+    zcu: *Zcu,
     arena: Allocator,
     struct_type: InternPool.LoadedStructType,
 ) CompileError!void {
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const decl_index = struct_type.decl.unwrap() orelse return;
-    const decl = mod.declPtr(decl_index);
+    const decl = zcu.declPtr(decl_index);
     const namespace_index = struct_type.namespace.unwrap() orelse decl.src_namespace;
-    const zir = mod.namespacePtr(namespace_index).file_scope.zir;
+    const zir = zcu.namespacePtr(namespace_index).fileScope(zcu).zir;
     const zir_index = struct_type.zir_index.unwrap().?.resolve(ip);
     const fields_len, const small, var extra_index = structZirInfo(zir, zir_index);
     if (fields_len == 0) switch (struct_type.layout) {
         .@"packed" => {
-            try semaBackingIntType(mod, struct_type);
+            try semaBackingIntType(zcu, struct_type);
             return;
         },
         .auto, .@"extern" => {
 @@ -35627,7 +35644,7 @@ fn semaStructFields(
     defer comptime_err_ret_trace.deinit();
     var sema: Sema = .{
-        .mod = mod,
+        .mod = zcu,
         .gpa = gpa,
         .arena = arena,
         .code = zir,
 @@ -35749,7 +35766,7 @@ fn semaStructFields(
         struct_type.field_types.get(ip)[field_i] = field_ty.toIntern();
-        if (field_ty.zigTypeTag(mod) == .Opaque) {
+        if (field_ty.zigTypeTag(zcu) == .Opaque) {
             const msg = msg: {
                 const msg = try sema.errMsg(ty_src, "opaque types have unknown size and therefore cannot be directly embedded in structs", .{});
                 errdefer msg.destroy(sema.gpa);
 @@ -35759,7 +35776,7 @@ fn semaStructFields(
             };
             return sema.failWithOwnedErrorMsg(&block_scope, msg);
         }
-        if (field_ty.zigTypeTag(mod) == .NoReturn) {
+        if (field_ty.zigTypeTag(zcu) == .NoReturn) {
             const msg = msg: {
                 const msg = try sema.errMsg(ty_src, "struct fields cannot be 'noreturn'", .{});
                 errdefer msg.destroy(sema.gpa);
 @@ -35772,7 +35789,7 @@ fn semaStructFields(
         switch (struct_type.layout) {
             .@"extern" => if (!try sema.validateExternType(field_ty, .struct_field)) {
                 const msg = msg: {
-                    const msg = try sema.errMsg(ty_src, "extern structs cannot contain fields of type '{}'", .{field_ty.fmt(mod)});
+                    const msg = try sema.errMsg(ty_src, "extern structs cannot contain fields of type '{}'", .{field_ty.fmt(zcu)});
                     errdefer msg.destroy(sema.gpa);
                     try sema.explainWhyTypeIsNotExtern(msg, ty_src, field_ty, .struct_field);
 @@ -35784,7 +35801,7 @@ fn semaStructFields(
             },
             .@"packed" => if (!try sema.validatePackedType(field_ty)) {
                 const msg = msg: {
-                    const msg = try sema.errMsg(ty_src, "packed structs cannot contain fields of type '{}'", .{field_ty.fmt(mod)});
+                    const msg = try sema.errMsg(ty_src, "packed structs cannot contain fields of type '{}'", .{field_ty.fmt(zcu)});
                     errdefer msg.destroy(sema.gpa);
                     try sema.explainWhyTypeIsNotPacked(msg, ty_src, field_ty);
 @@ -35820,19 +35837,19 @@ fn semaStructFields(
 // This logic must be kept in sync with `semaStructFields`
 fn semaStructFieldInits(
-    mod: *Module,
+    zcu: *Zcu,
     arena: Allocator,
     struct_type: InternPool.LoadedStructType,
 ) CompileError!void {
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     assert(!struct_type.haveFieldInits(ip));
     const decl_index = struct_type.decl.unwrap() orelse return;
-    const decl = mod.declPtr(decl_index);
+    const decl = zcu.declPtr(decl_index);
     const namespace_index = struct_type.namespace.unwrap() orelse decl.src_namespace;
-    const zir = mod.namespacePtr(namespace_index).file_scope.zir;
+    const zir = zcu.namespacePtr(namespace_index).fileScope(zcu).zir;
     const zir_index = struct_type.zir_index.unwrap().?.resolve(ip);
     const fields_len, const small, var extra_index = structZirInfo(zir, zir_index);
 @@ -35840,7 +35857,7 @@ fn semaStructFieldInits(
     defer comptime_err_ret_trace.deinit();
     var sema: Sema = .{
-        .mod = mod,
+        .mod = zcu,
         .gpa = gpa,
         .arena = arena,
         .code = zir,
 @@ -35950,7 +35967,7 @@ fn semaStructFieldInits(
                 });
             };
-            if (default_val.canMutateComptimeVarState(mod)) {
+            if (default_val.canMutateComptimeVarState(zcu)) {
                 return sema.fail(&block_scope, init_src, "field default value contains reference to comptime-mutable memory", .{});
             }
             struct_type.field_inits.get(ip)[field_i] = default_val.toIntern();
 @@ -35960,14 +35977,14 @@ fn semaStructFieldInits(
     try sema.flushExports();
 }
-fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.LoadedUnionType) CompileError!void {
+fn semaUnionFields(zcu: *Zcu, arena: Allocator, union_type: InternPool.LoadedUnionType) CompileError!void {
     const tracy = trace(@src());
     defer tracy.end();
-    const gpa = mod.gpa;
+    const gpa = zcu.gpa;
-    const ip = &mod.intern_pool;
+    const ip = &zcu.intern_pool;
     const decl_index = union_type.decl;
-    const zir = mod.namespacePtr(union_type.namespace.unwrap().?).file_scope.zir;
+    const zir = zcu.namespacePtr(union_type.namespace.unwrap().?).fileScope(zcu).zir;
     const zir_index = union_type.zir_index.resolve(ip);
     const extended = zir.instructions.items(.data)[@intFromEnum(zir_index)].extended;
     assert(extended.opcode == .union_decl);
 @@ -36011,13 +36028,13 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
     const body = zir.bodySlice(extra_index, body_len);
     extra_index += body.len;
-    const decl = mod.declPtr(decl_index);
+    const decl = zcu.declPtr(decl_index);
     var comptime_err_ret_trace = std.ArrayList(LazySrcLoc).init(gpa);
     defer comptime_err_ret_trace.deinit();
     var sema: Sema = .{
-        .mod = mod,
+        .mod = zcu,
         .gpa = gpa,
         .arena = arena,
         .code = zir,
 @@ -36063,18 +36080,18 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
         if (small.auto_enum_tag) {
             // The provided type is an integer type and we must construct the enum tag type here.
             int_tag_ty = provided_ty;
-            if (int_tag_ty.zigTypeTag(mod) != .Int and int_tag_ty.zigTypeTag(mod) != .ComptimeInt) {
+            if (int_tag_ty.zigTypeTag(zcu) != .Int and int_tag_ty.zigTypeTag(zcu) != .ComptimeInt) {
-                return sema.fail(&block_scope, tag_ty_src, "expected integer tag type, found '{}'", .{int_tag_ty.fmt(mod)});
+                return sema.fail(&block_scope, tag_ty_src, "expected integer tag type, found '{}'", .{int_tag_ty.fmt(zcu)});
             }
             if (fields_len > 0) {
-                const field_count_val = try mod.intValue(Type.comptime_int, fields_len - 1);
+                const field_count_val = try zcu.intValue(Type.comptime_int, fields_len - 1);
                 if (!(try sema.intFitsInType(field_count_val, int_tag_ty, null))) {
                     const msg = msg: {
                         const msg = try sema.errMsg(tag_ty_src, "specified integer tag type cannot represent every field", .{});
                         errdefer msg.destroy(sema.gpa);
                         try sema.errNote(tag_ty_src, msg, "type '{}' cannot fit values in range 0...{d}", .{
-                            int_tag_ty.fmt(mod),
+                            int_tag_ty.fmt(zcu),
                             fields_len - 1,
                         });
                         break :msg msg;
 @@ -36089,7 +36106,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
             union_type.tagTypePtr(ip).* = provided_ty.toIntern();
             const enum_type = switch (ip.indexToKey(provided_ty.toIntern())) {
                 .enum_type => ip.loadEnumType(provided_ty.toIntern()),
-                else => return sema.fail(&block_scope, tag_ty_src, "expected enum tag type, found '{}'", .{provided_ty.fmt(mod)}),
+                else => return sema.fail(&block_scope, tag_ty_src, "expected enum tag type, found '{}'", .{provided_ty.fmt(zcu)}),
             };
             // The fields of the union must match the enum exactly.
             // A flag per field is used to check for missing and extraneous fields.
 @@ -36185,7 +36202,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
                 const val = if (last_tag_val) |val|
                     try sema.intAdd(val, Value.one_comptime_int, int_tag_ty, undefined)
                 else
-                    try mod.intValue(int_tag_ty, 0);
+                    try zcu.intValue(int_tag_ty, 0);
                 last_tag_val = val;
                 break :blk val;
 @@ -36197,7 +36214,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
                     .offset = .{ .container_field_value = @intCast(gop.index) },
                 };
                 const msg = msg: {
-                    const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValue(mod, &sema)});
+                    const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValue(zcu, &sema)});
                     errdefer msg.destroy(gpa);
                     try sema.errNote(other_value_src, msg, "other occurrence here", .{});
                     break :msg msg;
 @@ -36227,7 +36244,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
             const tag_info = ip.loadEnumType(union_type.tagTypePtr(ip).*);
             const enum_index = tag_info.nameIndex(ip, field_name) orelse {
                 return sema.fail(&block_scope, name_src, "no field named '{}' in enum '{}'", .{
-                    field_name.fmt(ip), Type.fromInterned(union_type.tagTypePtr(ip).*).fmt(mod),
+                    field_name.fmt(ip), Type.fromInterned(union_type.tagTypePtr(ip).*).fmt(zcu),
                 });
             };
 @@ -36254,7 +36271,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
             }
         }
-        if (field_ty.zigTypeTag(mod) == .Opaque) {
+        if (field_ty.zigTypeTag(zcu) == .Opaque) {
             const msg = msg: {
                 const msg = try sema.errMsg(type_src, "opaque types have unknown size and therefore cannot be directly embedded in unions", .{});
                 errdefer msg.destroy(sema.gpa);
 @@ -36269,7 +36286,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
             !try sema.validateExternType(field_ty, .union_field))
         {
             const msg = msg: {
-                const msg = try sema.errMsg(type_src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(mod)});
+                const msg = try sema.errMsg(type_src, "extern unions cannot contain fields of type '{}'", .{field_ty.fmt(zcu)});
                 errdefer msg.destroy(sema.gpa);
                 try sema.explainWhyTypeIsNotExtern(msg, type_src, field_ty, .union_field);
 @@ -36280,7 +36297,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
             return sema.failWithOwnedErrorMsg(&block_scope, msg);
         } else if (layout == .@"packed" and !try sema.validatePackedType(field_ty)) {
             const msg = msg: {
-                const msg = try sema.errMsg(type_src, "packed unions cannot contain fields of type '{}'", .{field_ty.fmt(mod)});
+                const msg = try sema.errMsg(type_src, "packed unions cannot contain fields of type '{}'", .{field_ty.fmt(zcu)});
                 errdefer msg.destroy(sema.gpa);
                 try sema.explainWhyTypeIsNotPacked(msg, type_src, field_ty);
 @@ -36325,10 +36342,10 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Loaded
             return sema.failWithOwnedErrorMsg(&block_scope, msg);
         }
     } else if (enum_field_vals.count() > 0) {
-        const enum_ty = try sema.generateUnionTagTypeNumbered(&block_scope, enum_field_names, enum_field_vals.keys(), mod.declPtr(union_type.decl));
+        const enum_ty = try sema.generateUnionTagTypeNumbered(&block_scope, enum_field_names, enum_field_vals.keys(), zcu.declPtr(union_type.decl));
         union_type.tagTypePtr(ip).* = enum_ty;
     } else {
-        const enum_ty = try sema.generateUnionTagTypeSimple(&block_scope, enum_field_names, mod.declPtr(union_type.decl));
+        const enum_ty = try sema.generateUnionTagTypeSimple(&block_scope, enum_field_names, zcu.declPtr(union_type.decl));
         union_type.tagTypePtr(ip).* = enum_ty;
     }

src/Type.zig+1-1

...	@@ -3455,7 +3455,7 @@ pub fn typeDeclSrcLine(ty: Type, zcu: *const Zcu) ?u32 {	...	@@ -3455,7 +3455,7 @@ pub fn typeDeclSrcLine(ty: Type, zcu: *const Zcu) ?u32 {
3455	else => return null,	3455	else => return null,
3456	};	3456	};
3457	const info = tracked.resolveFull(&zcu.intern_pool);	3457	const info = tracked.resolveFull(&zcu.intern_pool);
3458	const file = zcu.import_table.values()[zcu.path_digest_map.getIndex(info.path_digest).?];	3458	const file = zcu.fileByIndex(info.file);
3459	assert(file.zir_loaded);	3459	assert(file.zir_loaded);
3460	const zir = file.zir;	3460	const zir = file.zir;
3461	const inst = zir.instructions.get(@intFromEnum(info.inst));	3461	const inst = zir.instructions.get(@intFromEnum(info.inst));

src/Zcu.zig+318-252

...	@@ -72,6 +72,7 @@ codegen_prog_node: std.Progress.Node = undefined,	...	@@ -72,6 +72,7 @@ codegen_prog_node: std.Progress.Node = undefined,
72	global_zir_cache: Compilation.Directory,	72	global_zir_cache: Compilation.Directory,
73	/// Used by AstGen worker to load and store ZIR cache.	73	/// Used by AstGen worker to load and store ZIR cache.
74	local_zir_cache: Compilation.Directory,	74	local_zir_cache: Compilation.Directory,
		75
75	/// This is where all `Export` values are stored. Not all values here are necessarily valid exports;	76	/// This is where all `Export` values are stored. Not all values here are necessarily valid exports;
76	/// to enumerate all exports, `single_exports` and `multi_exports` must be consulted.	77	/// to enumerate all exports, `single_exports` and `multi_exports` must be consulted.
77	all_exports: ArrayListUnmanaged(Export) = .{},	78	all_exports: ArrayListUnmanaged(Export) = .{},
...	@@ -88,14 +89,22 @@ multi_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {	...	@@ -88,14 +89,22 @@ multi_exports: std.AutoArrayHashMapUnmanaged(AnalUnit, extern struct {
88	index: u32,	89	index: u32,
89	len: u32,	90	len: u32,
90	}) = .{},	91	}) = .{},
91	/// The set of all the Zig source files in the Module. We keep track of this in order	92
92	/// to iterate over it and check which source files have been modified on the file system when	93	/// The set of all the Zig source files in the Zig Compilation Unit. Tracked in
93	/// an update is requested, as well as to cache `@import` results.	94	/// order to iterate over it and check which source files have been modified on
		95	/// the file system when an update is requested, as well as to cache `@import`
		96	/// results.
		97	///
94	/// Keys are fully resolved file paths. This table owns the keys and values.	98	/// Keys are fully resolved file paths. This table owns the keys and values.
		99	///
		100	/// Protected by Compilation's mutex.
		101	///
		102	/// Not serialized. This state is reconstructed during the first call to
		103	/// `Compilation.update` of the process for a given `Compilation`.
		104	///
		105	/// Indexes correspond 1:1 to `files`.
95	import_table: std.StringArrayHashMapUnmanaged(*File) = .{},	106	import_table: std.StringArrayHashMapUnmanaged(*File) = .{},
96	/// This acts as a map from `path_digest` to the corresponding `File`.	107
97	/// The value is omitted, as keys are ordered identically to `import_table`.
98	path_digest_map: std.AutoArrayHashMapUnmanaged(Cache.BinDigest, void) = .{},
99	/// The set of all the files which have been loaded with `@embedFile` in the Module.	108	/// The set of all the files which have been loaded with `@embedFile` in the Module.
100	/// We keep track of this in order to iterate over it and check which files have been	109	/// We keep track of this in order to iterate over it and check which files have been
101	/// modified on the file system when an update is requested, as well as to cache	110	/// modified on the file system when an update is requested, as well as to cache
...	@@ -387,8 +396,8 @@ pub const Decl = struct {	...	@@ -387,8 +396,8 @@ pub const Decl = struct {
387	anon,	396	anon,
388	};	397	};
389		398
390	const Index = InternPool.DeclIndex;	399	pub const Index = InternPool.DeclIndex;
391	const OptionalIndex = InternPool.OptionalDeclIndex;	400	pub const OptionalIndex = InternPool.OptionalDeclIndex;
392		401
393	pub fn zirBodies(decl: Decl, zcu: *Zcu) Zir.Inst.Declaration.Bodies {	402	pub fn zirBodies(decl: Decl, zcu: *Zcu) Zir.Inst.Declaration.Bodies {
394	const zir = decl.getFileScope(zcu).zir;	403	const zir = decl.getFileScope(zcu).zir;
...	@@ -490,6 +499,10 @@ pub const Decl = struct {	...	@@ -490,6 +499,10 @@ pub const Decl = struct {
490	}	499	}
491		500
492	pub fn getFileScope(decl: Decl, zcu: Zcu) File {	501	pub fn getFileScope(decl: Decl, zcu: Zcu) File {
		502	return zcu.fileByIndex(getFileScopeIndex(decl, zcu));
		503	}
		504
		505	pub fn getFileScopeIndex(decl: Decl, zcu: *Zcu) File.Index {
493	return zcu.namespacePtr(decl.src_namespace).file_scope;	506	return zcu.namespacePtr(decl.src_namespace).file_scope;
494	}	507	}
495		508
...	@@ -546,19 +559,20 @@ pub const Decl = struct {	...	@@ -546,19 +559,20 @@ pub const Decl = struct {
546	}	559	}
547		560
548	pub fn navSrcLine(decl: Decl, zcu: *Zcu) u32 {	561	pub fn navSrcLine(decl: Decl, zcu: *Zcu) u32 {
		562	const ip = &zcu.intern_pool;
549	const tracked = decl.zir_decl_index.unwrap() orelse inst: {	563	const tracked = decl.zir_decl_index.unwrap() orelse inst: {
550	// generic instantiation	564	// generic instantiation
551	assert(decl.has_tv);	565	assert(decl.has_tv);
552	assert(decl.owns_tv);	566	assert(decl.owns_tv);
553	const generic_owner_func = switch (zcu.intern_pool.indexToKey(decl.val.toIntern())) {	567	const generic_owner_func = switch (ip.indexToKey(decl.val.toIntern())) {
554	.func => \|func\| func.generic_owner,	568	.func => \|func\| func.generic_owner,
555	else => return 0, // TODO: this is probably a `variable` or something; figure this out when we finish sorting out `Decl`.	569	else => return 0, // TODO: this is probably a `variable` or something; figure this out when we finish sorting out `Decl`.
556	};	570	};
557	const generic_owner_decl = zcu.declPtr(zcu.funcInfo(generic_owner_func).owner_decl);	571	const generic_owner_decl = zcu.declPtr(zcu.funcInfo(generic_owner_func).owner_decl);
558	break :inst generic_owner_decl.zir_decl_index.unwrap().?;	572	break :inst generic_owner_decl.zir_decl_index.unwrap().?;
559	};	573	};
560	const info = tracked.resolveFull(&zcu.intern_pool);	574	const info = tracked.resolveFull(ip);
561	const file = zcu.import_table.values()[zcu.path_digest_map.getIndex(info.path_digest).?];	575	const file = zcu.fileByIndex(info.file);
562	assert(file.zir_loaded);	576	assert(file.zir_loaded);
563	const zir = file.zir;	577	const zir = file.zir;
564	const inst = zir.instructions.get(@intFromEnum(info.inst));	578	const inst = zir.instructions.get(@intFromEnum(info.inst));
...	@@ -595,7 +609,7 @@ pub const DeclAdapter = struct {	...	@@ -595,7 +609,7 @@ pub const DeclAdapter = struct {
595	/// The container that structs, enums, unions, and opaques have.	609	/// The container that structs, enums, unions, and opaques have.
596	pub const Namespace = struct {	610	pub const Namespace = struct {
597	parent: OptionalIndex,	611	parent: OptionalIndex,
598	file_scope: *File,	612	file_scope: File.Index,
599	/// Will be a struct, enum, union, or opaque.	613	/// Will be a struct, enum, union, or opaque.
600	decl_index: Decl.Index,	614	decl_index: Decl.Index,
601	/// Direct children of the namespace.	615	/// Direct children of the namespace.
...	@@ -627,6 +641,10 @@ pub const Namespace = struct {	...	@@ -627,6 +641,10 @@ pub const Namespace = struct {
627	}	641	}
628	};	642	};
629		643
		644	pub fn fileScope(ns: Namespace, zcu: Zcu) File {
		645	return zcu.fileByIndex(ns.file_scope);
		646	}
		647
630	// This renders e.g. "std.fs.Dir.OpenOptions"	648	// This renders e.g. "std.fs.Dir.OpenOptions"
631	pub fn renderFullyQualifiedName(	649	pub fn renderFullyQualifiedName(
632	ns: Namespace,	650	ns: Namespace,
...	@@ -641,7 +659,7 @@ pub const Namespace = struct {	...	@@ -641,7 +659,7 @@ pub const Namespace = struct {
641	writer,	659	writer,
642	);	660	);
643	} else {	661	} else {
644	try ns.file_scope.renderFullyQualifiedName(writer);	662	try ns.fileScope(zcu).renderFullyQualifiedName(writer);
645	}	663	}
646	if (name != .empty) try writer.print(".{}", .{name.fmt(&zcu.intern_pool)});	664	if (name != .empty) try writer.print(".{}", .{name.fmt(&zcu.intern_pool)});
647	}	665	}
...	@@ -661,7 +679,7 @@ pub const Namespace = struct {	...	@@ -661,7 +679,7 @@ pub const Namespace = struct {
661	);	679	);
662	break :sep '.';	680	break :sep '.';
663	} else sep: {	681	} else sep: {
664	try ns.file_scope.renderFullyQualifiedDebugName(writer);	682	try ns.fileScope(zcu).renderFullyQualifiedDebugName(writer);
665	break :sep ':';	683	break :sep ':';
666	};	684	};
667	if (name != .empty) try writer.print("{c}{}", .{ sep, name.fmt(&zcu.intern_pool) });	685	if (name != .empty) try writer.print("{c}{}", .{ sep, name.fmt(&zcu.intern_pool) });
...	@@ -680,7 +698,7 @@ pub const Namespace = struct {	...	@@ -680,7 +698,7 @@ pub const Namespace = struct {
680	const decl = zcu.declPtr(cur_ns.decl_index);	698	const decl = zcu.declPtr(cur_ns.decl_index);
681	count += decl.name.length(ip) + 1;	699	count += decl.name.length(ip) + 1;
682	cur_ns = zcu.namespacePtr(cur_ns.parent.unwrap() orelse {	700	cur_ns = zcu.namespacePtr(cur_ns.parent.unwrap() orelse {
683	count += ns.file_scope.sub_file_path.len;	701	count += ns.fileScope(zcu).sub_file_path.len;
684	break :count count;	702	break :count count;
685	});	703	});
686	}	704	}
...	@@ -715,8 +733,6 @@ pub const Namespace = struct {	...	@@ -715,8 +733,6 @@ pub const Namespace = struct {
715	};	733	};
716		734
717	pub const File = struct {	735	pub const File = struct {
718	/// The Decl of the struct that represents this File.
719	root_decl: Decl.OptionalIndex,
720	status: enum {	736	status: enum {
721	never_loaded,	737	never_loaded,
722	retryable_failure,	738	retryable_failure,
...	@@ -744,8 +760,6 @@ pub const File = struct {	...	@@ -744,8 +760,6 @@ pub const File = struct {
744	multi_pkg: bool = false,	760	multi_pkg: bool = false,
745	/// List of references to this file, used for multi-package errors.	761	/// List of references to this file, used for multi-package errors.
746	references: std.ArrayListUnmanaged(File.Reference) = .{},	762	references: std.ArrayListUnmanaged(File.Reference) = .{},
747	/// The hash of the path to this file, used to store `InternPool.TrackedInst`.
748	path_digest: Cache.BinDigest,
749		763
750	/// The most recent successful ZIR for this file, with no errors.	764	/// The most recent successful ZIR for this file, with no errors.
751	/// This is only populated when a previously successful ZIR	765	/// This is only populated when a previously successful ZIR
...	@@ -757,7 +771,7 @@ pub const File = struct {	...	@@ -757,7 +771,7 @@ pub const File = struct {
757	pub const Reference = union(enum) {	771	pub const Reference = union(enum) {
758	/// The file is imported directly (i.e. not as a package) with @import.	772	/// The file is imported directly (i.e. not as a package) with @import.
759	import: struct {	773	import: struct {
760	file: *File,	774	file: File.Index,
761	token: Ast.TokenIndex,	775	token: Ast.TokenIndex,
762	},	776	},
763	/// The file is the root of a module.	777	/// The file is the root of a module.
...	@@ -791,28 +805,6 @@ pub const File = struct {	...	@@ -791,28 +805,6 @@ pub const File = struct {
791	}	805	}
792	}	806	}
793		807
794	pub fn deinit(file: File, mod: Module) void {
795	const gpa = mod.gpa;
796	const is_builtin = file.mod.isBuiltin();
797	log.debug("deinit File {s}", .{file.sub_file_path});
798	if (is_builtin) {
799	file.unloadTree(gpa);
800	file.unloadZir(gpa);
801	} else {
802	gpa.free(file.sub_file_path);
803	file.unload(gpa);
804	}
805	file.references.deinit(gpa);
806	if (file.root_decl.unwrap()) \|root_decl\| {
807	mod.destroyDecl(root_decl);
808	}
809	if (file.prev_zir) \|prev_zir\| {
810	prev_zir.deinit(gpa);
811	gpa.destroy(prev_zir);
812	}
813	file.* = undefined;
814	}
815
816	pub const Source = struct {	808	pub const Source = struct {
817	bytes: [:0]const u8,	809	bytes: [:0]const u8,
818	stat: Cache.File.Stat,	810	stat: Cache.File.Stat,
...	@@ -865,13 +857,6 @@ pub const File = struct {	...	@@ -865,13 +857,6 @@ pub const File = struct {
865	return &file.tree;	857	return &file.tree;
866	}	858	}
867		859
868	pub fn destroy(file: File, mod: Module) void {
869	const gpa = mod.gpa;
870	const is_builtin = file.mod.isBuiltin();
871	file.deinit(mod);
872	if (!is_builtin) gpa.destroy(file);
873	}
874
875	pub fn renderFullyQualifiedName(file: File, writer: anytype) !void {	860	pub fn renderFullyQualifiedName(file: File, writer: anytype) !void {
876	// Convert all the slashes into dots and truncate the extension.	861	// Convert all the slashes into dots and truncate the extension.
877	const ext = std.fs.path.extension(file.sub_file_path);	862	const ext = std.fs.path.extension(file.sub_file_path);
...	@@ -937,7 +922,7 @@ pub const File = struct {	...	@@ -937,7 +922,7 @@ pub const File = struct {
937	}	922	}
938		923
939	const mod = switch (ref) {	924	const mod = switch (ref) {
940	.import => \|import\| import.file.mod,	925	.import => \|import\| zcu.fileByIndex(import.file).mod,
941	.root => \|mod\| mod,	926	.root => \|mod\| mod,
942	};	927	};
943	if (mod != file.mod) file.multi_pkg = true;	928	if (mod != file.mod) file.multi_pkg = true;
...	@@ -971,6 +956,8 @@ pub const File = struct {	...	@@ -971,6 +956,8 @@ pub const File = struct {
971	}	956	}
972	}	957	}
973	}	958	}
		959
		960	pub const Index = InternPool.FileIndex;
974	};	961	};
975		962
976	pub const EmbedFile = struct {	963	pub const EmbedFile = struct {
...	@@ -2350,14 +2337,12 @@ pub const LazySrcLoc = struct {	...	@@ -2350,14 +2337,12 @@ pub const LazySrcLoc = struct {
2350	};	2337	};
2351		2338
2352	pub fn resolveBaseNode(base_node_inst: InternPool.TrackedInst.Index, zcu: Zcu) struct { File, Ast.Node.Index } {	2339	pub fn resolveBaseNode(base_node_inst: InternPool.TrackedInst.Index, zcu: Zcu) struct { File, Ast.Node.Index } {
2353	const want_path_digest, const zir_inst = inst: {	2340	const ip = &zcu.intern_pool;
2354	const info = base_node_inst.resolveFull(&zcu.intern_pool);	2341	const file_index, const zir_inst = inst: {
2355	break :inst .{ info.path_digest, info.inst };	2342	const info = base_node_inst.resolveFull(ip);
2356	};	2343	break :inst .{ info.file, info.inst };
2357	const file = file: {
2358	const index = zcu.path_digest_map.getIndex(want_path_digest).?;
2359	break :file zcu.import_table.values()[index];
2360	};	2344	};
		2345	const file = zcu.fileByIndex(file_index);
2361	assert(file.zir_loaded);	2346	assert(file.zir_loaded);
2362		2347
2363	const zir = file.zir;	2348	const zir = file.zir;
...	@@ -2423,11 +2408,11 @@ pub fn deinit(zcu: *Zcu) void {	...	@@ -2423,11 +2408,11 @@ pub fn deinit(zcu: *Zcu) void {
2423	for (zcu.import_table.keys()) \|key\| {	2408	for (zcu.import_table.keys()) \|key\| {
2424	gpa.free(key);	2409	gpa.free(key);
2425	}	2410	}
2426	for (zcu.import_table.values()) \|value\| {	2411	for (0..zcu.import_table.entries.len) \|file_index_usize\| {
2427	value.destroy(zcu);	2412	const file_index: File.Index = @enumFromInt(file_index_usize);
		2413	zcu.destroyFile(file_index);
2428	}	2414	}
2429	zcu.import_table.deinit(gpa);	2415	zcu.import_table.deinit(gpa);
2430	zcu.path_digest_map.deinit(gpa);
2431		2416
2432	for (zcu.embed_table.keys(), zcu.embed_table.values()) \|path, embed_file\| {	2417	for (zcu.embed_table.keys(), zcu.embed_table.values()) \|path, embed_file\| {
2433	gpa.free(path);	2418	gpa.free(path);
...	@@ -2531,6 +2516,37 @@ pub fn destroyDecl(mod: *Module, decl_index: Decl.Index) void {	...	@@ -2531,6 +2516,37 @@ pub fn destroyDecl(mod: *Module, decl_index: Decl.Index) void {
2531	}	2516	}
2532	}	2517	}
2533		2518
		2519	fn deinitFile(zcu: *Zcu, file_index: File.Index) void {
		2520	const gpa = zcu.gpa;
		2521	const file = zcu.fileByIndex(file_index);
		2522	const is_builtin = file.mod.isBuiltin();
		2523	log.debug("deinit File {s}", .{file.sub_file_path});
		2524	if (is_builtin) {
		2525	file.unloadTree(gpa);
		2526	file.unloadZir(gpa);
		2527	} else {
		2528	gpa.free(file.sub_file_path);
		2529	file.unload(gpa);
		2530	}
		2531	file.references.deinit(gpa);
		2532	if (zcu.fileRootDecl(file_index).unwrap()) \|root_decl\| {
		2533	zcu.destroyDecl(root_decl);
		2534	}
		2535	if (file.prev_zir) \|prev_zir\| {
		2536	prev_zir.deinit(gpa);
		2537	gpa.destroy(prev_zir);
		2538	}
		2539	file.* = undefined;
		2540	}
		2541
		2542	pub fn destroyFile(zcu: *Zcu, file_index: File.Index) void {
		2543	const gpa = zcu.gpa;
		2544	const file = zcu.fileByIndex(file_index);
		2545	const is_builtin = file.mod.isBuiltin();
		2546	zcu.deinitFile(file_index);
		2547	if (!is_builtin) gpa.destroy(file);
		2548	}
		2549
2534	pub fn declPtr(mod: Module, index: Decl.Index) Decl {	2550	pub fn declPtr(mod: Module, index: Decl.Index) Decl {
2535	return mod.intern_pool.declPtr(index);	2551	return mod.intern_pool.declPtr(index);
2536	}	2552	}
...	@@ -2563,14 +2579,23 @@ comptime {	...	@@ -2563,14 +2579,23 @@ comptime {
2563	}	2579	}
2564	}	2580	}
2565		2581
2566	pub fn astGenFile(mod: Module, file: File) !void {	2582	pub fn astGenFile(
		2583	zcu: *Zcu,
		2584	file: *File,
		2585	/// This parameter is provided separately from `file` because it is not
		2586	/// safe to access `import_table` without a lock, and this index is needed
		2587	/// in the call to `updateZirRefs`.
		2588	file_index: File.Index,
		2589	path_digest: Cache.BinDigest,
		2590	opt_root_decl: Zcu.Decl.OptionalIndex,
		2591	) !void {
2567	assert(!file.mod.isBuiltin());	2592	assert(!file.mod.isBuiltin());
2568		2593
2569	const tracy = trace(@src());	2594	const tracy = trace(@src());
2570	defer tracy.end();	2595	defer tracy.end();
2571		2596
2572	const comp = mod.comp;	2597	const comp = zcu.comp;
2573	const gpa = mod.gpa;	2598	const gpa = zcu.gpa;
2574		2599
2575	// In any case we need to examine the stat of the file to determine the course of action.	2600	// In any case we need to examine the stat of the file to determine the course of action.
2576	var source_file = try file.mod.root.openFile(file.sub_file_path, .{});	2601	var source_file = try file.mod.root.openFile(file.sub_file_path, .{});
...	@@ -2578,17 +2603,9 @@ pub fn astGenFile(mod: Module, file: File) !void {	...	@@ -2578,17 +2603,9 @@ pub fn astGenFile(mod: Module, file: File) !void {
2578		2603
2579	const stat = try source_file.stat();	2604	const stat = try source_file.stat();
2580		2605
2581	const want_local_cache = file.mod == mod.main_mod;	2606	const want_local_cache = file.mod == zcu.main_mod;
2582	const hex_digest = hex: {	2607	const hex_digest = Cache.binToHex(path_digest);
2583	var hex: Cache.HexDigest = undefined;	2608	const cache_directory = if (want_local_cache) zcu.local_zir_cache else zcu.global_zir_cache;
2584	_ = std.fmt.bufPrint(
2585	&hex,
2586	"{s}",
2587	.{std.fmt.fmtSliceHexLower(&file.path_digest)},
2588	) catch unreachable;
2589	break :hex hex;
2590	};
2591	const cache_directory = if (want_local_cache) mod.local_zir_cache else mod.global_zir_cache;
2592	const zir_dir = cache_directory.handle;	2609	const zir_dir = cache_directory.handle;
2593		2610
2594	// Determine whether we need to reload the file from disk and redo parsing and AstGen.	2611	// Determine whether we need to reload the file from disk and redo parsing and AstGen.
...	@@ -2688,7 +2705,7 @@ pub fn astGenFile(mod: Module, file: File) !void {	...	@@ -2688,7 +2705,7 @@ pub fn astGenFile(mod: Module, file: File) !void {
2688	{	2705	{
2689	comp.mutex.lock();	2706	comp.mutex.lock();
2690	defer comp.mutex.unlock();	2707	defer comp.mutex.unlock();
2691	try mod.failed_files.putNoClobber(gpa, file, null);	2708	try zcu.failed_files.putNoClobber(gpa, file, null);
2692	}	2709	}
2693	file.status = .astgen_failure;	2710	file.status = .astgen_failure;
2694	return error.AnalysisFail;	2711	return error.AnalysisFail;
...	@@ -2712,7 +2729,7 @@ pub fn astGenFile(mod: Module, file: File) !void {	...	@@ -2712,7 +2729,7 @@ pub fn astGenFile(mod: Module, file: File) !void {
2712	else => \|e\| return e,	2729	else => \|e\| return e,
2713	};	2730	};
2714		2731
2715	mod.lockAndClearFileCompileError(file);	2732	zcu.lockAndClearFileCompileError(file);
2716		2733
2717	// If the previous ZIR does not have compile errors, keep it around	2734	// If the previous ZIR does not have compile errors, keep it around
2718	// in case parsing or new ZIR fails. In case of successful ZIR update	2735	// in case parsing or new ZIR fails. In case of successful ZIR update
...	@@ -2818,27 +2835,27 @@ pub fn astGenFile(mod: Module, file: File) !void {	...	@@ -2818,27 +2835,27 @@ pub fn astGenFile(mod: Module, file: File) !void {
2818	{	2835	{
2819	comp.mutex.lock();	2836	comp.mutex.lock();
2820	defer comp.mutex.unlock();	2837	defer comp.mutex.unlock();
2821	try mod.failed_files.putNoClobber(gpa, file, null);	2838	try zcu.failed_files.putNoClobber(gpa, file, null);
2822	}	2839	}
2823	file.status = .astgen_failure;	2840	file.status = .astgen_failure;
2824	return error.AnalysisFail;	2841	return error.AnalysisFail;
2825	}	2842	}
2826		2843
2827	if (file.prev_zir) \|prev_zir\| {	2844	if (file.prev_zir) \|prev_zir\| {
2828	try updateZirRefs(mod, file, prev_zir.*);	2845	try updateZirRefs(zcu, file, file_index, prev_zir.*);
2829	// No need to keep previous ZIR.	2846	// No need to keep previous ZIR.
2830	prev_zir.deinit(gpa);	2847	prev_zir.deinit(gpa);
2831	gpa.destroy(prev_zir);	2848	gpa.destroy(prev_zir);
2832	file.prev_zir = null;	2849	file.prev_zir = null;
2833	}	2850	}
2834		2851
2835	if (file.root_decl.unwrap()) \|root_decl\| {	2852	if (opt_root_decl.unwrap()) \|root_decl\| {
2836	// The root of this file must be re-analyzed, since the file has changed.	2853	// The root of this file must be re-analyzed, since the file has changed.
2837	comp.mutex.lock();	2854	comp.mutex.lock();
2838	defer comp.mutex.unlock();	2855	defer comp.mutex.unlock();
2839		2856
2840	log.debug("outdated root Decl: {}", .{root_decl});	2857	log.debug("outdated root Decl: {}", .{root_decl});
2841	try mod.outdated_file_root.put(gpa, root_decl, {});	2858	try zcu.outdated_file_root.put(gpa, root_decl, {});
2842	}	2859	}
2843	}	2860	}
2844		2861
...	@@ -2914,7 +2931,7 @@ fn loadZirCacheBody(gpa: Allocator, header: Zir.Header, cache_file: std.fs.File)	...	@@ -2914,7 +2931,7 @@ fn loadZirCacheBody(gpa: Allocator, header: Zir.Header, cache_file: std.fs.File)
2914		2931
2915	/// This is called from the AstGen thread pool, so must acquire	2932	/// This is called from the AstGen thread pool, so must acquire
2916	/// the Compilation mutex when acting on shared state.	2933	/// the Compilation mutex when acting on shared state.
2917	fn updateZirRefs(zcu: Module, file: File, old_zir: Zir) !void {	2934	fn updateZirRefs(zcu: Module, file: File, file_index: File.Index, old_zir: Zir) !void {
2918	const gpa = zcu.gpa;	2935	const gpa = zcu.gpa;
2919	const new_zir = file.zir;	2936	const new_zir = file.zir;
2920		2937
...	@@ -2930,7 +2947,7 @@ fn updateZirRefs(zcu: Module, file: File, old_zir: Zir) !void {	...	@@ -2930,7 +2947,7 @@ fn updateZirRefs(zcu: Module, file: File, old_zir: Zir) !void {
2930	// iterating over this full set for every updated file.	2947	// iterating over this full set for every updated file.
2931	for (zcu.intern_pool.tracked_insts.keys(), 0..) \|*ti, idx_raw\| {	2948	for (zcu.intern_pool.tracked_insts.keys(), 0..) \|*ti, idx_raw\| {
2932	const ti_idx: InternPool.TrackedInst.Index = @enumFromInt(idx_raw);	2949	const ti_idx: InternPool.TrackedInst.Index = @enumFromInt(idx_raw);
2933	if (!std.mem.eql(u8, &ti.path_digest, &file.path_digest)) continue;	2950	if (ti.file != file_index) continue;
2934	const old_inst = ti.inst;	2951	const old_inst = ti.inst;
2935	ti.inst = inst_map.get(ti.inst) orelse {	2952	ti.inst = inst_map.get(ti.inst) orelse {
2936	// Tracking failed for this instruction. Invalidate associated `src_hash` deps.	2953	// Tracking failed for this instruction. Invalidate associated `src_hash` deps.
...	@@ -3378,11 +3395,11 @@ pub fn mapOldZirToNew(	...	@@ -3378,11 +3395,11 @@ pub fn mapOldZirToNew(
3378	}	3395	}
3379		3396
3380	/// Like `ensureDeclAnalyzed`, but the Decl is a file's root Decl.	3397	/// Like `ensureDeclAnalyzed`, but the Decl is a file's root Decl.
3381	pub fn ensureFileAnalyzed(zcu: Zcu, file: File) SemaError!void {	3398	pub fn ensureFileAnalyzed(zcu: *Zcu, file_index: File.Index) SemaError!void {
3382	if (file.root_decl.unwrap()) \|existing_root\| {	3399	if (zcu.fileRootDecl(file_index).unwrap()) \|existing_root\| {
3383	return zcu.ensureDeclAnalyzed(existing_root);	3400	return zcu.ensureDeclAnalyzed(existing_root);
3384	} else {	3401	} else {
3385	return zcu.semaFile(file);	3402	return zcu.semaFile(file_index);
3386	}	3403	}
3387	}	3404	}
3388		3405
...	@@ -3455,7 +3472,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {	...	@@ -3455,7 +3472,7 @@ pub fn ensureDeclAnalyzed(mod: *Module, decl_index: Decl.Index) SemaError!void {
3455	}	3472	}
3456		3473
3457	if (mod.declIsRoot(decl_index)) {	3474	if (mod.declIsRoot(decl_index)) {
3458	const changed = try mod.semaFileUpdate(decl.getFileScope(mod), decl_was_outdated);	3475	const changed = try mod.semaFileUpdate(decl.getFileScopeIndex(mod), decl_was_outdated);
3459	break :blk .{	3476	break :blk .{
3460	.invalidate_decl_val = changed,	3477	.invalidate_decl_val = changed,
3461	.invalidate_decl_ref = changed,	3478	.invalidate_decl_ref = changed,
...	@@ -3787,17 +3804,23 @@ pub fn ensureFuncBodyAnalysisQueued(mod: *Module, func_index: InternPool.Index)	...	@@ -3787,17 +3804,23 @@ pub fn ensureFuncBodyAnalysisQueued(mod: *Module, func_index: InternPool.Index)
3787	func.analysis(ip).state = .queued;	3804	func.analysis(ip).state = .queued;
3788	}	3805	}
3789		3806
3790	/// https://github.com/ziglang/zig/issues/14307	3807	pub fn semaPkg(zcu: Zcu, pkg: Package.Module) !void {
3791	pub fn semaPkg(mod: Module, pkg: Package.Module) !void {	3808	const import_file_result = try zcu.importPkg(pkg);
3792	const file = (try mod.importPkg(pkg)).file;	3809	const root_decl_index = zcu.fileRootDecl(import_file_result.file_index);
3793	if (file.root_decl == .none) {	3810	if (root_decl_index == .none) {
3794	return mod.semaFile(file);	3811	return zcu.semaFile(import_file_result.file_index);
3795	}	3812	}
3796	}	3813	}
3797		3814
3798	fn getFileRootStruct(zcu: Zcu, decl_index: Decl.Index, namespace_index: Namespace.Index, file: File) Allocator.Error!InternPool.Index {	3815	fn getFileRootStruct(
		3816	zcu: *Zcu,
		3817	decl_index: Decl.Index,
		3818	namespace_index: Namespace.Index,
		3819	file_index: File.Index,
		3820	) Allocator.Error!InternPool.Index {
3799	const gpa = zcu.gpa;	3821	const gpa = zcu.gpa;
3800	const ip = &zcu.intern_pool;	3822	const ip = &zcu.intern_pool;
		3823	const file = zcu.fileByIndex(file_index);
3801	const extended = file.zir.instructions.items(.data)[@intFromEnum(Zir.Inst.Index.main_struct_inst)].extended;	3824	const extended = file.zir.instructions.items(.data)[@intFromEnum(Zir.Inst.Index.main_struct_inst)].extended;
3802	assert(extended.opcode == .struct_decl);	3825	assert(extended.opcode == .struct_decl);
3803	const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);	3826	const small: Zir.Inst.StructDecl.Small = @bitCast(extended.small);
...	@@ -3818,7 +3841,7 @@ fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespa	...	@@ -3818,7 +3841,7 @@ fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespa
3818	const decls = file.zir.bodySlice(extra_index, decls_len);	3841	const decls = file.zir.bodySlice(extra_index, decls_len);
3819	extra_index += decls_len;	3842	extra_index += decls_len;
3820		3843
3821	const tracked_inst = try ip.trackZir(gpa, file, .main_struct_inst);	3844	const tracked_inst = try ip.trackZir(gpa, file_index, .main_struct_inst);
3822	const wip_ty = switch (try ip.getStructType(gpa, .{	3845	const wip_ty = switch (try ip.getStructType(gpa, .{
3823	.layout = .auto,	3846	.layout = .auto,
3824	.fields_len = fields_len,	3847	.fields_len = fields_len,
...	@@ -3863,8 +3886,9 @@ fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespa	...	@@ -3863,8 +3886,9 @@ fn getFileRootStruct(zcu: *Zcu, decl_index: Decl.Index, namespace_index: Namespa
3863	/// If `type_outdated`, the struct type itself is considered outdated and is	3886	/// If `type_outdated`, the struct type itself is considered outdated and is
3864	/// reconstructed at a new InternPool index. Otherwise, the namespace is just	3887	/// reconstructed at a new InternPool index. Otherwise, the namespace is just
3865	/// re-analyzed. Returns whether the decl's tyval was invalidated.	3888	/// re-analyzed. Returns whether the decl's tyval was invalidated.
3866	fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {	3889	fn semaFileUpdate(zcu: *Zcu, file_index: File.Index, type_outdated: bool) SemaError!bool {
3867	const decl = zcu.declPtr(file.root_decl.unwrap().?);	3890	const file = zcu.fileByIndex(file_index);
		3891	const decl = zcu.declPtr(zcu.fileRootDecl(file_index).unwrap().?);
3868		3892
3869	log.debug("semaFileUpdate mod={s} sub_file_path={s} type_outdated={}", .{	3893	log.debug("semaFileUpdate mod={s} sub_file_path={s} type_outdated={}", .{
3870	file.mod.fully_qualified_name,	3894	file.mod.fully_qualified_name,
...	@@ -3883,7 +3907,8 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {	...	@@ -3883,7 +3907,8 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {
3883		3907
3884	if (decl.analysis == .file_failure) {	3908	if (decl.analysis == .file_failure) {
3885	// No struct type currently exists. Create one!	3909	// No struct type currently exists. Create one!
3886	_ = try zcu.getFileRootStruct(file.root_decl.unwrap().?, decl.src_namespace, file);	3910	const root_decl = zcu.fileRootDecl(file_index);
		3911	_ = try zcu.getFileRootStruct(root_decl.unwrap().?, decl.src_namespace, file_index);
3887	return true;	3912	return true;
3888	}	3913	}
3889		3914
...	@@ -3892,10 +3917,13 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {	...	@@ -3892,10 +3917,13 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {
3892		3917
3893	if (type_outdated) {	3918	if (type_outdated) {
3894	// Invalidate the existing type, reusing the decl and namespace.	3919	// Invalidate the existing type, reusing the decl and namespace.
3895	zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, AnalUnit.wrap(.{ .decl = file.root_decl.unwrap().? }));	3920	const file_root_decl = zcu.fileRootDecl(file_index).unwrap().?;
		3921	zcu.intern_pool.removeDependenciesForDepender(zcu.gpa, AnalUnit.wrap(.{
		3922	.decl = file_root_decl,
		3923	}));
3896	zcu.intern_pool.remove(decl.val.toIntern());	3924	zcu.intern_pool.remove(decl.val.toIntern());
3897	decl.val = undefined;	3925	decl.val = undefined;
3898	_ = try zcu.getFileRootStruct(file.root_decl.unwrap().?, decl.src_namespace, file);	3926	_ = try zcu.getFileRootStruct(file_root_decl, decl.src_namespace, file_index);
3899	return true;	3927	return true;
3900	}	3928	}
3901		3929
...	@@ -3923,35 +3951,36 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {	...	@@ -3923,35 +3951,36 @@ fn semaFileUpdate(zcu: Zcu, file: File, type_outdated: bool) SemaError!bool {
3923		3951
3924	/// Regardless of the file status, will create a `Decl` if none exists so that we can track	3952	/// Regardless of the file status, will create a `Decl` if none exists so that we can track
3925	/// dependencies and re-analyze when the file becomes outdated.	3953	/// dependencies and re-analyze when the file becomes outdated.
3926	fn semaFile(mod: Module, file: File) SemaError!void {	3954	fn semaFile(zcu: *Zcu, file_index: File.Index) SemaError!void {
3927	const tracy = trace(@src());	3955	const tracy = trace(@src());
3928	defer tracy.end();	3956	defer tracy.end();
3929		3957
3930	assert(file.root_decl == .none);	3958	const file = zcu.fileByIndex(file_index);
		3959	assert(zcu.fileRootDecl(file_index) == .none);
3931		3960
3932	const gpa = mod.gpa;	3961	const gpa = zcu.gpa;
3933	log.debug("semaFile mod={s} sub_file_path={s}", .{	3962	log.debug("semaFile zcu={s} sub_file_path={s}", .{
3934	file.mod.fully_qualified_name, file.sub_file_path,	3963	file.mod.fully_qualified_name, file.sub_file_path,
3935	});	3964	});
3936		3965
3937	// Because these three things each reference each other, `undefined`	3966	// Because these three things each reference each other, `undefined`
3938	// placeholders are used before being set after the struct type gains an	3967	// placeholders are used before being set after the struct type gains an
3939	// InternPool index.	3968	// InternPool index.
3940	const new_namespace_index = try mod.createNamespace(.{	3969	const new_namespace_index = try zcu.createNamespace(.{
3941	.parent = .none,	3970	.parent = .none,
3942	.decl_index = undefined,	3971	.decl_index = undefined,
3943	.file_scope = file,	3972	.file_scope = file_index,
3944	});	3973	});
3945	errdefer mod.destroyNamespace(new_namespace_index);	3974	errdefer zcu.destroyNamespace(new_namespace_index);
3946		3975
3947	const new_decl_index = try mod.allocateNewDecl(new_namespace_index);	3976	const new_decl_index = try zcu.allocateNewDecl(new_namespace_index);
3948	const new_decl = mod.declPtr(new_decl_index);	3977	const new_decl = zcu.declPtr(new_decl_index);
3949	errdefer @panic("TODO error handling");	3978	errdefer @panic("TODO error handling");
3950		3979
3951	file.root_decl = new_decl_index.toOptional();	3980	zcu.setFileRootDecl(file_index, new_decl_index.toOptional());
3952	mod.namespacePtr(new_namespace_index).decl_index = new_decl_index;	3981	zcu.namespacePtr(new_namespace_index).decl_index = new_decl_index;
3953		3982
3954	new_decl.name = try file.fullyQualifiedName(mod);	3983	new_decl.name = try file.fullyQualifiedName(zcu);
3955	new_decl.name_fully_qualified = true;	3984	new_decl.name_fully_qualified = true;
3956	new_decl.is_pub = true;	3985	new_decl.is_pub = true;
3957	new_decl.is_exported = false;	3986	new_decl.is_exported = false;
...	@@ -3965,13 +3994,13 @@ fn semaFile(mod: Module, file: File) SemaError!void {	...	@@ -3965,13 +3994,13 @@ fn semaFile(mod: Module, file: File) SemaError!void {
3965	}	3994	}
3966	assert(file.zir_loaded);	3995	assert(file.zir_loaded);
3967		3996
3968	const struct_ty = try mod.getFileRootStruct(new_decl_index, new_namespace_index, file);	3997	const struct_ty = try zcu.getFileRootStruct(new_decl_index, new_namespace_index, file_index);
3969	errdefer mod.intern_pool.remove(struct_ty);	3998	errdefer zcu.intern_pool.remove(struct_ty);
3970		3999
3971	switch (mod.comp.cache_use) {	4000	switch (zcu.comp.cache_use) {
3972	.whole => \|whole\| if (whole.cache_manifest) \|man\| {	4001	.whole => \|whole\| if (whole.cache_manifest) \|man\| {
3973	const source = file.getSource(gpa) catch \|err\| {	4002	const source = file.getSource(gpa) catch \|err\| {
3974	try reportRetryableFileError(mod, file, "unable to load source: {s}", .{@errorName(err)});	4003	try reportRetryableFileError(zcu, file_index, "unable to load source: {s}", .{@errorName(err)});
3975	return error.AnalysisFail;	4004	return error.AnalysisFail;
3976	};	4005	};
3977		4006
...	@@ -3980,7 +4009,7 @@ fn semaFile(mod: Module, file: File) SemaError!void {	...	@@ -3980,7 +4009,7 @@ fn semaFile(mod: Module, file: File) SemaError!void {
3980	file.mod.root.sub_path,	4009	file.mod.root.sub_path,
3981	file.sub_file_path,	4010	file.sub_file_path,
3982	}) catch \|err\| {	4011	}) catch \|err\| {
3983	try reportRetryableFileError(mod, file, "unable to resolve path: {s}", .{@errorName(err)});	4012	try reportRetryableFileError(zcu, file_index, "unable to resolve path: {s}", .{@errorName(err)});
3984	return error.AnalysisFail;	4013	return error.AnalysisFail;
3985	};	4014	};
3986	errdefer gpa.free(resolved_path);	4015	errdefer gpa.free(resolved_path);
...	@@ -4000,57 +4029,58 @@ const SemaDeclResult = packed struct {	...	@@ -4000,57 +4029,58 @@ const SemaDeclResult = packed struct {
4000	invalidate_decl_ref: bool,	4029	invalidate_decl_ref: bool,
4001	};	4030	};
4002		4031
4003	fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	4032	fn semaDecl(zcu: *Zcu, decl_index: Decl.Index) !SemaDeclResult {
4004	const tracy = trace(@src());	4033	const tracy = trace(@src());
4005	defer tracy.end();	4034	defer tracy.end();
4006		4035
4007	const decl = mod.declPtr(decl_index);	4036	const decl = zcu.declPtr(decl_index);
4008	const ip = &mod.intern_pool;	4037	const ip = &zcu.intern_pool;
4009		4038
4010	if (decl.getFileScope(mod).status != .success_zir) {	4039	if (decl.getFileScope(zcu).status != .success_zir) {
4011	return error.AnalysisFail;	4040	return error.AnalysisFail;
4012	}	4041	}
4013		4042
4014	assert(!mod.declIsRoot(decl_index));	4043	assert(!zcu.declIsRoot(decl_index));
4015		4044
4016	if (decl.zir_decl_index == .none and decl.owns_tv) {	4045	if (decl.zir_decl_index == .none and decl.owns_tv) {
4017	// We are re-analyzing an anonymous owner Decl (for a function or a namespace type).	4046	// We are re-analyzing an anonymous owner Decl (for a function or a namespace type).
4018	return mod.semaAnonOwnerDecl(decl_index);	4047	return zcu.semaAnonOwnerDecl(decl_index);
4019	}	4048	}
4020		4049
4021	log.debug("semaDecl '{d}'", .{@intFromEnum(decl_index)});	4050	log.debug("semaDecl '{d}'", .{@intFromEnum(decl_index)});
4022	log.debug("decl name '{}'", .{(try decl.fullyQualifiedName(mod)).fmt(ip)});	4051	log.debug("decl name '{}'", .{(try decl.fullyQualifiedName(zcu)).fmt(ip)});
4023	defer blk: {	4052	defer blk: {
4024	log.debug("finish decl name '{}'", .{(decl.fullyQualifiedName(mod) catch break :blk).fmt(ip)});	4053	log.debug("finish decl name '{}'", .{(decl.fullyQualifiedName(zcu) catch break :blk).fmt(ip)});
4025	}	4054	}
4026		4055
4027	const old_has_tv = decl.has_tv;	4056	const old_has_tv = decl.has_tv;
4028	// The following values are ignored if `!old_has_tv`	4057	// The following values are ignored if `!old_has_tv`
4029	const old_ty = if (old_has_tv) decl.typeOf(mod) else undefined;	4058	const old_ty = if (old_has_tv) decl.typeOf(zcu) else undefined;
4030	const old_val = decl.val;	4059	const old_val = decl.val;
4031	const old_align = decl.alignment;	4060	const old_align = decl.alignment;
4032	const old_linksection = decl.@"linksection";	4061	const old_linksection = decl.@"linksection";
4033	const old_addrspace = decl.@"addrspace";	4062	const old_addrspace = decl.@"addrspace";
4034	const old_is_inline = if (decl.getOwnedFunction(mod)) \|prev_func\|	4063	const old_is_inline = if (decl.getOwnedFunction(zcu)) \|prev_func\|
4035	prev_func.analysis(ip).state == .inline_only	4064	prev_func.analysis(ip).state == .inline_only
4036	else	4065	else
4037	false;	4066	false;
4038		4067
4039	const decl_inst = decl.zir_decl_index.unwrap().?.resolve(ip);	4068	const decl_inst = decl.zir_decl_index.unwrap().?.resolve(ip);
4040		4069
4041	const gpa = mod.gpa;	4070	const gpa = zcu.gpa;
4042	const zir = decl.getFileScope(mod).zir;	4071	const zir = decl.getFileScope(zcu).zir;
4043		4072
4044	const builtin_type_target_index: InternPool.Index = ip_index: {	4073	const builtin_type_target_index: InternPool.Index = ip_index: {
4045	const std_mod = mod.std_mod;	4074	const std_mod = zcu.std_mod;
4046	if (decl.getFileScope(mod).mod != std_mod) break :ip_index .none;	4075	if (decl.getFileScope(zcu).mod != std_mod) break :ip_index .none;
4047	// We're in the std module.	4076	// We're in the std module.
4048	const std_file = (try mod.importPkg(std_mod)).file;	4077	const std_file_imported = try zcu.importPkg(std_mod);
4049	const std_decl = mod.declPtr(std_file.root_decl.unwrap().?);	4078	const std_file_root_decl_index = zcu.fileRootDecl(std_file_imported.file_index);
4050	const std_namespace = std_decl.getInnerNamespace(mod).?;	4079	const std_decl = zcu.declPtr(std_file_root_decl_index.unwrap().?);
		4080	const std_namespace = std_decl.getInnerNamespace(zcu).?;
4051	const builtin_str = try ip.getOrPutString(gpa, "builtin", .no_embedded_nulls);	4081	const builtin_str = try ip.getOrPutString(gpa, "builtin", .no_embedded_nulls);
4052	const builtin_decl = mod.declPtr(std_namespace.decls.getKeyAdapted(builtin_str, DeclAdapter{ .zcu = mod }) orelse break :ip_index .none);	4082	const builtin_decl = zcu.declPtr(std_namespace.decls.getKeyAdapted(builtin_str, DeclAdapter{ .zcu = zcu }) orelse break :ip_index .none);
4053	const builtin_namespace = builtin_decl.getInnerNamespaceIndex(mod).unwrap() orelse break :ip_index .none;	4083	const builtin_namespace = builtin_decl.getInnerNamespaceIndex(zcu).unwrap() orelse break :ip_index .none;
4054	if (decl.src_namespace != builtin_namespace) break :ip_index .none;	4084	if (decl.src_namespace != builtin_namespace) break :ip_index .none;
4055	// We're in builtin.zig. This could be a builtin we need to add to a specific InternPool index.	4085	// We're in builtin.zig. This could be a builtin we need to add to a specific InternPool index.
4056	for ([_][]const u8{	4086	for ([_][]const u8{
...	@@ -4083,7 +4113,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4083,7 +4113,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4083	break :ip_index .none;	4113	break :ip_index .none;
4084	};	4114	};
4085		4115
4086	mod.intern_pool.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .decl = decl_index }));	4116	zcu.intern_pool.removeDependenciesForDepender(gpa, AnalUnit.wrap(.{ .decl = decl_index }));
4087		4117
4088	decl.analysis = .in_progress;	4118	decl.analysis = .in_progress;
4089		4119
...	@@ -4094,7 +4124,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4094,7 +4124,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4094	defer comptime_err_ret_trace.deinit();	4124	defer comptime_err_ret_trace.deinit();
4095		4125
4096	var sema: Sema = .{	4126	var sema: Sema = .{
4097	.mod = mod,	4127	.mod = zcu,
4098	.gpa = gpa,	4128	.gpa = gpa,
4099	.arena = analysis_arena.allocator(),	4129	.arena = analysis_arena.allocator(),
4100	.code = zir,	4130	.code = zir,
...	@@ -4112,8 +4142,8 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4112,8 +4142,8 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4112		4142
4113	// Every Decl (other than file root Decls, which do not have a ZIR index) has a dependency on its own source.	4143	// Every Decl (other than file root Decls, which do not have a ZIR index) has a dependency on its own source.
4114	try sema.declareDependency(.{ .src_hash = try ip.trackZir(	4144	try sema.declareDependency(.{ .src_hash = try ip.trackZir(
4115	sema.gpa,	4145	gpa,
4116	decl.getFileScope(mod),	4146	decl.getFileScopeIndex(zcu),
4117	decl_inst,	4147	decl_inst,
4118	) });	4148	) });
4119		4149
...	@@ -4129,7 +4159,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4129,7 +4159,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4129	};	4159	};
4130	defer block_scope.instructions.deinit(gpa);	4160	defer block_scope.instructions.deinit(gpa);
4131		4161
4132	const decl_bodies = decl.zirBodies(mod);	4162	const decl_bodies = decl.zirBodies(zcu);
4133		4163
4134	const result_ref = try sema.resolveInlineBody(&block_scope, decl_bodies.value_body, decl_inst);	4164	const result_ref = try sema.resolveInlineBody(&block_scope, decl_bodies.value_body, decl_inst);
4135	// We'll do some other bits with the Sema. Clear the type target index just	4165	// We'll do some other bits with the Sema. Clear the type target index just
...	@@ -4141,22 +4171,22 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4141,22 +4171,22 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4141	const ty_src: LazySrcLoc = block_scope.src(.{ .node_offset_var_decl_ty = 0 });	4171	const ty_src: LazySrcLoc = block_scope.src(.{ .node_offset_var_decl_ty = 0 });
4142	const init_src: LazySrcLoc = block_scope.src(.{ .node_offset_var_decl_init = 0 });	4172	const init_src: LazySrcLoc = block_scope.src(.{ .node_offset_var_decl_init = 0 });
4143	const decl_val = try sema.resolveFinalDeclValue(&block_scope, init_src, result_ref);	4173	const decl_val = try sema.resolveFinalDeclValue(&block_scope, init_src, result_ref);
4144	const decl_ty = decl_val.typeOf(mod);	4174	const decl_ty = decl_val.typeOf(zcu);
4145		4175
4146	// Note this resolves the type of the Decl, not the value; if this Decl	4176	// Note this resolves the type of the Decl, not the value; if this Decl
4147	// is a struct, for example, this resolves `type` (which needs no resolution),	4177	// is a struct, for example, this resolves `type` (which needs no resolution),
4148	// not the struct itself.	4178	// not the struct itself.
4149	try decl_ty.resolveLayout(mod);	4179	try decl_ty.resolveLayout(zcu);
4150		4180
4151	if (decl.kind == .@"usingnamespace") {	4181	if (decl.kind == .@"usingnamespace") {
4152	if (!decl_ty.eql(Type.type, mod)) {	4182	if (!decl_ty.eql(Type.type, zcu)) {
4153	return sema.fail(&block_scope, ty_src, "expected type, found {}", .{	4183	return sema.fail(&block_scope, ty_src, "expected type, found {}", .{
4154	decl_ty.fmt(mod),	4184	decl_ty.fmt(zcu),
4155	});	4185	});
4156	}	4186	}
4157	const ty = decl_val.toType();	4187	const ty = decl_val.toType();
4158	if (ty.getNamespace(mod) == null) {	4188	if (ty.getNamespace(zcu) == null) {
4159	return sema.fail(&block_scope, ty_src, "type {} has no namespace", .{ty.fmt(mod)});	4189	return sema.fail(&block_scope, ty_src, "type {} has no namespace", .{ty.fmt(zcu)});
4160	}	4190	}
4161		4191
4162	decl.val = ty.toValue();	4192	decl.val = ty.toValue();
...	@@ -4194,7 +4224,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4194,7 +4224,7 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4194	.func => \|func\| {	4224	.func => \|func\| {
4195	decl.owns_tv = func.owner_decl == decl_index;	4225	decl.owns_tv = func.owner_decl == decl_index;
4196	queue_linker_work = false;	4226	queue_linker_work = false;
4197	is_inline = decl.owns_tv and decl_ty.fnCallingConvention(mod) == .Inline;	4227	is_inline = decl.owns_tv and decl_ty.fnCallingConvention(zcu) == .Inline;
4198	is_func = decl.owns_tv;	4228	is_func = decl.owns_tv;
4199	},	4229	},
4200		4230
...	@@ -4246,10 +4276,10 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4246,10 +4276,10 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4246	decl.analysis = .complete;	4276	decl.analysis = .complete;
4247		4277
4248	const result: SemaDeclResult = if (old_has_tv) .{	4278	const result: SemaDeclResult = if (old_has_tv) .{
4249	.invalidate_decl_val = !decl_ty.eql(old_ty, mod) or	4279	.invalidate_decl_val = !decl_ty.eql(old_ty, zcu) or
4250	!decl.val.eql(old_val, decl_ty, mod) or	4280	!decl.val.eql(old_val, decl_ty, zcu) or
4251	is_inline != old_is_inline,	4281	is_inline != old_is_inline,
4252	.invalidate_decl_ref = !decl_ty.eql(old_ty, mod) or	4282	.invalidate_decl_ref = !decl_ty.eql(old_ty, zcu) or
4253	decl.alignment != old_align or	4283	decl.alignment != old_align or
4254	decl.@"linksection" != old_linksection or	4284	decl.@"linksection" != old_linksection or
4255	decl.@"addrspace" != old_addrspace or	4285	decl.@"addrspace" != old_addrspace or
...	@@ -4263,12 +4293,12 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4263,12 +4293,12 @@ fn semaDecl(mod: *Module, decl_index: Decl.Index) !SemaDeclResult {
4263	if (has_runtime_bits) {	4293	if (has_runtime_bits) {
4264	// Needed for codegen_decl which will call updateDecl and then the	4294	// Needed for codegen_decl which will call updateDecl and then the
4265	// codegen backend wants full access to the Decl Type.	4295	// codegen backend wants full access to the Decl Type.
4266	try decl_ty.resolveFully(mod);	4296	try decl_ty.resolveFully(zcu);
4267		4297
4268	try mod.comp.work_queue.writeItem(.{ .codegen_decl = decl_index });	4298	try zcu.comp.work_queue.writeItem(.{ .codegen_decl = decl_index });
4269		4299
4270	if (result.invalidate_decl_ref and mod.emit_h != null) {	4300	if (result.invalidate_decl_ref and zcu.emit_h != null) {
4271	try mod.comp.work_queue.writeItem(.{ .emit_h_decl = decl_index });	4301	try zcu.comp.work_queue.writeItem(.{ .emit_h_decl = decl_index });
4272	}	4302	}
4273	}	4303	}
4274		4304
...	@@ -4322,6 +4352,7 @@ fn semaAnonOwnerDecl(zcu: *Zcu, decl_index: Decl.Index) !SemaDeclResult {	...	@@ -4322,6 +4352,7 @@ fn semaAnonOwnerDecl(zcu: *Zcu, decl_index: Decl.Index) !SemaDeclResult {
4322		4352
4323	pub const ImportFileResult = struct {	4353	pub const ImportFileResult = struct {
4324	file: *File,	4354	file: *File,
		4355	file_index: File.Index,
4325	is_new: bool,	4356	is_new: bool,
4326	is_pkg: bool,	4357	is_pkg: bool,
4327	};	4358	};
...	@@ -4344,20 +4375,27 @@ pub fn importPkg(zcu: Zcu, mod: Package.Module) !ImportFileResult {	...	@@ -4344,20 +4375,27 @@ pub fn importPkg(zcu: Zcu, mod: Package.Module) !ImportFileResult {
4344	errdefer _ = zcu.import_table.pop();	4375	errdefer _ = zcu.import_table.pop();
4345	if (gop.found_existing) {	4376	if (gop.found_existing) {
4346	try gop.value_ptr..addReference(zcu., .{ .root = mod });	4377	try gop.value_ptr..addReference(zcu., .{ .root = mod });
4347	return ImportFileResult{	4378	return .{
4348	.file = gop.value_ptr.*,	4379	.file = gop.value_ptr.*,
		4380	.file_index = @enumFromInt(gop.index),
4349	.is_new = false,	4381	.is_new = false,
4350	.is_pkg = true,	4382	.is_pkg = true,
4351	};	4383	};
4352	}	4384	}
4353		4385
		4386	const ip = &zcu.intern_pool;
		4387
		4388	try ip.files.ensureUnusedCapacity(gpa, 1);
		4389
4354	if (mod.builtin_file) \|builtin_file\| {	4390	if (mod.builtin_file) \|builtin_file\| {
4355	keep_resolved_path = true; // It's now owned by import_table.	4391	keep_resolved_path = true; // It's now owned by import_table.
4356	gop.value_ptr.* = builtin_file;	4392	gop.value_ptr.* = builtin_file;
4357	try builtin_file.addReference(zcu.*, .{ .root = mod });	4393	try builtin_file.addReference(zcu.*, .{ .root = mod });
4358	try zcu.path_digest_map.put(gpa, builtin_file.path_digest, {});	4394	const path_digest = computePathDigest(zcu, mod, builtin_file.sub_file_path);
		4395	ip.files.putAssumeCapacityNoClobber(path_digest, .none);
4359	return .{	4396	return .{
4360	.file = builtin_file,	4397	.file = builtin_file,
		4398	.file_index = @enumFromInt(ip.files.entries.len - 1),
4361	.is_new = false,	4399	.is_new = false,
4362	.is_pkg = true,	4400	.is_pkg = true,
4363	};	4401	};
...	@@ -4382,43 +4420,36 @@ pub fn importPkg(zcu: Zcu, mod: Package.Module) !ImportFileResult {	...	@@ -4382,43 +4420,36 @@ pub fn importPkg(zcu: Zcu, mod: Package.Module) !ImportFileResult {
4382	.zir = undefined,	4420	.zir = undefined,
4383	.status = .never_loaded,	4421	.status = .never_loaded,
4384	.mod = mod,	4422	.mod = mod,
4385	.root_decl = .none,
4386	.path_digest = digest: {
4387	const want_local_cache = mod == zcu.main_mod;
4388	var path_hash: Cache.HashHelper = .{};
4389	path_hash.addBytes(build_options.version);
4390	path_hash.add(builtin.zig_backend);
4391	if (!want_local_cache) {
4392	path_hash.addOptionalBytes(mod.root.root_dir.path);
4393	path_hash.addBytes(mod.root.sub_path);
4394	}
4395	path_hash.addBytes(sub_file_path);
4396	var bin: Cache.BinDigest = undefined;
4397	path_hash.hasher.final(&bin);
4398	break :digest bin;
4399	},
4400	};	4423	};
		4424
		4425	const path_digest = computePathDigest(zcu, mod, sub_file_path);
		4426
4401	try new_file.addReference(zcu.*, .{ .root = mod });	4427	try new_file.addReference(zcu.*, .{ .root = mod });
4402	try zcu.path_digest_map.put(gpa, new_file.path_digest, {});	4428	ip.files.putAssumeCapacityNoClobber(path_digest, .none);
4403	return ImportFileResult{	4429	return .{
4404	.file = new_file,	4430	.file = new_file,
		4431	.file_index = @enumFromInt(ip.files.entries.len - 1),
4405	.is_new = true,	4432	.is_new = true,
4406	.is_pkg = true,	4433	.is_pkg = true,
4407	};	4434	};
4408	}	4435	}
4409		4436
		4437	/// Called from a worker thread during AstGen.
		4438	/// Also called from Sema during semantic analysis.
4410	pub fn importFile(	4439	pub fn importFile(
4411	zcu: *Zcu,	4440	zcu: *Zcu,
4412	cur_file: *File,	4441	cur_file: *File,
4413	import_string: []const u8,	4442	import_string: []const u8,
4414	) !ImportFileResult {	4443	) !ImportFileResult {
		4444	const mod = cur_file.mod;
		4445
4415	if (std.mem.eql(u8, import_string, "std")) {	4446	if (std.mem.eql(u8, import_string, "std")) {
4416	return zcu.importPkg(zcu.std_mod);	4447	return zcu.importPkg(zcu.std_mod);
4417	}	4448	}
4418	if (std.mem.eql(u8, import_string, "root")) {	4449	if (std.mem.eql(u8, import_string, "root")) {
4419	return zcu.importPkg(zcu.root_mod);	4450	return zcu.importPkg(zcu.root_mod);
4420	}	4451	}
4421	if (cur_file.mod.deps.get(import_string)) \|pkg\| {	4452	if (mod.deps.get(import_string)) \|pkg\| {
4422	return zcu.importPkg(pkg);	4453	return zcu.importPkg(pkg);
4423	}	4454	}
4424	if (!mem.endsWith(u8, import_string, ".zig")) {	4455	if (!mem.endsWith(u8, import_string, ".zig")) {
...	@@ -4430,8 +4461,8 @@ pub fn importFile(	...	@@ -4430,8 +4461,8 @@ pub fn importFile(
4430	// an import refers to the same as another, despite different relative paths	4461	// an import refers to the same as another, despite different relative paths
4431	// or differently mapped package names.	4462	// or differently mapped package names.
4432	const resolved_path = try std.fs.path.resolve(gpa, &.{	4463	const resolved_path = try std.fs.path.resolve(gpa, &.{
4433	cur_file.mod.root.root_dir.path orelse ".",	4464	mod.root.root_dir.path orelse ".",
4434	cur_file.mod.root.sub_path,	4465	mod.root.sub_path,
4435	cur_file.sub_file_path,	4466	cur_file.sub_file_path,
4436	"..",	4467	"..",
4437	import_string,	4468	import_string,
...	@@ -4442,18 +4473,23 @@ pub fn importFile(	...	@@ -4442,18 +4473,23 @@ pub fn importFile(
4442		4473
4443	const gop = try zcu.import_table.getOrPut(gpa, resolved_path);	4474	const gop = try zcu.import_table.getOrPut(gpa, resolved_path);
4444	errdefer _ = zcu.import_table.pop();	4475	errdefer _ = zcu.import_table.pop();
4445	if (gop.found_existing) return ImportFileResult{	4476	if (gop.found_existing) return .{
4446	.file = gop.value_ptr.*,	4477	.file = gop.value_ptr.*,
		4478	.file_index = @enumFromInt(gop.index),
4447	.is_new = false,	4479	.is_new = false,
4448	.is_pkg = false,	4480	.is_pkg = false,
4449	};	4481	};
4450		4482
		4483	const ip = &zcu.intern_pool;
		4484
		4485	try ip.files.ensureUnusedCapacity(gpa, 1);
		4486
4451	const new_file = try gpa.create(File);	4487	const new_file = try gpa.create(File);
4452	errdefer gpa.destroy(new_file);	4488	errdefer gpa.destroy(new_file);
4453		4489
4454	const resolved_root_path = try std.fs.path.resolve(gpa, &.{	4490	const resolved_root_path = try std.fs.path.resolve(gpa, &.{
4455	cur_file.mod.root.root_dir.path orelse ".",	4491	mod.root.root_dir.path orelse ".",
4456	cur_file.mod.root.sub_path,	4492	mod.root.sub_path,
4457	});	4493	});
4458	defer gpa.free(resolved_root_path);	4494	defer gpa.free(resolved_root_path);
4459		4495
...	@@ -4484,26 +4520,14 @@ pub fn importFile(	...	@@ -4484,26 +4520,14 @@ pub fn importFile(
4484	.tree = undefined,	4520	.tree = undefined,
4485	.zir = undefined,	4521	.zir = undefined,
4486	.status = .never_loaded,	4522	.status = .never_loaded,
4487	.mod = cur_file.mod,	4523	.mod = mod,
4488	.root_decl = .none,
4489	.path_digest = digest: {
4490	const want_local_cache = cur_file.mod == zcu.main_mod;
4491	var path_hash: Cache.HashHelper = .{};
4492	path_hash.addBytes(build_options.version);
4493	path_hash.add(builtin.zig_backend);
4494	if (!want_local_cache) {
4495	path_hash.addOptionalBytes(cur_file.mod.root.root_dir.path);
4496	path_hash.addBytes(cur_file.mod.root.sub_path);
4497	}
4498	path_hash.addBytes(sub_file_path);
4499	var bin: Cache.BinDigest = undefined;
4500	path_hash.hasher.final(&bin);
4501	break :digest bin;
4502	},
4503	};	4524	};
4504	try zcu.path_digest_map.put(gpa, new_file.path_digest, {});	4525
4505	return ImportFileResult{	4526	const path_digest = computePathDigest(zcu, mod, sub_file_path);
		4527	ip.files.putAssumeCapacityNoClobber(path_digest, .none);
		4528	return .{
4506	.file = new_file,	4529	.file = new_file,
		4530	.file_index = @enumFromInt(ip.files.entries.len - 1),
4507	.is_new = true,	4531	.is_new = true,
4508	.is_pkg = false,	4532	.is_pkg = false,
4509	};	4533	};
...	@@ -4581,6 +4605,21 @@ pub fn embedFile(	...	@@ -4581,6 +4605,21 @@ pub fn embedFile(
4581	return newEmbedFile(mod, cur_file.mod, sub_file_path, resolved_path, gop.value_ptr, src_loc);	4605	return newEmbedFile(mod, cur_file.mod, sub_file_path, resolved_path, gop.value_ptr, src_loc);
4582	}	4606	}
4583		4607
		4608	fn computePathDigest(zcu: Zcu, mod: Package.Module, sub_file_path: []const u8) Cache.BinDigest {
		4609	const want_local_cache = mod == zcu.main_mod;
		4610	var path_hash: Cache.HashHelper = .{};
		4611	path_hash.addBytes(build_options.version);
		4612	path_hash.add(builtin.zig_backend);
		4613	if (!want_local_cache) {
		4614	path_hash.addOptionalBytes(mod.root.root_dir.path);
		4615	path_hash.addBytes(mod.root.sub_path);
		4616	}
		4617	path_hash.addBytes(sub_file_path);
		4618	var bin: Cache.BinDigest = undefined;
		4619	path_hash.hasher.final(&bin);
		4620	return bin;
		4621	}
		4622
4584	/// https://github.com/ziglang/zig/issues/14307	4623	/// https://github.com/ziglang/zig/issues/14307
4585	fn newEmbedFile(	4624	fn newEmbedFile(
4586	mod: *Module,	4625	mod: *Module,
...	@@ -4765,7 +4804,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void	...	@@ -4765,7 +4804,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void
4765	const namespace_index = iter.namespace_index;	4804	const namespace_index = iter.namespace_index;
4766	const namespace = zcu.namespacePtr(namespace_index);	4805	const namespace = zcu.namespacePtr(namespace_index);
4767	const gpa = zcu.gpa;	4806	const gpa = zcu.gpa;
4768	const zir = namespace.file_scope.zir;	4807	const zir = namespace.fileScope(zcu).zir;
4769	const ip = &zcu.intern_pool;	4808	const ip = &zcu.intern_pool;
4770		4809
4771	const inst_data = zir.instructions.items(.data)[@intFromEnum(decl_inst)].declaration;	4810	const inst_data = zir.instructions.items(.data)[@intFromEnum(decl_inst)].declaration;
...	@@ -4848,7 +4887,8 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void	...	@@ -4848,7 +4887,8 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void
4848	else => {},	4887	else => {},
4849	}	4888	}
4850		4889
4851	const tracked_inst = try ip.trackZir(gpa, iter.parent_decl.getFileScope(zcu), decl_inst);	4890	const parent_file_scope_index = iter.parent_decl.getFileScopeIndex(zcu);
		4891	const tracked_inst = try ip.trackZir(gpa, parent_file_scope_index, decl_inst);
4852		4892
4853	// We create a Decl for it regardless of analysis status.	4893	// We create a Decl for it regardless of analysis status.
4854		4894
...	@@ -4878,7 +4918,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void	...	@@ -4878,7 +4918,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void
4878	namespace.decls.putAssumeCapacityNoClobberContext(decl_index, {}, .{ .zcu = zcu });	4918	namespace.decls.putAssumeCapacityNoClobberContext(decl_index, {}, .{ .zcu = zcu });
4879		4919
4880	const comp = zcu.comp;	4920	const comp = zcu.comp;
4881	const decl_mod = namespace.file_scope.mod;	4921	const decl_mod = namespace.fileScope(zcu).mod;
4882	const want_analysis = declaration.flags.is_export or switch (kind) {	4922	const want_analysis = declaration.flags.is_export or switch (kind) {
4883	.anon => unreachable,	4923	.anon => unreachable,
4884	.@"comptime" => true,	4924	.@"comptime" => true,
...	@@ -4908,7 +4948,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void	...	@@ -4908,7 +4948,7 @@ fn scanDecl(iter: *ScanDeclIter, decl_inst: Zir.Inst.Index) Allocator.Error!void
4908	// re-analysis for us if necessary.	4948	// re-analysis for us if necessary.
4909	if (prev_exported != declaration.flags.is_export or decl.analysis == .unreferenced) {	4949	if (prev_exported != declaration.flags.is_export or decl.analysis == .unreferenced) {
4910	log.debug("scanDecl queue analyze_decl file='{s}' decl_name='{}' decl_index={d}", .{	4950	log.debug("scanDecl queue analyze_decl file='{s}' decl_name='{}' decl_index={d}", .{
4911	namespace.file_scope.sub_file_path, decl_name.fmt(ip), decl_index,	4951	namespace.fileScope(zcu).sub_file_path, decl_name.fmt(ip), decl_index,
4912	});	4952	});
4913	comp.work_queue.writeItemAssumeCapacity(.{ .analyze_decl = decl_index });	4953	comp.work_queue.writeItemAssumeCapacity(.{ .analyze_decl = decl_index });
4914	}	4954	}
...	@@ -5512,77 +5552,78 @@ fn handleUpdateExports(	...	@@ -5512,77 +5552,78 @@ fn handleUpdateExports(
5512	}	5552	}
5513		5553
5514	pub fn populateTestFunctions(	5554	pub fn populateTestFunctions(
5515	mod: *Module,	5555	zcu: *Zcu,
5516	main_progress_node: std.Progress.Node,	5556	main_progress_node: std.Progress.Node,
5517	) !void {	5557	) !void {
5518	const gpa = mod.gpa;	5558	const gpa = zcu.gpa;
5519	const ip = &mod.intern_pool;	5559	const ip = &zcu.intern_pool;
5520	const builtin_mod = mod.root_mod.getBuiltinDependency();	5560	const builtin_mod = zcu.root_mod.getBuiltinDependency();
5521	const builtin_file = (mod.importPkg(builtin_mod) catch unreachable).file;	5561	const builtin_file_index = (zcu.importPkg(builtin_mod) catch unreachable).file_index;
5522	const root_decl = mod.declPtr(builtin_file.root_decl.unwrap().?);	5562	const root_decl_index = zcu.fileRootDecl(builtin_file_index);
5523	const builtin_namespace = mod.namespacePtr(root_decl.src_namespace);	5563	const root_decl = zcu.declPtr(root_decl_index.unwrap().?);
		5564	const builtin_namespace = zcu.namespacePtr(root_decl.src_namespace);
5524	const test_functions_str = try ip.getOrPutString(gpa, "test_functions", .no_embedded_nulls);	5565	const test_functions_str = try ip.getOrPutString(gpa, "test_functions", .no_embedded_nulls);
5525	const decl_index = builtin_namespace.decls.getKeyAdapted(	5566	const decl_index = builtin_namespace.decls.getKeyAdapted(
5526	test_functions_str,	5567	test_functions_str,
5527	DeclAdapter{ .zcu = mod },	5568	DeclAdapter{ .zcu = zcu },
5528	).?;	5569	).?;
5529	{	5570	{
5530	// We have to call `ensureDeclAnalyzed` here in case `builtin.test_functions`	5571	// We have to call `ensureDeclAnalyzed` here in case `builtin.test_functions`
5531	// was not referenced by start code.	5572	// was not referenced by start code.
5532	mod.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);	5573	zcu.sema_prog_node = main_progress_node.start("Semantic Analysis", 0);
5533	defer {	5574	defer {
5534	mod.sema_prog_node.end();	5575	zcu.sema_prog_node.end();
5535	mod.sema_prog_node = undefined;	5576	zcu.sema_prog_node = undefined;
5536	}	5577	}
5537	try mod.ensureDeclAnalyzed(decl_index);	5578	try zcu.ensureDeclAnalyzed(decl_index);
5538	}	5579	}
5539		5580
5540	const decl = mod.declPtr(decl_index);	5581	const decl = zcu.declPtr(decl_index);
5541	const test_fn_ty = decl.typeOf(mod).slicePtrFieldType(mod).childType(mod);	5582	const test_fn_ty = decl.typeOf(zcu).slicePtrFieldType(zcu).childType(zcu);
5542		5583
5543	const array_anon_decl: InternPool.Key.Ptr.BaseAddr.AnonDecl = array: {	5584	const array_anon_decl: InternPool.Key.Ptr.BaseAddr.AnonDecl = array: {
5544	// Add mod.test_functions to an array decl then make the test_functions	5585	// Add zcu.test_functions to an array decl then make the test_functions
5545	// decl reference it as a slice.	5586	// decl reference it as a slice.
5546	const test_fn_vals = try gpa.alloc(InternPool.Index, mod.test_functions.count());	5587	const test_fn_vals = try gpa.alloc(InternPool.Index, zcu.test_functions.count());
5547	defer gpa.free(test_fn_vals);	5588	defer gpa.free(test_fn_vals);
5548		5589
5549	for (test_fn_vals, mod.test_functions.keys()) \|*test_fn_val, test_decl_index\| {	5590	for (test_fn_vals, zcu.test_functions.keys()) \|*test_fn_val, test_decl_index\| {
5550	const test_decl = mod.declPtr(test_decl_index);	5591	const test_decl = zcu.declPtr(test_decl_index);
5551	const test_decl_name = try test_decl.fullyQualifiedName(mod);	5592	const test_decl_name = try test_decl.fullyQualifiedName(zcu);
5552	const test_decl_name_len = test_decl_name.length(ip);	5593	const test_decl_name_len = test_decl_name.length(ip);
5553	const test_name_anon_decl: InternPool.Key.Ptr.BaseAddr.AnonDecl = n: {	5594	const test_name_anon_decl: InternPool.Key.Ptr.BaseAddr.AnonDecl = n: {
5554	const test_name_ty = try mod.arrayType(.{	5595	const test_name_ty = try zcu.arrayType(.{
5555	.len = test_decl_name_len,	5596	.len = test_decl_name_len,
5556	.child = .u8_type,	5597	.child = .u8_type,
5557	});	5598	});
5558	const test_name_val = try mod.intern(.{ .aggregate = .{	5599	const test_name_val = try zcu.intern(.{ .aggregate = .{
5559	.ty = test_name_ty.toIntern(),	5600	.ty = test_name_ty.toIntern(),
5560	.storage = .{ .bytes = test_decl_name.toString() },	5601	.storage = .{ .bytes = test_decl_name.toString() },
5561	} });	5602	} });
5562	break :n .{	5603	break :n .{
5563	.orig_ty = (try mod.singleConstPtrType(test_name_ty)).toIntern(),	5604	.orig_ty = (try zcu.singleConstPtrType(test_name_ty)).toIntern(),
5564	.val = test_name_val,	5605	.val = test_name_val,
5565	};	5606	};
5566	};	5607	};
5567		5608
5568	const test_fn_fields = .{	5609	const test_fn_fields = .{
5569	// name	5610	// name
5570	try mod.intern(.{ .slice = .{	5611	try zcu.intern(.{ .slice = .{
5571	.ty = .slice_const_u8_type,	5612	.ty = .slice_const_u8_type,
5572	.ptr = try mod.intern(.{ .ptr = .{	5613	.ptr = try zcu.intern(.{ .ptr = .{
5573	.ty = .manyptr_const_u8_type,	5614	.ty = .manyptr_const_u8_type,
5574	.base_addr = .{ .anon_decl = test_name_anon_decl },	5615	.base_addr = .{ .anon_decl = test_name_anon_decl },
5575	.byte_offset = 0,	5616	.byte_offset = 0,
5576	} }),	5617	} }),
5577	.len = try mod.intern(.{ .int = .{	5618	.len = try zcu.intern(.{ .int = .{
5578	.ty = .usize_type,	5619	.ty = .usize_type,
5579	.storage = .{ .u64 = test_decl_name_len },	5620	.storage = .{ .u64 = test_decl_name_len },
5580	} }),	5621	} }),
5581	} }),	5622	} }),
5582	// func	5623	// func
5583	try mod.intern(.{ .ptr = .{	5624	try zcu.intern(.{ .ptr = .{
5584	.ty = try mod.intern(.{ .ptr_type = .{	5625	.ty = try zcu.intern(.{ .ptr_type = .{
5585	.child = test_decl.typeOf(mod).toIntern(),	5626	.child = test_decl.typeOf(zcu).toIntern(),
5586	.flags = .{	5627	.flags = .{
5587	.is_const = true,	5628	.is_const = true,
5588	},	5629	},
...	@@ -5591,29 +5632,29 @@ pub fn populateTestFunctions(	...	@@ -5591,29 +5632,29 @@ pub fn populateTestFunctions(
5591	.byte_offset = 0,	5632	.byte_offset = 0,
5592	} }),	5633	} }),
5593	};	5634	};
5594	test_fn_val.* = try mod.intern(.{ .aggregate = .{	5635	test_fn_val.* = try zcu.intern(.{ .aggregate = .{
5595	.ty = test_fn_ty.toIntern(),	5636	.ty = test_fn_ty.toIntern(),
5596	.storage = .{ .elems = &test_fn_fields },	5637	.storage = .{ .elems = &test_fn_fields },
5597	} });	5638	} });
5598	}	5639	}
5599		5640
5600	const array_ty = try mod.arrayType(.{	5641	const array_ty = try zcu.arrayType(.{
5601	.len = test_fn_vals.len,	5642	.len = test_fn_vals.len,
5602	.child = test_fn_ty.toIntern(),	5643	.child = test_fn_ty.toIntern(),
5603	.sentinel = .none,	5644	.sentinel = .none,
5604	});	5645	});
5605	const array_val = try mod.intern(.{ .aggregate = .{	5646	const array_val = try zcu.intern(.{ .aggregate = .{
5606	.ty = array_ty.toIntern(),	5647	.ty = array_ty.toIntern(),
5607	.storage = .{ .elems = test_fn_vals },	5648	.storage = .{ .elems = test_fn_vals },
5608	} });	5649	} });
5609	break :array .{	5650	break :array .{
5610	.orig_ty = (try mod.singleConstPtrType(array_ty)).toIntern(),	5651	.orig_ty = (try zcu.singleConstPtrType(array_ty)).toIntern(),
5611	.val = array_val,	5652	.val = array_val,
5612	};	5653	};
5613	};	5654	};
5614		5655
5615	{	5656	{
5616	const new_ty = try mod.ptrType(.{	5657	const new_ty = try zcu.ptrType(.{
5617	.child = test_fn_ty.toIntern(),	5658	.child = test_fn_ty.toIntern(),
5618	.flags = .{	5659	.flags = .{
5619	.is_const = true,	5660	.is_const = true,
...	@@ -5621,14 +5662,14 @@ pub fn populateTestFunctions(	...	@@ -5621,14 +5662,14 @@ pub fn populateTestFunctions(
5621	},	5662	},
5622	});	5663	});
5623	const new_val = decl.val;	5664	const new_val = decl.val;
5624	const new_init = try mod.intern(.{ .slice = .{	5665	const new_init = try zcu.intern(.{ .slice = .{
5625	.ty = new_ty.toIntern(),	5666	.ty = new_ty.toIntern(),
5626	.ptr = try mod.intern(.{ .ptr = .{	5667	.ptr = try zcu.intern(.{ .ptr = .{
5627	.ty = new_ty.slicePtrFieldType(mod).toIntern(),	5668	.ty = new_ty.slicePtrFieldType(zcu).toIntern(),
5628	.base_addr = .{ .anon_decl = array_anon_decl },	5669	.base_addr = .{ .anon_decl = array_anon_decl },
5629	.byte_offset = 0,	5670	.byte_offset = 0,
5630	} }),	5671	} }),
5631	.len = (try mod.intValue(Type.usize, mod.test_functions.count())).toIntern(),	5672	.len = (try zcu.intValue(Type.usize, zcu.test_functions.count())).toIntern(),
5632	} });	5673	} });
5633	ip.mutateVarInit(decl.val.toIntern(), new_init);	5674	ip.mutateVarInit(decl.val.toIntern(), new_init);
5634		5675
...	@@ -5638,13 +5679,13 @@ pub fn populateTestFunctions(	...	@@ -5638,13 +5679,13 @@ pub fn populateTestFunctions(
5638	decl.has_tv = true;	5679	decl.has_tv = true;
5639	}	5680	}
5640	{	5681	{
5641	mod.codegen_prog_node = main_progress_node.start("Code Generation", 0);	5682	zcu.codegen_prog_node = main_progress_node.start("Code Generation", 0);
5642	defer {	5683	defer {
5643	mod.codegen_prog_node.end();	5684	zcu.codegen_prog_node.end();
5644	mod.codegen_prog_node = undefined;	5685	zcu.codegen_prog_node = undefined;
5645	}	5686	}
5646		5687
5647	try mod.linkerUpdateDecl(decl_index);	5688	try zcu.linkerUpdateDecl(decl_index);
5648	}	5689	}
5649	}	5690	}
5650		5691
...	@@ -5684,31 +5725,35 @@ pub fn linkerUpdateDecl(zcu: *Zcu, decl_index: Decl.Index) !void {	...	@@ -5684,31 +5725,35 @@ pub fn linkerUpdateDecl(zcu: *Zcu, decl_index: Decl.Index) !void {
5684	}	5725	}
5685		5726
5686	fn reportRetryableFileError(	5727	fn reportRetryableFileError(
5687	mod: *Module,	5728	zcu: *Zcu,
5688	file: *File,	5729	file_index: File.Index,
5689	comptime format: []const u8,	5730	comptime format: []const u8,
5690	args: anytype,	5731	args: anytype,
5691	) error{OutOfMemory}!void {	5732	) error{OutOfMemory}!void {
		5733	const gpa = zcu.gpa;
		5734	const ip = &zcu.intern_pool;
		5735
		5736	const file = zcu.fileByIndex(file_index);
5692	file.status = .retryable_failure;	5737	file.status = .retryable_failure;
5693		5738
5694	const err_msg = try ErrorMsg.create(	5739	const err_msg = try ErrorMsg.create(
5695	mod.gpa,	5740	gpa,
5696	.{	5741	.{
5697	.base_node_inst = try mod.intern_pool.trackZir(mod.gpa, file, .main_struct_inst),	5742	.base_node_inst = try ip.trackZir(gpa, file_index, .main_struct_inst),
5698	.offset = .entire_file,	5743	.offset = .entire_file,
5699	},	5744	},
5700	format,	5745	format,
5701	args,	5746	args,
5702	);	5747	);
5703	errdefer err_msg.destroy(mod.gpa);	5748	errdefer err_msg.destroy(gpa);
5704		5749
5705	mod.comp.mutex.lock();	5750	zcu.comp.mutex.lock();
5706	defer mod.comp.mutex.unlock();	5751	defer zcu.comp.mutex.unlock();
5707		5752
5708	const gop = try mod.failed_files.getOrPut(mod.gpa, file);	5753	const gop = try zcu.failed_files.getOrPut(gpa, file);
5709	if (gop.found_existing) {	5754	if (gop.found_existing) {
5710	if (gop.value_ptr.*) \|old_err_msg\| {	5755	if (gop.value_ptr.*) \|old_err_msg\| {
5711	old_err_msg.destroy(mod.gpa);	5756	old_err_msg.destroy(gpa);
5712	}	5757	}
5713	}	5758	}
5714	gop.value_ptr.* = err_msg;	5759	gop.value_ptr.* = err_msg;
...	@@ -6528,8 +6573,9 @@ pub fn getBuiltin(zcu: *Zcu, name: []const u8) Allocator.Error!Air.Inst.Ref {	...	@@ -6528,8 +6573,9 @@ pub fn getBuiltin(zcu: *Zcu, name: []const u8) Allocator.Error!Air.Inst.Ref {
6528	pub fn getBuiltinDecl(zcu: *Zcu, name: []const u8) Allocator.Error!InternPool.DeclIndex {	6573	pub fn getBuiltinDecl(zcu: *Zcu, name: []const u8) Allocator.Error!InternPool.DeclIndex {
6529	const gpa = zcu.gpa;	6574	const gpa = zcu.gpa;
6530	const ip = &zcu.intern_pool;	6575	const ip = &zcu.intern_pool;
6531	const std_file = (zcu.importPkg(zcu.std_mod) catch @panic("failed to import lib/std.zig")).file;	6576	const std_file_imported = zcu.importPkg(zcu.std_mod) catch @panic("failed to import lib/std.zig");
6532	const std_namespace = zcu.declPtr(std_file.root_decl.unwrap().?).getOwnedInnerNamespace(zcu).?;	6577	const std_file_root_decl = zcu.fileRootDecl(std_file_imported.file_index).unwrap().?;
		6578	const std_namespace = zcu.declPtr(std_file_root_decl).getOwnedInnerNamespace(zcu).?;
6533	const builtin_str = try ip.getOrPutString(gpa, "builtin", .no_embedded_nulls);	6579	const builtin_str = try ip.getOrPutString(gpa, "builtin", .no_embedded_nulls);
6534	const builtin_decl = std_namespace.decls.getKeyAdapted(builtin_str, Zcu.DeclAdapter{ .zcu = zcu }) orelse @panic("lib/std.zig is corrupt and missing 'builtin'");	6580	const builtin_decl = std_namespace.decls.getKeyAdapted(builtin_str, Zcu.DeclAdapter{ .zcu = zcu }) orelse @panic("lib/std.zig is corrupt and missing 'builtin'");
6535	zcu.ensureDeclAnalyzed(builtin_decl) catch @panic("std.builtin is corrupt");	6581	zcu.ensureDeclAnalyzed(builtin_decl) catch @panic("std.builtin is corrupt");
...	@@ -6544,3 +6590,23 @@ pub fn getBuiltinType(zcu: *Zcu, name: []const u8) Allocator.Error!Type {	...	@@ -6544,3 +6590,23 @@ pub fn getBuiltinType(zcu: *Zcu, name: []const u8) Allocator.Error!Type {
6544	ty.resolveFully(zcu) catch @panic("std.builtin is corrupt");	6590	ty.resolveFully(zcu) catch @panic("std.builtin is corrupt");
6545	return ty;	6591	return ty;
6546	}	6592	}
		6593
		6594	pub fn fileByIndex(zcu: const Zcu, i: File.Index) File {
		6595	return zcu.import_table.values()[@intFromEnum(i)];
		6596	}
		6597
		6598	/// Returns the `Decl` of the struct that represents this `File`.
		6599	pub fn fileRootDecl(zcu: *const Zcu, i: File.Index) Decl.OptionalIndex {
		6600	const ip = &zcu.intern_pool;
		6601	return ip.files.values()[@intFromEnum(i)];
		6602	}
		6603
		6604	pub fn setFileRootDecl(zcu: *Zcu, i: File.Index, root_decl: Decl.OptionalIndex) void {
		6605	const ip = &zcu.intern_pool;
		6606	ip.files.values()[@intFromEnum(i)] = root_decl;
		6607	}
		6608
		6609	pub fn filePathDigest(zcu: *const Zcu, i: File.Index) Cache.BinDigest {
		6610	const ip = &zcu.intern_pool;
		6611	return ip.files.keys()[@intFromEnum(i)];
		6612	}

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

...	@@ -345,7 +345,7 @@ pub fn generate(	...	@@ -345,7 +345,7 @@ pub fn generate(
345	assert(fn_owner_decl.has_tv);	345	assert(fn_owner_decl.has_tv);
346	const fn_type = fn_owner_decl.typeOf(zcu);	346	const fn_type = fn_owner_decl.typeOf(zcu);
347	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	347	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
348	const target = &namespace.file_scope.mod.resolved_target.result;	348	const target = &namespace.fileScope(zcu).mod.resolved_target.result;
349		349
350	var branch_stack = std.ArrayList(Branch).init(gpa);	350	var branch_stack = std.ArrayList(Branch).init(gpa);
351	defer {	351	defer {

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

...	@@ -352,7 +352,7 @@ pub fn generate(	...	@@ -352,7 +352,7 @@ pub fn generate(
352	assert(fn_owner_decl.has_tv);	352	assert(fn_owner_decl.has_tv);
353	const fn_type = fn_owner_decl.typeOf(zcu);	353	const fn_type = fn_owner_decl.typeOf(zcu);
354	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	354	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
355	const target = &namespace.file_scope.mod.resolved_target.result;	355	const target = &namespace.fileScope(zcu).mod.resolved_target.result;
356		356
357	var branch_stack = std.ArrayList(Branch).init(gpa);	357	var branch_stack = std.ArrayList(Branch).init(gpa);
358	defer {	358	defer {

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

...	@@ -712,8 +712,8 @@ pub fn generate(	...	@@ -712,8 +712,8 @@ pub fn generate(
712	assert(fn_owner_decl.has_tv);	712	assert(fn_owner_decl.has_tv);
713	const fn_type = fn_owner_decl.typeOf(zcu);	713	const fn_type = fn_owner_decl.typeOf(zcu);
714	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	714	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
715	const target = &namespace.file_scope.mod.resolved_target.result;	715	const target = &namespace.fileScope(zcu).mod.resolved_target.result;
716	const mod = namespace.file_scope.mod;	716	const mod = namespace.fileScope(zcu).mod;
717		717
718	var branch_stack = std.ArrayList(Branch).init(gpa);	718	var branch_stack = std.ArrayList(Branch).init(gpa);
719	defer {	719	defer {

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

...	@@ -277,7 +277,7 @@ pub fn generate(	...	@@ -277,7 +277,7 @@ pub fn generate(
277	assert(fn_owner_decl.has_tv);	277	assert(fn_owner_decl.has_tv);
278	const fn_type = fn_owner_decl.typeOf(zcu);	278	const fn_type = fn_owner_decl.typeOf(zcu);
279	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	279	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
280	const target = &namespace.file_scope.mod.resolved_target.result;	280	const target = &namespace.fileScope(zcu).mod.resolved_target.result;
281		281
282	var branch_stack = std.ArrayList(Branch).init(gpa);	282	var branch_stack = std.ArrayList(Branch).init(gpa);
283	defer {	283	defer {

src/arch/wasm/CodeGen.zig+6-6

...	@@ -1212,11 +1212,11 @@ pub fn generate(	...	@@ -1212,11 +1212,11 @@ pub fn generate(
1212	_ = src_loc;	1212	_ = src_loc;
1213	const comp = bin_file.comp;	1213	const comp = bin_file.comp;
1214	const gpa = comp.gpa;	1214	const gpa = comp.gpa;
1215	const mod = comp.module.?;	1215	const zcu = comp.module.?;
1216	const func = mod.funcInfo(func_index);	1216	const func = zcu.funcInfo(func_index);
1217	const decl = mod.declPtr(func.owner_decl);	1217	const decl = zcu.declPtr(func.owner_decl);
1218	const namespace = mod.namespacePtr(decl.src_namespace);	1218	const namespace = zcu.namespacePtr(decl.src_namespace);
1219	const target = namespace.file_scope.mod.resolved_target.result;	1219	const target = namespace.fileScope(zcu).mod.resolved_target.result;
1220	var code_gen: CodeGen = .{	1220	var code_gen: CodeGen = .{
1221	.gpa = gpa,	1221	.gpa = gpa,
1222	.air = air,	1222	.air = air,
...	@@ -7706,7 +7706,7 @@ fn airFence(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {	...	@@ -7706,7 +7706,7 @@ fn airFence(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
7706	// for a single-threaded build, can we emit the `fence` instruction.	7706	// for a single-threaded build, can we emit the `fence` instruction.
7707	// In all other cases, we emit no instructions for a fence.	7707	// In all other cases, we emit no instructions for a fence.
7708	const func_namespace = zcu.namespacePtr(func.decl.src_namespace);	7708	const func_namespace = zcu.namespacePtr(func.decl.src_namespace);
7709	const single_threaded = func_namespace.file_scope.mod.single_threaded;	7709	const single_threaded = func_namespace.fileScope(zcu).mod.single_threaded;
7710	if (func.useAtomicFeature() and !single_threaded) {	7710	if (func.useAtomicFeature() and !single_threaded) {
7711	try func.addAtomicTag(.atomic_fence);	7711	try func.addAtomicTag(.atomic_fence);
7712	}	7712	}

src/arch/x86_64/CodeGen.zig+1-1

...	@@ -810,7 +810,7 @@ pub fn generate(	...	@@ -810,7 +810,7 @@ pub fn generate(
810	assert(fn_owner_decl.has_tv);	810	assert(fn_owner_decl.has_tv);
811	const fn_type = fn_owner_decl.typeOf(zcu);	811	const fn_type = fn_owner_decl.typeOf(zcu);
812	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);	812	const namespace = zcu.namespacePtr(fn_owner_decl.src_namespace);
813	const mod = namespace.file_scope.mod;	813	const mod = namespace.fileScope(zcu).mod;
814		814
815	var function = Self{	815	var function = Self{
816	.gpa = gpa,	816	.gpa = gpa,

src/codegen.zig+6-6

src/codegen/c.zig+1-1

...	@@ -2581,7 +2581,7 @@ pub fn genTypeDecl(	...	@@ -2581,7 +2581,7 @@ pub fn genTypeDecl(
2581	_ = try renderTypePrefix(.flush, global_ctype_pool, zcu, writer, global_ctype, .suffix, .{});	2581	_ = try renderTypePrefix(.flush, global_ctype_pool, zcu, writer, global_ctype, .suffix, .{});
2582	try writer.writeByte(';');	2582	try writer.writeByte(';');
2583	const owner_decl = zcu.declPtr(owner_decl_index);	2583	const owner_decl = zcu.declPtr(owner_decl_index);
2584	const owner_mod = zcu.namespacePtr(owner_decl.src_namespace).file_scope.mod;	2584	const owner_mod = zcu.namespacePtr(owner_decl.src_namespace).fileScope(zcu).mod;
2585	if (!owner_mod.strip) {	2585	if (!owner_mod.strip) {
2586	try writer.writeAll(" /* ");	2586	try writer.writeAll(" /* ");
2587	try owner_decl.renderFullyQualifiedName(zcu, writer);	2587	try owner_decl.renderFullyQualifiedName(zcu, writer);

src/codegen/llvm.zig+150-141

 @@ -1362,7 +1362,8 @@ pub const Object = struct {
         const decl_index = func.owner_decl;
         const decl = zcu.declPtr(decl_index);
         const namespace = zcu.namespacePtr(decl.src_namespace);
-        const owner_mod = namespace.file_scope.mod;
+        const file_scope = namespace.fileScope(zcu);
+        const owner_mod = file_scope.mod;
         const fn_info = zcu.typeToFunc(decl.typeOf(zcu)).?;
         const target = owner_mod.resolved_target.result;
         const ip = &zcu.intern_pool;
 @@ -1633,7 +1634,7 @@ pub const Object = struct {
         function_index.setAttributes(try attributes.finish(&o.builder), &o.builder);
         const file, const subprogram = if (!wip.strip) debug_info: {
-            const file = try o.getDebugFile(namespace.file_scope);
+            const file = try o.getDebugFile(file_scope);
             const line_number = decl.navSrcLine(zcu) + 1;
             const is_internal_linkage = decl.val.getExternFunc(zcu) == null;
 @@ -1720,23 +1721,23 @@ pub const Object = struct {
     pub fn updateExports(
         self: *Object,
-        mod: *Module,
+        zcu: *Zcu,
         exported: Module.Exported,
         export_indices: []const u32,
     ) link.File.UpdateExportsError!void {
         const decl_index = switch (exported) {
             .decl_index => |i| i,
-            .value => |val| return updateExportedValue(self, mod, val, export_indices),
+            .value => |val| return updateExportedValue(self, zcu, val, export_indices),
         };
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         const global_index = self.decl_map.get(decl_index).?;
-        const decl = mod.declPtr(decl_index);
+        const decl = zcu.declPtr(decl_index);
-        const comp = mod.comp;
+        const comp = zcu.comp;
         if (export_indices.len != 0) {
-            return updateExportedGlobal(self, mod, global_index, export_indices);
+            return updateExportedGlobal(self, zcu, global_index, export_indices);
         } else {
-            const fqn = try self.builder.strtabString((try decl.fullyQualifiedName(mod)).toSlice(ip));
+            const fqn = try self.builder.strtabString((try decl.fullyQualifiedName(zcu)).toSlice(ip));
             try global_index.rename(fqn, &self.builder);
             global_index.setLinkage(.internal, &self.builder);
             if (comp.config.dll_export_fns)
 @@ -1908,12 +1909,12 @@ pub const Object = struct {
         const gpa = o.gpa;
         const target = o.target;
-        const mod = o.module;
+        const zcu = o.module;
-        const ip = &mod.intern_pool;
+        const ip = &zcu.intern_pool;
         if (o.debug_type_map.get(ty)) |debug_type| return debug_type;
-        switch (ty.zigTypeTag(mod)) {
+        switch (ty.zigTypeTag(zcu)) {
             .Void,
             .NoReturn,
             => {
 @@ -1925,12 +1926,12 @@ pub const Object = struct {
                 return debug_void_type;
             },
             .Int => {
-                const info = ty.intInfo(mod);
+                const info = ty.intInfo(zcu);
                 assert(info.bits != 0);
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
                 const builder_name = try o.builder.metadataString(name);
-                const debug_bits = ty.abiSize(mod) * 8; // lldb cannot handle non-byte sized types
+                const debug_bits = ty.abiSize(zcu) * 8; // lldb cannot handle non-byte sized types
                 const debug_int_type = switch (info.signedness) {
                     .signed => try o.builder.debugSignedType(builder_name, debug_bits),
                     .unsigned => try o.builder.debugUnsignedType(builder_name, debug_bits),
 @@ -1939,10 +1940,10 @@ pub const Object = struct {
                 return debug_int_type;
             },
             .Enum => {
-                const owner_decl_index = ty.getOwnerDecl(mod);
+                const owner_decl_index = ty.getOwnerDecl(zcu);
                 const owner_decl = o.module.declPtr(owner_decl_index);
-                if (!ty.hasRuntimeBitsIgnoreComptime(mod)) {
+                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     const debug_enum_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);
                     try o.debug_type_map.put(gpa, ty, debug_enum_type);
                     return debug_enum_type;
 @@ -1954,13 +1955,13 @@ pub const Object = struct {
                 defer gpa.free(enumerators);
                 const int_ty = Type.fromInterned(enum_type.tag_ty);
-                const int_info = ty.intInfo(mod);
+                const int_info = ty.intInfo(zcu);
                 assert(int_info.bits != 0);
                 for (enum_type.names.get(ip), 0..) |field_name_ip, i| {
                     var bigint_space: Value.BigIntSpace = undefined;
                     const bigint = if (enum_type.values.len != 0)
-                        Value.fromInterned(enum_type.values.get(ip)[i]).toBigInt(&bigint_space, mod)
+                        Value.fromInterned(enum_type.values.get(ip)[i]).toBigInt(&bigint_space, zcu)
                     else
                         std.math.big.int.Mutable.init(&bigint_space.limbs, i).toConst();
 @@ -1972,7 +1973,8 @@ pub const Object = struct {
                     );
                 }
-                const file = try o.getDebugFile(mod.namespacePtr(owner_decl.src_namespace).file_scope);
+                const file_scope = zcu.namespacePtr(owner_decl.src_namespace).fileScope(zcu);
+                const file = try o.getDebugFile(file_scope);
                 const scope = try o.namespaceToDebugScope(owner_decl.src_namespace);
                 const name = try o.allocTypeName(ty);
 @@ -1982,10 +1984,10 @@ pub const Object = struct {
                     try o.builder.metadataString(name),
                     file,
                     scope,
-                    owner_decl.typeSrcLine(mod) + 1, // Line
+                    owner_decl.typeSrcLine(zcu) + 1, // Line
                     try o.lowerDebugType(int_ty),
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(enumerators),
                 );
 @@ -2014,7 +2016,7 @@ pub const Object = struct {
             },
             .Pointer => {
                 // Normalize everything that the debug info does not represent.
-                const ptr_info = ty.ptrInfo(mod);
+                const ptr_info = ty.ptrInfo(zcu);
                 if (ptr_info.sentinel != .none or
                     ptr_info.flags.address_space != .generic or
 @@ -2025,10 +2027,10 @@ pub const Object = struct {
                     ptr_info.flags.is_const or
                     ptr_info.flags.is_volatile or
                     ptr_info.flags.size == .Many or ptr_info.flags.size == .C or
-                    !Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(mod))
+                    !Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(zcu))
                 {
-                    const bland_ptr_ty = try mod.ptrType(.{
+                    const bland_ptr_ty = try zcu.ptrType(.{
-                        .child = if (!Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(mod))
+                        .child = if (!Type.fromInterned(ptr_info.child).hasRuntimeBitsIgnoreComptime(zcu))
                             .anyopaque_type
                         else
                             ptr_info.child,
 @@ -2050,18 +2052,18 @@ pub const Object = struct {
                 // Set as forward reference while the type is lowered in case it references itself
                 try o.debug_type_map.put(gpa, ty, debug_fwd_ref);
-                if (ty.isSlice(mod)) {
+                if (ty.isSlice(zcu)) {
-                    const ptr_ty = ty.slicePtrFieldType(mod);
+                    const ptr_ty = ty.slicePtrFieldType(zcu);
                     const len_ty = Type.usize;
                     const name = try o.allocTypeName(ty);
                     defer gpa.free(name);
                     const line = 0;
-                    const ptr_size = ptr_ty.abiSize(mod);
+                    const ptr_size = ptr_ty.abiSize(zcu);
-                    const ptr_align = ptr_ty.abiAlignment(mod);
+                    const ptr_align = ptr_ty.abiAlignment(zcu);
-                    const len_size = len_ty.abiSize(mod);
+                    const len_size = len_ty.abiSize(zcu);
-                    const len_align = len_ty.abiAlignment(mod);
+                    const len_align = len_ty.abiAlignment(zcu);
                     const len_offset = len_align.forward(ptr_size);
 @@ -2093,8 +2095,8 @@ pub const Object = struct {
                         o.debug_compile_unit, // Scope
                         line,
                         .none, // Underlying type
-                        ty.abiSize(mod) * 8,
+                        ty.abiSize(zcu) * 8,
-                        (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                         try o.builder.debugTuple(&.{
                             debug_ptr_type,
                             debug_len_type,
 @@ -2122,7 +2124,7 @@ pub const Object = struct {
                     0, // Line
                     debug_elem_ty,
                     target.ptrBitWidth(),
-                    (ty.ptrAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.ptrAlignment(zcu).toByteUnits() orelse 0) * 8,
                     0, // Offset
                 );
 @@ -2146,13 +2148,14 @@ pub const Object = struct {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
-                const owner_decl_index = ty.getOwnerDecl(mod);
+                const owner_decl_index = ty.getOwnerDecl(zcu);
                 const owner_decl = o.module.declPtr(owner_decl_index);
+                const file_scope = zcu.namespacePtr(owner_decl.src_namespace).fileScope(zcu);
                 const debug_opaque_type = try o.builder.debugStructType(
                     try o.builder.metadataString(name),
-                    try o.getDebugFile(mod.namespacePtr(owner_decl.src_namespace).file_scope),
+                    try o.getDebugFile(file_scope),
                     try o.namespaceToDebugScope(owner_decl.src_namespace),
-                    owner_decl.typeSrcLine(mod) + 1, // Line
+                    owner_decl.typeSrcLine(zcu) + 1, // Line
                     .none, // Underlying type
                     0, // Size
                     0, // Align
 @@ -2167,13 +2170,13 @@ pub const Object = struct {
                     .none, // File
                     .none, // Scope
                     0, // Line
-                    try o.lowerDebugType(ty.childType(mod)),
+                    try o.lowerDebugType(ty.childType(zcu)),
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&.{
                         try o.builder.debugSubrange(
                             try o.builder.debugConstant(try o.builder.intConst(.i64, 0)),
-                            try o.builder.debugConstant(try o.builder.intConst(.i64, ty.arrayLen(mod))),
+                            try o.builder.debugConstant(try o.builder.intConst(.i64, ty.arrayLen(zcu))),
                         ),
                     }),
                 );
 @@ -2181,14 +2184,14 @@ pub const Object = struct {
                 return debug_array_type;
             },
             .Vector => {
-                const elem_ty = ty.elemType2(mod);
+                const elem_ty = ty.elemType2(zcu);
                 // Vector elements cannot be padded since that would make
                 // @bitSizOf(elem) * len > @bitSizOf(vec).
                 // Neither gdb nor lldb seem to be able to display non-byte sized
                 // vectors properly.
-                const debug_elem_type = switch (elem_ty.zigTypeTag(mod)) {
+                const debug_elem_type = switch (elem_ty.zigTypeTag(zcu)) {
                     .Int => blk: {
-                        const info = elem_ty.intInfo(mod);
+                        const info = elem_ty.intInfo(zcu);
                         assert(info.bits != 0);
                         const name = try o.allocTypeName(ty);
                         defer gpa.free(name);
 @@ -2202,7 +2205,7 @@ pub const Object = struct {
                         try o.builder.metadataString("bool"),
                         1,
                     ),
-                    else => try o.lowerDebugType(ty.childType(mod)),
+                    else => try o.lowerDebugType(ty.childType(zcu)),
                 };
                 const debug_vector_type = try o.builder.debugVectorType(
 @@ -2211,12 +2214,12 @@ pub const Object = struct {
                     .none, // Scope
                     0, // Line
                     debug_elem_type,
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&.{
                         try o.builder.debugSubrange(
                             try o.builder.debugConstant(try o.builder.intConst(.i64, 0)),
-                            try o.builder.debugConstant(try o.builder.intConst(.i64, ty.vectorLen(mod))),
+                            try o.builder.debugConstant(try o.builder.intConst(.i64, ty.vectorLen(zcu))),
                         ),
                     }),
                 );
 @@ -2227,8 +2230,8 @@ pub const Object = struct {
             .Optional => {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
-                const child_ty = ty.optionalChild(mod);
+                const child_ty = ty.optionalChild(zcu);
-                if (!child_ty.hasRuntimeBitsIgnoreComptime(mod)) {
+                if (!child_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     const debug_bool_type = try o.builder.debugBoolType(
                         try o.builder.metadataString(name),
                         8,
 @@ -2242,7 +2245,7 @@ pub const Object = struct {
                 // Set as forward reference while the type is lowered in case it references itself
                 try o.debug_type_map.put(gpa, ty, debug_fwd_ref);
-                if (ty.optionalReprIsPayload(mod)) {
+                if (ty.optionalReprIsPayload(zcu)) {
                     const debug_optional_type = try o.lowerDebugType(child_ty);
                     o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_optional_type);
 @@ -2255,10 +2258,10 @@ pub const Object = struct {
                 }
                 const non_null_ty = Type.u8;
-                const payload_size = child_ty.abiSize(mod);
+                const payload_size = child_ty.abiSize(zcu);
-                const payload_align = child_ty.abiAlignment(mod);
+                const payload_align = child_ty.abiAlignment(zcu);
-                const non_null_size = non_null_ty.abiSize(mod);
+                const non_null_size = non_null_ty.abiSize(zcu);
-                const non_null_align = non_null_ty.abiAlignment(mod);
+                const non_null_align = non_null_ty.abiAlignment(zcu);
                 const non_null_offset = non_null_align.forward(payload_size);
                 const debug_data_type = try o.builder.debugMemberType(
 @@ -2289,8 +2292,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&.{
                         debug_data_type,
                         debug_some_type,
 @@ -2306,8 +2309,8 @@ pub const Object = struct {
                 return debug_optional_type;
             },
             .ErrorUnion => {
-                const payload_ty = ty.errorUnionPayload(mod);
+                const payload_ty = ty.errorUnionPayload(zcu);
-                if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
+                if (!payload_ty.hasRuntimeBitsIgnoreComptime(zcu)) {
                     // TODO: Maybe remove?
                     const debug_error_union_type = try o.lowerDebugType(Type.anyerror);
                     try o.debug_type_map.put(gpa, ty, debug_error_union_type);
 @@ -2317,10 +2320,10 @@ pub const Object = struct {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
-                const error_size = Type.anyerror.abiSize(mod);
+                const error_size = Type.anyerror.abiSize(zcu);
-                const error_align = Type.anyerror.abiAlignment(mod);
+                const error_align = Type.anyerror.abiAlignment(zcu);
-                const payload_size = payload_ty.abiSize(mod);
+                const payload_size = payload_ty.abiSize(zcu);
-                const payload_align = payload_ty.abiAlignment(mod);
+                const payload_align = payload_ty.abiAlignment(zcu);
                 var error_index: u32 = undefined;
                 var payload_index: u32 = undefined;
 @@ -2368,8 +2371,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Sope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&fields),
                 );
 @@ -2390,14 +2393,14 @@ pub const Object = struct {
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
-                if (mod.typeToPackedStruct(ty)) |struct_type| {
+                if (zcu.typeToPackedStruct(ty)) |struct_type| {
                     const backing_int_ty = struct_type.backingIntType(ip).*;
                     if (backing_int_ty != .none) {
-                        const info = Type.fromInterned(backing_int_ty).intInfo(mod);
+                        const info = Type.fromInterned(backing_int_ty).intInfo(zcu);
                         const builder_name = try o.builder.metadataString(name);
                         const debug_int_type = switch (info.signedness) {
-                            .signed => try o.builder.debugSignedType(builder_name, ty.abiSize(mod) * 8),
+                            .signed => try o.builder.debugSignedType(builder_name, ty.abiSize(zcu) * 8),
-                            .unsigned => try o.builder.debugUnsignedType(builder_name, ty.abiSize(mod) * 8),
+                            .unsigned => try o.builder.debugUnsignedType(builder_name, ty.abiSize(zcu) * 8),
                         };
                         try o.debug_type_map.put(gpa, ty, debug_int_type);
                         return debug_int_type;
 @@ -2417,10 +2420,10 @@ pub const Object = struct {
                         const debug_fwd_ref = try o.builder.debugForwardReference();
                         for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty, field_val, i| {
-                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(mod)) continue;
+                            if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(zcu)) continue;
-                            const field_size = Type.fromInterned(field_ty).abiSize(mod);
+                            const field_size = Type.fromInterned(field_ty).abiSize(zcu);
-                            const field_align = Type.fromInterned(field_ty).abiAlignment(mod);
+                            const field_align = Type.fromInterned(field_ty).abiAlignment(zcu);
                             const field_offset = field_align.forward(offset);
                             offset = field_offset + field_size;
 @@ -2448,8 +2451,8 @@ pub const Object = struct {
                             o.debug_compile_unit, // Scope
                             0, // Line
                             .none, // Underlying type
-                            ty.abiSize(mod) * 8,
+                            ty.abiSize(zcu) * 8,
-                            (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                            (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                             try o.builder.debugTuple(fields.items),
                         );
 @@ -2467,7 +2470,7 @@ pub const Object = struct {
                             // into. Therefore we can satisfy this by making an empty namespace,
                             // rather than changing the frontend to unnecessarily resolve the
                             // struct field types.
-                            const owner_decl_index = ty.getOwnerDecl(mod);
+                            const owner_decl_index = ty.getOwnerDecl(zcu);
                             const debug_struct_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);
                             try o.debug_type_map.put(gpa, ty, debug_struct_type);
                             return debug_struct_type;
 @@ -2476,14 +2479,14 @@ pub const Object = struct {
                     else => {},
                 }
-                if (!ty.hasRuntimeBitsIgnoreComptime(mod)) {
+                if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const owner_decl_index = ty.getOwnerDecl(mod);
+                    const owner_decl_index = ty.getOwnerDecl(zcu);
                     const debug_struct_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);
                     try o.debug_type_map.put(gpa, ty, debug_struct_type);
                     return debug_struct_type;
                 }
-                const struct_type = mod.typeToStruct(ty).?;
+                const struct_type = zcu.typeToStruct(ty).?;
                 var fields: std.ArrayListUnmanaged(Builder.Metadata) = .{};
                 defer fields.deinit(gpa);
 @@ -2499,14 +2502,14 @@ pub const Object = struct {
                 var it = struct_type.iterateRuntimeOrder(ip);
                 while (it.next()) |field_index| {
                     const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[field_index]);
-                    if (!field_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
+                    if (!field_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    const field_size = field_ty.abiSize(mod);
+                    const field_size = field_ty.abiSize(zcu);
-                    const field_align = mod.structFieldAlignment(
+                    const field_align = zcu.structFieldAlignment(
                         struct_type.fieldAlign(ip, field_index),
                         field_ty,
                         struct_type.layout,
                     );
-                    const field_offset = ty.structFieldOffset(field_index, mod);
+                    const field_offset = ty.structFieldOffset(field_index, zcu);
                     const field_name = struct_type.fieldName(ip, field_index).unwrap() orelse
                         try ip.getOrPutStringFmt(gpa, "{d}", .{field_index}, .no_embedded_nulls);
 @@ -2529,8 +2532,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(fields.items),
                 );
 @@ -2543,14 +2546,14 @@ pub const Object = struct {
                 return debug_struct_type;
             },
             .Union => {
-                const owner_decl_index = ty.getOwnerDecl(mod);
+                const owner_decl_index = ty.getOwnerDecl(zcu);
                 const name = try o.allocTypeName(ty);
                 defer gpa.free(name);
                 const union_type = ip.loadUnionType(ty.toIntern());
                 if (!union_type.haveFieldTypes(ip) or
-                    !ty.hasRuntimeBitsIgnoreComptime(mod) or
+                    !ty.hasRuntimeBitsIgnoreComptime(zcu) or
                     !union_type.haveLayout(ip))
                 {
                     const debug_union_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);
 @@ -2558,7 +2561,7 @@ pub const Object = struct {
                     return debug_union_type;
                 }
-                const layout = mod.getUnionLayout(union_type);
+                const layout = zcu.getUnionLayout(union_type);
                 const debug_fwd_ref = try o.builder.debugForwardReference();
 @@ -2572,8 +2575,8 @@ pub const Object = struct {
                         o.debug_compile_unit, // Scope
                         0, // Line
                         .none, // Underlying type
-                        ty.abiSize(mod) * 8,
+                        ty.abiSize(zcu) * 8,
-                        (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                        (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                         try o.builder.debugTuple(
                             &.{try o.lowerDebugType(Type.fromInterned(union_type.enum_tag_ty))},
                         ),
 @@ -2600,12 +2603,12 @@ pub const Object = struct {
                 for (0..tag_type.names.len) |field_index| {
                     const field_ty = union_type.field_types.get(ip)[field_index];
-                    if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(mod)) continue;
+                    if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    const field_size = Type.fromInterned(field_ty).abiSize(mod);
+                    const field_size = Type.fromInterned(field_ty).abiSize(zcu);
                     const field_align: InternPool.Alignment = switch (union_type.flagsPtr(ip).layout) {
                         .@"packed" => .none,
-                        .auto, .@"extern" => mod.unionFieldNormalAlignment(union_type, @intCast(field_index)),
+                        .auto, .@"extern" => zcu.unionFieldNormalAlignment(union_type, @intCast(field_index)),
                     };
                     const field_name = tag_type.names.get(ip)[field_index];
 @@ -2634,8 +2637,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(fields.items),
                 );
 @@ -2693,8 +2696,8 @@ pub const Object = struct {
                     o.debug_compile_unit, // Scope
                     0, // Line
                     .none, // Underlying type
-                    ty.abiSize(mod) * 8,
+                    ty.abiSize(zcu) * 8,
-                    (ty.abiAlignment(mod).toByteUnits() orelse 0) * 8,
+                    (ty.abiAlignment(zcu).toByteUnits() orelse 0) * 8,
                     try o.builder.debugTuple(&full_fields),
                 );
 @@ -2707,7 +2710,7 @@ pub const Object = struct {
                 return debug_tagged_union_type;
             },
             .Fn => {
-                const fn_info = mod.typeToFunc(ty).?;
+                const fn_info = zcu.typeToFunc(ty).?;
                 var debug_param_types = std.ArrayList(Builder.Metadata).init(gpa);
                 defer debug_param_types.deinit();
 @@ -2715,32 +2718,32 @@ pub const Object = struct {
                 try debug_param_types.ensureUnusedCapacity(3 + fn_info.param_types.len);
                 // Return type goes first.
-                if (Type.fromInterned(fn_info.return_type).hasRuntimeBitsIgnoreComptime(mod)) {
+                if (Type.fromInterned(fn_info.return_type).hasRuntimeBitsIgnoreComptime(zcu)) {
-                    const sret = firstParamSRet(fn_info, mod, target);
+                    const sret = firstParamSRet(fn_info, zcu, target);
                     const ret_ty = if (sret) Type.void else Type.fromInterned(fn_info.return_type);
                     debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ret_ty));
                     if (sret) {
-                        const ptr_ty = try mod.singleMutPtrType(Type.fromInterned(fn_info.return_type));
+                        const ptr_ty = try zcu.singleMutPtrType(Type.fromInterned(fn_info.return_type));
                         debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));
                     }
                 } else {
                     debug_param_types.appendAssumeCapacity(try o.lowerDebugType(Type.void));
                 }
-                if (Type.fromInterned(fn_info.return_type).isError(mod) and
+                if (Type.fromInterned(fn_info.return_type).isError(zcu) and
                     o.module.comp.config.any_error_tracing)
                 {
-                    const ptr_ty = try mod.singleMutPtrType(try o.getStackTraceType());
+                    const ptr_ty = try zcu.singleMutPtrType(try o.getStackTraceType());
                     debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));
                 }
                 for (0..fn_info.param_types.len) |i| {
                     const param_ty = Type.fromInterned(fn_info.param_types.get(ip)[i]);
-                    if (!param_ty.hasRuntimeBitsIgnoreComptime(mod)) continue;
+                    if (!param_ty.hasRuntimeBitsIgnoreComptime(zcu)) continue;
-                    if (isByRef(param_ty, mod)) {
+                    if (isByRef(param_ty, zcu)) {
-                        const ptr_ty = try mod.singleMutPtrType(param_ty);
+                        const ptr_ty = try zcu.singleMutPtrType(param_ty);
                         debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));
                     } else {
                         debug_param_types.appendAssumeCapacity(try o.lowerDebugType(param_ty));
 @@ -2767,9 +2770,10 @@ pub const Object = struct {
     }
     fn namespaceToDebugScope(o: *Object, namespace_index: InternPool.NamespaceIndex) !Builder.Metadata {
-        const mod = o.module;
+        const zcu = o.module;
-        const namespace = mod.namespacePtr(namespace_index);
+        const namespace = zcu.namespacePtr(namespace_index);
-        if (namespace.parent == .none) return try o.getDebugFile(namespace.file_scope);
+        const file_scope = namespace.fileScope(zcu);
+        if (namespace.parent == .none) return try o.getDebugFile(file_scope);
         const gop = try o.debug_unresolved_namespace_scopes.getOrPut(o.gpa, namespace_index);
 @@ -2779,13 +2783,14 @@ pub const Object = struct {
     }
     fn makeEmptyNamespaceDebugType(o: *Object, decl_index: InternPool.DeclIndex) !Builder.Metadata {
-        const mod = o.module;
+        const zcu = o.module;
-        const decl = mod.declPtr(decl_index);
+        const decl = zcu.declPtr(decl_index);
+        const file_scope = zcu.namespacePtr(decl.src_namespace).fileScope(zcu);
         return o.builder.debugStructType(
-            try o.builder.metadataString(decl.name.toSlice(&mod.intern_pool)), // TODO use fully qualified name
+            try o.builder.metadataString(decl.name.toSlice(&zcu.intern_pool)), // TODO use fully qualified name
-            try o.getDebugFile(mod.namespacePtr(decl.src_namespace).file_scope),
+            try o.getDebugFile(file_scope),
             try o.namespaceToDebugScope(decl.src_namespace),
-            decl.typeSrcLine(mod) + 1,
+            decl.typeSrcLine(zcu) + 1,
             .none,
             0,
             0,
 @@ -2794,21 +2799,22 @@ pub const Object = struct {
     }
     fn getStackTraceType(o: *Object) Allocator.Error!Type {
-        const mod = o.module;
+        const zcu = o.module;
-        const std_mod = mod.std_mod;
+        const std_mod = zcu.std_mod;
-        const std_file = (mod.importPkg(std_mod) catch unreachable).file;
+        const std_file_imported = zcu.importPkg(std_mod) catch unreachable;
-        const builtin_str = try mod.intern_pool.getOrPutString(mod.gpa, "builtin", .no_embedded_nulls);
+        const builtin_str = try zcu.intern_pool.getOrPutString(zcu.gpa, "builtin", .no_embedded_nulls);
-        const std_namespace = mod.namespacePtr(mod.declPtr(std_file.root_decl.unwrap().?).src_namespace);
+        const std_file_root_decl = zcu.fileRootDecl(std_file_imported.file_index);
-        const builtin_decl = std_namespace.decls.getKeyAdapted(builtin_str, Module.DeclAdapter{ .zcu = mod }).?;
+        const std_namespace = zcu.namespacePtr(zcu.declPtr(std_file_root_decl.unwrap().?).src_namespace);
+        const builtin_decl = std_namespace.decls.getKeyAdapted(builtin_str, Module.DeclAdapter{ .zcu = zcu }).?;
-        const stack_trace_str = try mod.intern_pool.getOrPutString(mod.gpa, "StackTrace", .no_embedded_nulls);
+        const stack_trace_str = try zcu.intern_pool.getOrPutString(zcu.gpa, "StackTrace", .no_embedded_nulls);
         // buffer is only used for int_type, `builtin` is a struct.
-        const builtin_ty = mod.declPtr(builtin_decl).val.toType();
+        const builtin_ty = zcu.declPtr(builtin_decl).val.toType();
-        const builtin_namespace = mod.namespacePtrUnwrap(builtin_ty.getNamespaceIndex(mod)).?;
+        const builtin_namespace = zcu.namespacePtrUnwrap(builtin_ty.getNamespaceIndex(zcu)).?;
-        const stack_trace_decl_index = builtin_namespace.decls.getKeyAdapted(stack_trace_str, Module.DeclAdapter{ .zcu = mod }).?;
+        const stack_trace_decl_index = builtin_namespace.decls.getKeyAdapted(stack_trace_str, Module.DeclAdapter{ .zcu = zcu }).?;
-        const stack_trace_decl = mod.declPtr(stack_trace_decl_index);
+        const stack_trace_decl = zcu.declPtr(stack_trace_decl_index);
         // Sema should have ensured that StackTrace was analyzed.
         assert(stack_trace_decl.has_tv);
 @@ -2834,7 +2840,7 @@ pub const Object = struct {
         const gpa = o.gpa;
         const decl = zcu.declPtr(decl_index);
         const namespace = zcu.namespacePtr(decl.src_namespace);
-        const owner_mod = namespace.file_scope.mod;
+        const owner_mod = namespace.fileScope(zcu).mod;
         const zig_fn_type = decl.typeOf(zcu);
         const gop = try o.decl_map.getOrPut(gpa, decl_index);
         if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.function;
 @@ -3059,17 +3065,17 @@ pub const Object = struct {
         if (gop.found_existing) return gop.value_ptr.ptr(&o.builder).kind.variable;
         errdefer assert(o.decl_map.remove(decl_index));
-        const mod = o.module;
+        const zcu = o.module;
-        const decl = mod.declPtr(decl_index);
+        const decl = zcu.declPtr(decl_index);
-        const is_extern = decl.isExtern(mod);
+        const is_extern = decl.isExtern(zcu);
         const variable_index = try o.builder.addVariable(
             try o.builder.strtabString((if (is_extern)
                 decl.name
             else
-                try decl.fullyQualifiedName(mod)).toSlice(&mod.intern_pool)),
+                try decl.fullyQualifiedName(zcu)).toSlice(&zcu.intern_pool)),
-            try o.lowerType(decl.typeOf(mod)),
+            try o.lowerType(decl.typeOf(zcu)),
-            toLlvmGlobalAddressSpace(decl.@"addrspace", mod.getTarget()),
+            toLlvmGlobalAddressSpace(decl.@"addrspace", zcu.getTarget()),
         );
         gop.value_ptr.* = variable_index.ptrConst(&o.builder).global;
 @@ -3077,9 +3083,9 @@ pub const Object = struct {
         if (is_extern) {
             variable_index.setLinkage(.external, &o.builder);
             variable_index.setUnnamedAddr(.default, &o.builder);
-            if (decl.val.getVariable(mod)) |decl_var| {
+            if (decl.val.getVariable(zcu)) |decl_var| {
-                const decl_namespace = mod.namespacePtr(decl.src_namespace);
+                const decl_namespace = zcu.namespacePtr(decl.src_namespace);
-                const single_threaded = decl_namespace.file_scope.mod.single_threaded;
+                const single_threaded = decl_namespace.fileScope(zcu).mod.single_threaded;
                 variable_index.setThreadLocal(
                     if (decl_var.is_threadlocal and !single_threaded) .generaldynamic else .default,
                     &o.builder,
 @@ -4638,7 +4644,8 @@ pub const DeclGen = struct {
         const o = dg.object;
         const zcu = o.module;
         const namespace = zcu.namespacePtr(dg.decl.src_namespace);
-        return namespace.file_scope.mod;
+        const file_scope = namespace.fileScope(zcu);
+        return file_scope.mod;
     }
     fn todo(dg: *DeclGen, comptime format: []const u8, args: anytype) Error {
 @@ -4682,7 +4689,7 @@ pub const DeclGen = struct {
             if (decl.val.getVariable(zcu)) |decl_var| {
                 const decl_namespace = zcu.namespacePtr(decl.src_namespace);
-                const single_threaded = decl_namespace.file_scope.mod.single_threaded;
+                const single_threaded = decl_namespace.fileScope(zcu).mod.single_threaded;
                 variable_index.setThreadLocal(
                     if (decl_var.is_threadlocal and !single_threaded) .generaldynamic else .default,
                     &o.builder,
 @@ -4692,10 +4699,11 @@ pub const DeclGen = struct {
             const line_number = decl.navSrcLine(zcu) + 1;
             const namespace = zcu.namespacePtr(decl.src_namespace);
-            const owner_mod = namespace.file_scope.mod;
+            const file_scope = namespace.fileScope(zcu);
+            const owner_mod = file_scope.mod;
             if (!owner_mod.strip) {
-                const debug_file = try o.getDebugFile(namespace.file_scope);
+                const debug_file = try o.getDebugFile(file_scope);
                 const debug_global_var = try o.builder.debugGlobalVar(
                     try o.builder.metadataString(decl.name.toSlice(ip)), // Name
 @@ -5143,9 +5151,10 @@ pub const FuncGen = struct {
             const decl_index = func.owner_decl;
             const decl = zcu.declPtr(decl_index);
             const namespace = zcu.namespacePtr(decl.src_namespace);
-            const owner_mod = namespace.file_scope.mod;
+            const file_scope = namespace.fileScope(zcu);
+            const owner_mod = file_scope.mod;
-            self.file = try o.getDebugFile(namespace.file_scope);
+            self.file = try o.getDebugFile(file_scope);
             const line_number = decl.navSrcLine(zcu) + 1;
             self.inlined = self.wip.debug_location;

src/codegen/spirv.zig+10-9

 @@ -188,19 +188,20 @@ pub const Object = struct {
     fn genDecl(
         self: *Object,
-        mod: *Module,
+        zcu: *Zcu,
         decl_index: InternPool.DeclIndex,
         air: Air,
         liveness: Liveness,
     ) !void {
-        const decl = mod.declPtr(decl_index);
+        const gpa = self.gpa;
-        const namespace = mod.namespacePtr(decl.src_namespace);
+        const decl = zcu.declPtr(decl_index);
-        const structured_cfg = namespace.file_scope.mod.structured_cfg;
+        const namespace = zcu.namespacePtr(decl.src_namespace);
+        const structured_cfg = namespace.fileScope(zcu).mod.structured_cfg;
         var decl_gen = DeclGen{
-            .gpa = self.gpa,
+            .gpa = gpa,
             .object = self,
-            .module = mod,
+            .module = zcu,
             .spv = &self.spv,
             .decl_index = decl_index,
             .air = air,
 @@ -212,19 +213,19 @@ pub const Object = struct {
                 false => .{ .unstructured = .{} },
             },
             .current_block_label = undefined,
-            .base_line = decl.navSrcLine(mod),
+            .base_line = decl.navSrcLine(zcu),
         };
         defer decl_gen.deinit();
         decl_gen.genDecl() catch |err| switch (err) {
             error.CodegenFail => {
-                try mod.failed_analysis.put(mod.gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }), decl_gen.error_msg.?);
+                try zcu.failed_analysis.put(gpa, InternPool.AnalUnit.wrap(.{ .decl = decl_index }), decl_gen.error_msg.?);
             },
             else => |other| {
                 // There might be an error that happened *after* self.error_msg
                 // was already allocated, so be sure to free it.
                 if (decl_gen.error_msg) |error_msg| {
-                    error_msg.deinit(mod.gpa);
+                    error_msg.deinit(gpa);
                 }
                 return other;

src/link/C.zig+8-4

src/link/Dwarf.zig+1-1

...	@@ -1204,7 +1204,7 @@ pub fn commitDeclState(	...	@@ -1204,7 +1204,7 @@ pub fn commitDeclState(
1204	const decl = zcu.declPtr(decl_index);	1204	const decl = zcu.declPtr(decl_index);
1205	const ip = &zcu.intern_pool;	1205	const ip = &zcu.intern_pool;
1206	const namespace = zcu.namespacePtr(decl.src_namespace);	1206	const namespace = zcu.namespacePtr(decl.src_namespace);
1207	const target = namespace.file_scope.mod.resolved_target.result;	1207	const target = namespace.fileScope(zcu).mod.resolved_target.result;
1208	const target_endian = target.cpu.arch.endian();	1208	const target_endian = target.cpu.arch.endian();
1209		1209
1210	var dbg_line_buffer = &decl_state.dbg_line;	1210	var dbg_line_buffer = &decl_state.dbg_line;

src/link/Wasm/ZigObject.zig+11-11

...	@@ -335,29 +335,29 @@ fn finishUpdateDecl(	...	@@ -335,29 +335,29 @@ fn finishUpdateDecl(
335	code: []const u8,	335	code: []const u8,
336	) !void {	336	) !void {
337	const gpa = wasm_file.base.comp.gpa;	337	const gpa = wasm_file.base.comp.gpa;
338	const mod = wasm_file.base.comp.module.?;	338	const zcu = wasm_file.base.comp.module.?;
339	const decl = mod.declPtr(decl_index);	339	const decl = zcu.declPtr(decl_index);
340	const decl_info = zig_object.decls_map.get(decl_index).?;	340	const decl_info = zig_object.decls_map.get(decl_index).?;
341	const atom_index = decl_info.atom;	341	const atom_index = decl_info.atom;
342	const atom = wasm_file.getAtomPtr(atom_index);	342	const atom = wasm_file.getAtomPtr(atom_index);
343	const sym = zig_object.symbol(atom.sym_index);	343	const sym = zig_object.symbol(atom.sym_index);
344	const full_name = try decl.fullyQualifiedName(mod);	344	const full_name = try decl.fullyQualifiedName(zcu);
345	sym.name = try zig_object.string_table.insert(gpa, full_name.toSlice(&mod.intern_pool));	345	sym.name = try zig_object.string_table.insert(gpa, full_name.toSlice(&zcu.intern_pool));
346	try atom.code.appendSlice(gpa, code);	346	try atom.code.appendSlice(gpa, code);
347	atom.size = @intCast(code.len);	347	atom.size = @intCast(code.len);
348		348
349	switch (decl.typeOf(mod).zigTypeTag(mod)) {	349	switch (decl.typeOf(zcu).zigTypeTag(zcu)) {
350	.Fn => {	350	.Fn => {
351	sym.index = try zig_object.appendFunction(gpa, .{ .type_index = zig_object.atom_types.get(atom_index).? });	351	sym.index = try zig_object.appendFunction(gpa, .{ .type_index = zig_object.atom_types.get(atom_index).? });
352	sym.tag = .function;	352	sym.tag = .function;
353	},	353	},
354	else => {	354	else => {
355	const segment_name: []const u8 = if (decl.getOwnedVariable(mod)) \|variable\| name: {	355	const segment_name: []const u8 = if (decl.getOwnedVariable(zcu)) \|variable\| name: {
356	if (variable.is_const) {	356	if (variable.is_const) {
357	break :name ".rodata.";	357	break :name ".rodata.";
358	} else if (Value.fromInterned(variable.init).isUndefDeep(mod)) {	358	} else if (Value.fromInterned(variable.init).isUndefDeep(zcu)) {
359	const decl_namespace = mod.namespacePtr(decl.src_namespace);	359	const decl_namespace = zcu.namespacePtr(decl.src_namespace);
360	const optimize_mode = decl_namespace.file_scope.mod.optimize_mode;	360	const optimize_mode = decl_namespace.fileScope(zcu).mod.optimize_mode;
361	const is_initialized = switch (optimize_mode) {	361	const is_initialized = switch (optimize_mode) {
362	.Debug, .ReleaseSafe => true,	362	.Debug, .ReleaseSafe => true,
363	.ReleaseFast, .ReleaseSmall => false,	363	.ReleaseFast, .ReleaseSmall => false,
...	@@ -382,7 +382,7 @@ fn finishUpdateDecl(	...	@@ -382,7 +382,7 @@ fn finishUpdateDecl(
382	// Will be freed upon freeing of decl or after cleanup of Wasm binary.	382	// Will be freed upon freeing of decl or after cleanup of Wasm binary.
383	const full_segment_name = try std.mem.concat(gpa, u8, &.{	383	const full_segment_name = try std.mem.concat(gpa, u8, &.{
384	segment_name,	384	segment_name,
385	full_name.toSlice(&mod.intern_pool),	385	full_name.toSlice(&zcu.intern_pool),
386	});	386	});
387	errdefer gpa.free(full_segment_name);	387	errdefer gpa.free(full_segment_name);
388	sym.tag = .data;	388	sym.tag = .data;
...	@@ -390,7 +390,7 @@ fn finishUpdateDecl(	...	@@ -390,7 +390,7 @@ fn finishUpdateDecl(
390	},	390	},
391	}	391	}
392	if (code.len == 0) return;	392	if (code.len == 0) return;
393	atom.alignment = decl.getAlignment(mod);	393	atom.alignment = decl.getAlignment(zcu);
394	}	394	}
395		395
396	/// Creates and initializes a new segment in the 'Data' section.	396	/// Creates and initializes a new segment in the 'Data' section.

src/main.zig+7-15

...	@@ -27,8 +27,6 @@ const Cache = std.Build.Cache;	...	@@ -27,8 +27,6 @@ const Cache = std.Build.Cache;
27	const target_util = @import("target.zig");	27	const target_util = @import("target.zig");
28	const crash_report = @import("crash_report.zig");	28	const crash_report = @import("crash_report.zig");
29	const Zcu = @import("Zcu.zig");	29	const Zcu = @import("Zcu.zig");
30	/// Deprecated.
31	const Module = Zcu;
32	const AstGen = std.zig.AstGen;	30	const AstGen = std.zig.AstGen;
33	const mingw = @import("mingw.zig");	31	const mingw = @import("mingw.zig");
34	const Server = std.zig.Server;	32	const Server = std.zig.Server;
...	@@ -919,7 +917,7 @@ fn buildOutputType(	...	@@ -919,7 +917,7 @@ fn buildOutputType(
919	var contains_res_file: bool = false;	917	var contains_res_file: bool = false;
920	var reference_trace: ?u32 = null;	918	var reference_trace: ?u32 = null;
921	var pdb_out_path: ?[]const u8 = null;	919	var pdb_out_path: ?[]const u8 = null;
922	var error_limit: ?Module.ErrorInt = null;	920	var error_limit: ?Zcu.ErrorInt = null;
923	// These are before resolving sysroot.	921	// These are before resolving sysroot.
924	var extra_cflags: std.ArrayListUnmanaged([]const u8) = .{};	922	var extra_cflags: std.ArrayListUnmanaged([]const u8) = .{};
925	var extra_rcflags: std.ArrayListUnmanaged([]const u8) = .{};	923	var extra_rcflags: std.ArrayListUnmanaged([]const u8) = .{};
...	@@ -1107,7 +1105,7 @@ fn buildOutputType(	...	@@ -1107,7 +1105,7 @@ fn buildOutputType(
1107	);	1105	);
1108	} else if (mem.eql(u8, arg, "--error-limit")) {	1106	} else if (mem.eql(u8, arg, "--error-limit")) {
1109	const next_arg = args_iter.nextOrFatal();	1107	const next_arg = args_iter.nextOrFatal();
1110	error_limit = std.fmt.parseUnsigned(Module.ErrorInt, next_arg, 0) catch \|err\| {	1108	error_limit = std.fmt.parseUnsigned(Zcu.ErrorInt, next_arg, 0) catch \|err\| {
1111	fatal("unable to parse error limit '{s}': {s}", .{ next_arg, @errorName(err) });	1109	fatal("unable to parse error limit '{s}': {s}", .{ next_arg, @errorName(err) });
1112	};	1110	};
1113	} else if (mem.eql(u8, arg, "-cflags")) {	1111	} else if (mem.eql(u8, arg, "-cflags")) {
...	@@ -5956,7 +5954,7 @@ fn cmdAstCheck(	...	@@ -5956,7 +5954,7 @@ fn cmdAstCheck(
5956	}	5954	}
5957	}	5955	}
5958		5956
5959	var file: Module.File = .{	5957	var file: Zcu.File = .{
5960	.status = .never_loaded,	5958	.status = .never_loaded,
5961	.source_loaded = false,	5959	.source_loaded = false,
5962	.tree_loaded = false,	5960	.tree_loaded = false,
...	@@ -5967,8 +5965,6 @@ fn cmdAstCheck(	...	@@ -5967,8 +5965,6 @@ fn cmdAstCheck(
5967	.tree = undefined,	5965	.tree = undefined,
5968	.zir = undefined,	5966	.zir = undefined,
5969	.mod = undefined,	5967	.mod = undefined,
5970	.root_decl = .none,
5971	.path_digest = undefined,
5972	};	5968	};
5973	if (zig_source_file) \|file_name\| {	5969	if (zig_source_file) \|file_name\| {
5974	var f = fs.cwd().openFile(file_name, .{}) catch \|err\| {	5970	var f = fs.cwd().openFile(file_name, .{}) catch \|err\| {
...	@@ -6275,7 +6271,7 @@ fn cmdDumpZir(	...	@@ -6275,7 +6271,7 @@ fn cmdDumpZir(
6275	};	6271	};
6276	defer f.close();	6272	defer f.close();
6277		6273
6278	var file: Module.File = .{	6274	var file: Zcu.File = .{
6279	.status = .never_loaded,	6275	.status = .never_loaded,
6280	.source_loaded = false,	6276	.source_loaded = false,
6281	.tree_loaded = false,	6277	.tree_loaded = false,
...	@@ -6284,10 +6280,8 @@ fn cmdDumpZir(	...	@@ -6284,10 +6280,8 @@ fn cmdDumpZir(
6284	.source = undefined,	6280	.source = undefined,
6285	.stat = undefined,	6281	.stat = undefined,
6286	.tree = undefined,	6282	.tree = undefined,
6287	.zir = try Module.loadZirCache(gpa, f),	6283	.zir = try Zcu.loadZirCache(gpa, f),
6288	.mod = undefined,	6284	.mod = undefined,
6289	.root_decl = .none,
6290	.path_digest = undefined,
6291	};	6285	};
6292	defer file.zir.deinit(gpa);	6286	defer file.zir.deinit(gpa);
6293		6287
...	@@ -6342,7 +6336,7 @@ fn cmdChangelist(	...	@@ -6342,7 +6336,7 @@ fn cmdChangelist(
6342	if (stat.size > std.zig.max_src_size)	6336	if (stat.size > std.zig.max_src_size)
6343	return error.FileTooBig;	6337	return error.FileTooBig;
6344		6338
6345	var file: Module.File = .{	6339	var file: Zcu.File = .{
6346	.status = .never_loaded,	6340	.status = .never_loaded,
6347	.source_loaded = false,	6341	.source_loaded = false,
6348	.tree_loaded = false,	6342	.tree_loaded = false,
...	@@ -6357,8 +6351,6 @@ fn cmdChangelist(	...	@@ -6357,8 +6351,6 @@ fn cmdChangelist(
6357	.tree = undefined,	6351	.tree = undefined,
6358	.zir = undefined,	6352	.zir = undefined,
6359	.mod = undefined,	6353	.mod = undefined,
6360	.root_decl = .none,
6361	.path_digest = undefined,
6362	};	6354	};
6363		6355
6364	file.mod = try Package.Module.createLimited(arena, .{	6356	file.mod = try Package.Module.createLimited(arena, .{
...	@@ -6431,7 +6423,7 @@ fn cmdChangelist(	...	@@ -6431,7 +6423,7 @@ fn cmdChangelist(
6431	var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .{};	6423	var inst_map: std.AutoHashMapUnmanaged(Zir.Inst.Index, Zir.Inst.Index) = .{};
6432	defer inst_map.deinit(gpa);	6424	defer inst_map.deinit(gpa);
6433		6425
6434	try Module.mapOldZirToNew(gpa, old_zir, file.zir, &inst_map);	6426	try Zcu.mapOldZirToNew(gpa, old_zir, file.zir, &inst_map);
6435		6427
6436	var bw = io.bufferedWriter(io.getStdOut().writer());	6428	var bw = io.bufferedWriter(io.getStdOut().writer());
6437	const stdout = bw.writer();	6429	const stdout = bw.writer();

...	@@ -58,7 +58,7 @@ pub fn generateFunction(	...	@@ -58,7 +58,7 @@ pub fn generateFunction(
58	const func = zcu.funcInfo(func_index);	58	const func = zcu.funcInfo(func_index);
59	const decl = zcu.declPtr(func.owner_decl);	59	const decl = zcu.declPtr(func.owner_decl);
60	const namespace = zcu.namespacePtr(decl.src_namespace);	60	const namespace = zcu.namespacePtr(decl.src_namespace);
61	const target = namespace.file_scope.mod.resolved_target.result;	61	const target = namespace.fileScope(zcu).mod.resolved_target.result;
62	switch (target.cpu.arch) {	62	switch (target.cpu.arch) {
63	.arm,	63	.arm,
64	.armeb,	64	.armeb,
...	@@ -88,7 +88,7 @@ pub fn generateLazyFunction(	...	@@ -88,7 +88,7 @@ pub fn generateLazyFunction(
88	const decl_index = lazy_sym.ty.getOwnerDecl(zcu);	88	const decl_index = lazy_sym.ty.getOwnerDecl(zcu);
89	const decl = zcu.declPtr(decl_index);	89	const decl = zcu.declPtr(decl_index);
90	const namespace = zcu.namespacePtr(decl.src_namespace);	90	const namespace = zcu.namespacePtr(decl.src_namespace);
91	const target = namespace.file_scope.mod.resolved_target.result;	91	const target = namespace.fileScope(zcu).mod.resolved_target.result;
92	switch (target.cpu.arch) {	92	switch (target.cpu.arch) {
93	.x86_64 => return @import("arch/x86_64/CodeGen.zig").generateLazy(lf, src_loc, lazy_sym, code, debug_output),	93	.x86_64 => return @import("arch/x86_64/CodeGen.zig").generateLazy(lf, src_loc, lazy_sym, code, debug_output),
94	else => unreachable,	94	else => unreachable,
...	@@ -742,7 +742,7 @@ fn lowerDeclRef(	...	@@ -742,7 +742,7 @@ fn lowerDeclRef(
742	const zcu = lf.comp.module.?;	742	const zcu = lf.comp.module.?;
743	const decl = zcu.declPtr(decl_index);	743	const decl = zcu.declPtr(decl_index);
744	const namespace = zcu.namespacePtr(decl.src_namespace);	744	const namespace = zcu.namespacePtr(decl.src_namespace);
745	const target = namespace.file_scope.mod.resolved_target.result;	745	const target = namespace.fileScope(zcu).mod.resolved_target.result;
746		746
747	const ptr_width = target.ptrBitWidth();	747	const ptr_width = target.ptrBitWidth();
748	const is_fn_body = decl.typeOf(zcu).zigTypeTag(zcu) == .Fn;	748	const is_fn_body = decl.typeOf(zcu).zigTypeTag(zcu) == .Fn;
...	@@ -836,7 +836,7 @@ fn genDeclRef(	...	@@ -836,7 +836,7 @@ fn genDeclRef(
836		836
837	const ptr_decl = zcu.declPtr(ptr_decl_index);	837	const ptr_decl = zcu.declPtr(ptr_decl_index);
838	const namespace = zcu.namespacePtr(ptr_decl.src_namespace);	838	const namespace = zcu.namespacePtr(ptr_decl.src_namespace);
839	const target = namespace.file_scope.mod.resolved_target.result;	839	const target = namespace.fileScope(zcu).mod.resolved_target.result;
840		840
841	const ptr_bits = target.ptrBitWidth();	841	const ptr_bits = target.ptrBitWidth();
842	const ptr_bytes: u64 = @divExact(ptr_bits, 8);	842	const ptr_bytes: u64 = @divExact(ptr_bits, 8);
...	@@ -875,7 +875,7 @@ fn genDeclRef(	...	@@ -875,7 +875,7 @@ fn genDeclRef(
875	}	875	}
876		876
877	const decl_namespace = zcu.namespacePtr(decl.src_namespace);	877	const decl_namespace = zcu.namespacePtr(decl.src_namespace);
878	const single_threaded = decl_namespace.file_scope.mod.single_threaded;	878	const single_threaded = decl_namespace.fileScope(zcu).mod.single_threaded;
879	const is_threadlocal = val.isPtrToThreadLocal(zcu) and !single_threaded;	879	const is_threadlocal = val.isPtrToThreadLocal(zcu) and !single_threaded;
880	const is_extern = decl.isExtern(zcu);	880	const is_extern = decl.isExtern(zcu);
881		881
...	@@ -985,7 +985,7 @@ pub fn genTypedValue(	...	@@ -985,7 +985,7 @@ pub fn genTypedValue(
985		985
986	const owner_decl = zcu.declPtr(owner_decl_index);	986	const owner_decl = zcu.declPtr(owner_decl_index);
987	const namespace = zcu.namespacePtr(owner_decl.src_namespace);	987	const namespace = zcu.namespacePtr(owner_decl.src_namespace);
988	const target = namespace.file_scope.mod.resolved_target.result;	988	const target = namespace.fileScope(zcu).mod.resolved_target.result;
989	const ptr_bits = target.ptrBitWidth();	989	const ptr_bits = target.ptrBitWidth();
990		990
991	if (!ty.isSlice(zcu)) switch (ip.indexToKey(val.toIntern())) {	991	if (!ty.isSlice(zcu)) switch (ip.indexToKey(val.toIntern())) {

...	@@ -208,6 +208,8 @@ pub fn updateFunc(	...	@@ -208,6 +208,8 @@ pub fn updateFunc(
208	fwd_decl.clearRetainingCapacity();	208	fwd_decl.clearRetainingCapacity();
209	code.clearRetainingCapacity();	209	code.clearRetainingCapacity();
210		210
		211	const file_scope = zcu.namespacePtr(decl.src_namespace).fileScope(zcu);
		212
211	var function: codegen.Function = .{	213	var function: codegen.Function = .{
212	.value_map = codegen.CValueMap.init(gpa),	214	.value_map = codegen.CValueMap.init(gpa),
213	.air = air,	215	.air = air,
...	@@ -217,7 +219,7 @@ pub fn updateFunc(	...	@@ -217,7 +219,7 @@ pub fn updateFunc(
217	.dg = .{	219	.dg = .{
218	.gpa = gpa,	220	.gpa = gpa,
219	.zcu = zcu,	221	.zcu = zcu,
220	.mod = zcu.namespacePtr(decl.src_namespace).file_scope.mod,	222	.mod = file_scope.mod,
221	.error_msg = null,	223	.error_msg = null,
222	.pass = .{ .decl = decl_index },	224	.pass = .{ .decl = decl_index },
223	.is_naked_fn = decl.typeOf(zcu).fnCallingConvention(zcu) == .Naked,	225	.is_naked_fn = decl.typeOf(zcu).fnCallingConvention(zcu) == .Naked,
...	@@ -335,11 +337,13 @@ pub fn updateDecl(self: C, zcu: Zcu, decl_index: InternPool.DeclIndex) !void {	...	@@ -335,11 +337,13 @@ pub fn updateDecl(self: C, zcu: Zcu, decl_index: InternPool.DeclIndex) !void {
335	fwd_decl.clearRetainingCapacity();	337	fwd_decl.clearRetainingCapacity();
336	code.clearRetainingCapacity();	338	code.clearRetainingCapacity();
337		339
		340	const file_scope = zcu.namespacePtr(decl.src_namespace).fileScope(zcu);
		341
338	var object: codegen.Object = .{	342	var object: codegen.Object = .{
339	.dg = .{	343	.dg = .{
340	.gpa = gpa,	344	.gpa = gpa,
341	.zcu = zcu,	345	.zcu = zcu,
342	.mod = zcu.namespacePtr(decl.src_namespace).file_scope.mod,	346	.mod = file_scope.mod,
343	.error_msg = null,	347	.error_msg = null,
344	.pass = .{ .decl = decl_index },	348	.pass = .{ .decl = decl_index },
345	.is_naked_fn = false,	349	.is_naked_fn = false,
...	@@ -491,7 +495,7 @@ pub fn flushModule(self: *C, arena: Allocator, prog_node: std.Progress.Node) !vo	...	@@ -491,7 +495,7 @@ pub fn flushModule(self: *C, arena: Allocator, prog_node: std.Progress.Node) !vo
491	for (self.decl_table.keys(), self.decl_table.values()) \|decl_index, *decl_block\| {	495	for (self.decl_table.keys(), self.decl_table.values()) \|decl_index, *decl_block\| {
492	const decl = zcu.declPtr(decl_index);	496	const decl = zcu.declPtr(decl_index);
493	const extern_name = if (decl.isExtern(zcu)) decl.name.toOptional() else .none;	497	const extern_name = if (decl.isExtern(zcu)) decl.name.toOptional() else .none;
494	const mod = zcu.namespacePtr(decl.src_namespace).file_scope.mod;	498	const mod = zcu.namespacePtr(decl.src_namespace).fileScope(zcu).mod;
495	try self.flushDeclBlock(	499	try self.flushDeclBlock(
496	zcu,	500	zcu,
497	mod,	501	mod,
...	@@ -848,7 +852,7 @@ pub fn updateExports(	...	@@ -848,7 +852,7 @@ pub fn updateExports(
848	const gpa = self.base.comp.gpa;	852	const gpa = self.base.comp.gpa;
849	const mod, const pass: codegen.DeclGen.Pass, const decl_block, const exported_block = switch (exported) {	853	const mod, const pass: codegen.DeclGen.Pass, const decl_block, const exported_block = switch (exported) {
850	.decl_index => \|decl_index\| .{	854	.decl_index => \|decl_index\| .{
851	zcu.namespacePtr(zcu.declPtr(decl_index).src_namespace).file_scope.mod,	855	zcu.namespacePtr(zcu.declPtr(decl_index).src_namespace).fileScope(zcu).mod,
852	.{ .decl = decl_index },	856	.{ .decl = decl_index },
853	self.decl_table.getPtr(decl_index).?,	857	self.decl_table.getPtr(decl_index).?,
854	(try self.exported_decls.getOrPut(gpa, decl_index)).value_ptr,	858	(try self.exported_decls.getOrPut(gpa, decl_index)).value_ptr,