Commit d717c96877355090ea3a8e3662a2584eea02445c | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-05-15 13:18:08+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-05-16 13:28:15+01:00
log	d717c96877355090ea3a8e3662a2584eea02445c
tree	3f76da87b8b222f9f103344aaacec8370a8ee3d4
parent	70040778fbde5d7fcbbfc26dbabc700024c538d5
signature	Commit is signed but in an unrecognized format.

compiler: include inline calls in the reference trace

Inline calls which happened in the erroring `AnalUnit` still show as
error notes, because they tend to make very important context (e.g. to
see how comptime values propagate through them). However, "earlier"
inline calls are still useful to see to understand how something is
being referenced, so we should include them in the reference trace.

4 files changed, 175 insertions(+), 57 deletions(-)

src/Compilation.zig+45-21

 @@ -3681,32 +3681,27 @@ pub fn addModuleErrorMsg(
             const ref = maybe_ref orelse break;
             const gop = try seen.getOrPut(gpa, ref.referencer);
             if (gop.found_existing) break;
-            if (ref_traces.items.len < max_references) skip: {
+            if (ref_traces.items.len < max_references) {
-                const src = ref.src.upgrade(zcu);
+                var last_call_src = ref.src;
-                const source = try src.file_scope.getSource(gpa);
+                var opt_inline_frame = ref.inline_frame;
-                const span = try src.span(gpa);
+                while (opt_inline_frame.unwrap()) |inline_frame| {
-                const loc = std.zig.findLineColumn(source.bytes, span.main);
+                    const f = inline_frame.ptr(zcu).*;
-                const rt_file_path = try src.file_scope.fullPath(gpa);
+                    const func_nav = ip.indexToKey(f.callee).func.owner_nav;
-                defer gpa.free(rt_file_path);
+                    const func_name = ip.getNav(func_nav).name.toSlice(ip);
-                const name = switch (ref.referencer.unwrap()) {
+                    try addReferenceTraceFrame(zcu, eb, &ref_traces, func_name, last_call_src, true);
+                    last_call_src = f.call_src;
+                    opt_inline_frame = f.parent;
+                }
+                const root_name: ?[]const u8 = switch (ref.referencer.unwrap()) {
                     .@"comptime" => "comptime",
                     .nav_val, .nav_ty => |nav| ip.getNav(nav).name.toSlice(ip),
                     .type => |ty| Type.fromInterned(ty).containerTypeName(ip).toSlice(ip),
                     .func => |f| ip.getNav(zcu.funcInfo(f).owner_nav).name.toSlice(ip),
-                    .memoized_state => break :skip,
+                    .memoized_state => null,
                 };
-                try ref_traces.append(gpa, .{
+                if (root_name) |n| {
-                    .decl_name = try eb.addString(name),
+                    try addReferenceTraceFrame(zcu, eb, &ref_traces, n, last_call_src, false);
-                    .src_loc = try eb.addSourceLocation(.{
+                }
-                        .src_path = try eb.addString(rt_file_path),
-                        .span_start = span.start,
-                        .span_main = span.main,
-                        .span_end = span.end,
-                        .line = @intCast(loc.line),
-                        .column = @intCast(loc.column),
-                        .source_line = 0,
-                    }),
-                });
             }
             referenced_by = ref.referencer;
         }
 @@ -3786,6 +3781,35 @@ pub fn addModuleErrorMsg(
     }
 }
+fn addReferenceTraceFrame(
+    zcu: *Zcu,
+    eb: *ErrorBundle.Wip,
+    ref_traces: *std.ArrayListUnmanaged(ErrorBundle.ReferenceTrace),
+    name: []const u8,
+    lazy_src: Zcu.LazySrcLoc,
+    inlined: bool,
+) !void {
+    const gpa = zcu.gpa;
+    const src = lazy_src.upgrade(zcu);
+    const source = try src.file_scope.getSource(gpa);
+    const span = try src.span(gpa);
+    const loc = std.zig.findLineColumn(source.bytes, span.main);
+    const rt_file_path = try src.file_scope.fullPath(gpa);
+    defer gpa.free(rt_file_path);
+    try ref_traces.append(gpa, .{
+        .decl_name = try eb.printString("{s}{s}", .{ name, if (inlined) " [inlined]" else "" }),
+        .src_loc = try eb.addSourceLocation(.{
+            .src_path = try eb.addString(rt_file_path),
+            .span_start = span.start,
+            .span_main = span.main,
+            .span_end = span.end,
+            .line = @intCast(loc.line),
+            .column = @intCast(loc.column),
+            .source_line = 0,
+        }),
+    });
+}
 pub fn addZirErrorMessages(eb: *ErrorBundle.Wip, file: *Zcu.File) !void {
     const gpa = eb.gpa;
     const src_path = try file.fullPath(gpa);

src/Sema.zig+51-33

 @@ -448,6 +448,21 @@ pub const Block = struct {
         func: InternPool.Index,
         comptime_result: Air.Inst.Ref,
         merges: Merges,
+        /// Populated lazily by `refFrame`.
+        ref_frame: Zcu.InlineReferenceFrame.Index.Optional = .none,
+        fn refFrame(inlining: *Inlining, zcu: *Zcu) Allocator.Error!Zcu.InlineReferenceFrame.Index {
+            if (inlining.ref_frame == .none) {
+                inlining.ref_frame = (try zcu.addInlineReferenceFrame(.{
+                    .callee = inlining.func,
+                    .call_src = inlining.call_src,
+                    .parent = if (inlining.call_block.inlining) |parent_inlining| p: {
+                        break :p (try parent_inlining.refFrame(zcu)).toOptional();
+                    } else .none,
+                })).toOptional();
+            }
+            return inlining.ref_frame.unwrap().?;
+        }
     };
     pub const Merges = struct {
 @@ -4287,7 +4302,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com
             if (zcu.intern_pool.isFuncBody(val)) {
                 const ty = Type.fromInterned(zcu.intern_pool.typeOf(val));
                 if (try ty.fnHasRuntimeBitsSema(pt)) {
-                    try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = val }));
+                    try sema.addReferenceEntry(block, src, AnalUnit.wrap(.{ .func = val }));
                     try zcu.ensureFuncBodyAnalysisQueued(val);
                 }
             }
 @@ -6615,7 +6630,7 @@ pub fn analyzeExport(
     if (options.linkage == .internal)
         return;
-    try sema.ensureNavResolved(src, orig_nav_index, .fully);
+    try sema.ensureNavResolved(block, src, orig_nav_index, .fully);
     const exported_nav_index = switch (ip.indexToKey(ip.getNav(orig_nav_index).status.fully_resolved.val)) {
         .variable => |v| v.owner_nav,
 @@ -6644,7 +6659,7 @@ pub fn analyzeExport(
         return sema.fail(block, src, "export target cannot be extern", .{});
     }
-    try sema.maybeQueueFuncBodyAnalysis(src, exported_nav_index);
+    try sema.maybeQueueFuncBodyAnalysis(block, src, exported_nav_index);
     try sema.exports.append(gpa, .{
         .opts = options,
 @@ -6892,7 +6907,7 @@ fn zirDeclRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
         .no_embedded_nulls,
     );
     const nav_index = try sema.lookupIdentifier(block, src, decl_name);
-    return sema.analyzeNavRef(src, nav_index);
+    return sema.analyzeNavRef(block, src, nav_index);
 }
 fn zirDeclVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -6988,7 +7003,7 @@ fn lookupInNamespace(
                 }
                 for (usingnamespaces.items) |sub_ns_nav| {
-                    try sema.ensureNavResolved(src, sub_ns_nav, .fully);
+                    try sema.ensureNavResolved(block, src, sub_ns_nav, .fully);
                     const sub_ns_ty = Type.fromInterned(ip.getNav(sub_ns_nav).status.fully_resolved.val);
                     const sub_ns = zcu.namespacePtr(sub_ns_ty.getNamespaceIndex(zcu));
                     try checked_namespaces.put(gpa, sub_ns, {});
 @@ -7720,8 +7735,8 @@ fn analyzeCall(
     var generic_inlining: Block.Inlining = if (func_ty_info.is_generic) .{
         .call_block = block,
         .call_src = call_src,
+        .func = func_val.?.toIntern(),
         .has_comptime_args = false, // unused by error reporting
-        .func = .none, // unused by error reporting
         .comptime_result = .none, // unused by error reporting
         .merges = undefined, // unused because we'll never `return`
     } else undefined;
 @@ -7999,7 +8014,7 @@ fn analyzeCall(
         ref_func: {
             const runtime_func_val = try sema.resolveValue(runtime_func) orelse break :ref_func;
             if (!ip.isFuncBody(runtime_func_val.toIntern())) break :ref_func;
-            try sema.addReferenceEntry(call_src, .wrap(.{ .func = runtime_func_val.toIntern() }));
+            try sema.addReferenceEntry(block, call_src, .wrap(.{ .func = runtime_func_val.toIntern() }));
             try zcu.ensureFuncBodyAnalysisQueued(runtime_func_val.toIntern());
         }
 @@ -17254,7 +17269,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
         .@"comptime" => |index| return Air.internedToRef(index),
         .runtime => |index| index,
         .nav_val => |nav| return sema.analyzeNavVal(block, src, nav),
-        .nav_ref => |nav| return sema.analyzeNavRef(src, nav),
+        .nav_ref => |nav| return sema.analyzeNavRef(block, src, nav),
     };
     // The comptime case is handled already above. Runtime case below.
 @@ -18407,7 +18422,7 @@ fn typeInfoNamespaceDecls(
         if (zcu.analysis_in_progress.contains(.wrap(.{ .nav_val = nav }))) {
             continue;
         }
-        try sema.ensureNavResolved(src, nav, .fully);
+        try sema.ensureNavResolved(block, src, nav, .fully);
         const namespace_ty = Type.fromInterned(ip.getNav(nav).status.fully_resolved.val);
         try sema.typeInfoNamespaceDecls(block, src, namespace_ty.getNamespaceIndex(zcu).toOptional(), declaration_ty, decl_vals, seen_namespaces);
     }
 @@ -27932,7 +27947,7 @@ fn namespaceLookupRef(
     decl_name: InternPool.NullTerminatedString,
 ) CompileError!?Air.Inst.Ref {
     const nav = try sema.namespaceLookup(block, src, namespace, decl_name) orelse return null;
-    return try sema.analyzeNavRef(src, nav);
+    return try sema.analyzeNavRef(block, src, nav);
 }
 fn namespaceLookupVal(
 @@ -29095,7 +29110,7 @@ fn coerceExtra(
                     .@"extern" => |e| e.owner_nav,
                     else => unreachable,
                 };
-                const inst_as_ptr = try sema.analyzeNavRef(inst_src, fn_nav);
+                const inst_as_ptr = try sema.analyzeNavRef(block, inst_src, fn_nav);
                 return sema.coerce(block, dest_ty, inst_as_ptr, inst_src);
             }
 @@ -30748,7 +30763,7 @@ fn coerceVarArgParam(
         .@"fn" => fn_ptr: {
             const fn_val = try sema.resolveConstDefinedValue(block, LazySrcLoc.unneeded, inst, undefined);
             const fn_nav = zcu.funcInfo(fn_val.toIntern()).owner_nav;
-            break :fn_ptr try sema.analyzeNavRef(inst_src, fn_nav);
+            break :fn_ptr try sema.analyzeNavRef(block, inst_src, fn_nav);
         },
         .array => return sema.fail(block, inst_src, "arrays must be passed by reference to variadic function", .{}),
         .float => float: {
 @@ -31758,12 +31773,13 @@ fn analyzeNavVal(
     src: LazySrcLoc,
     nav_index: InternPool.Nav.Index,
 ) CompileError!Air.Inst.Ref {
-    const ref = try sema.analyzeNavRefInner(src, nav_index, false);
+    const ref = try sema.analyzeNavRefInner(block, src, nav_index, false);
     return sema.analyzeLoad(block, src, ref, src);
 }
 fn addReferenceEntry(
     sema: *Sema,
+    opt_block: ?*Block,
     src: LazySrcLoc,
     referenced_unit: AnalUnit,
 ) !void {
 @@ -31771,10 +31787,12 @@ fn addReferenceEntry(
     if (!zcu.comp.incremental and zcu.comp.reference_trace == 0) return;
     const gop = try sema.references.getOrPut(sema.gpa, referenced_unit);
     if (gop.found_existing) return;
-    // TODO: we need to figure out how to model inline calls here.
+    try zcu.addUnitReference(sema.owner, referenced_unit, src, inline_frame: {
-    // They aren't references in the analysis sense, but ought to show up in the reference trace!
+        const block = opt_block orelse break :inline_frame .none;
-    // Would representing inline calls in the reference table cause excessive memory usage?
+        const inlining = block.inlining orelse break :inline_frame .none;
-    try zcu.addUnitReference(sema.owner, referenced_unit, src);
+        const frame = try inlining.refFrame(zcu);
+        break :inline_frame frame.toOptional();
+    });
 }
 pub fn addTypeReferenceEntry(
 @@ -31793,7 +31811,7 @@ fn ensureMemoizedStateResolved(sema: *Sema, src: LazySrcLoc, stage: InternPool.M
     const pt = sema.pt;
     const unit: AnalUnit = .wrap(.{ .memoized_state = stage });
-    try sema.addReferenceEntry(src, unit);
+    try sema.addReferenceEntry(null, src, unit);
     try sema.declareDependency(.{ .memoized_state = stage });
     if (pt.zcu.analysis_in_progress.contains(unit)) {
 @@ -31802,7 +31820,7 @@ fn ensureMemoizedStateResolved(sema: *Sema, src: LazySrcLoc, stage: InternPool.M
     try pt.ensureMemoizedStateUpToDate(stage);
 }
-pub fn ensureNavResolved(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index, kind: enum { type, fully }) CompileError!void {
+pub fn ensureNavResolved(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index: InternPool.Nav.Index, kind: enum { type, fully }) CompileError!void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 @@ -31825,7 +31843,7 @@ pub fn ensureNavResolved(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav
         .type => .{ .nav_ty = nav_index },
         .fully => .{ .nav_val = nav_index },
     });
-    try sema.addReferenceEntry(src, anal_unit);
+    try sema.addReferenceEntry(block, src, anal_unit);
     if (zcu.analysis_in_progress.contains(anal_unit)) {
         return sema.failWithOwnedErrorMsg(null, try sema.errMsg(.{
 @@ -31855,25 +31873,25 @@ fn optRefValue(sema: *Sema, opt_val: ?Value) !Value {
     } }));
 }
-fn analyzeNavRef(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index) CompileError!Air.Inst.Ref {
+fn analyzeNavRef(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index: InternPool.Nav.Index) CompileError!Air.Inst.Ref {
-    return sema.analyzeNavRefInner(src, nav_index, true);
+    return sema.analyzeNavRefInner(block, src, nav_index, true);
 }
 /// Analyze a reference to the `Nav` at the given index. Ensures the underlying `Nav` is analyzed.
 /// If this pointer will be used directly, `is_ref` must be `true`.
 /// If this pointer will be immediately loaded (i.e. a `decl_val` instruction), `is_ref` must be `false`.
-fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.Nav.Index, is_ref: bool) CompileError!Air.Inst.Ref {
+fn analyzeNavRefInner(sema: *Sema, block: *Block, src: LazySrcLoc, orig_nav_index: InternPool.Nav.Index, is_ref: bool) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
-    try sema.ensureNavResolved(src, orig_nav_index, if (is_ref) .type else .fully);
+    try sema.ensureNavResolved(block, src, orig_nav_index, if (is_ref) .type else .fully);
     const nav_index = nav: {
         if (ip.getNav(orig_nav_index).isExternOrFn(ip)) {
             // Getting a pointer to this `Nav` might mean we actually get a pointer to something else!
             // We need to resolve the value to know for sure.
-            if (is_ref) try sema.ensureNavResolved(src, orig_nav_index, .fully);
+            if (is_ref) try sema.ensureNavResolved(block, src, orig_nav_index, .fully);
             switch (ip.indexToKey(ip.getNav(orig_nav_index).status.fully_resolved.val)) {
                 .func => |f| break :nav f.owner_nav,
                 .@"extern" => |e| break :nav e.owner_nav,
 @@ -31897,7 +31915,7 @@ fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.N
         },
     });
     if (is_ref) {
-        try sema.maybeQueueFuncBodyAnalysis(src, nav_index);
+        try sema.maybeQueueFuncBodyAnalysis(block, src, nav_index);
     }
     return Air.internedToRef((try pt.intern(.{ .ptr = .{
         .ty = ptr_ty.toIntern(),
 @@ -31906,7 +31924,7 @@ fn analyzeNavRefInner(sema: *Sema, src: LazySrcLoc, orig_nav_index: InternPool.N
     } })));
 }
-fn maybeQueueFuncBodyAnalysis(sema: *Sema, src: LazySrcLoc, nav_index: InternPool.Nav.Index) !void {
+fn maybeQueueFuncBodyAnalysis(sema: *Sema, block: *Block, src: LazySrcLoc, nav_index: InternPool.Nav.Index) !void {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
 @@ -31914,16 +31932,16 @@ fn maybeQueueFuncBodyAnalysis(sema: *Sema, src: LazySrcLoc, nav_index: InternPoo
     // To avoid forcing too much resolution, let's first resolve the type, and check if it's a function.
     // If it is, we can resolve the *value*, and queue analysis as needed.
-    try sema.ensureNavResolved(src, nav_index, .type);
+    try sema.ensureNavResolved(block, src, nav_index, .type);
     const nav_ty: Type = .fromInterned(ip.getNav(nav_index).typeOf(ip));
     if (nav_ty.zigTypeTag(zcu) != .@"fn") return;
     if (!try nav_ty.fnHasRuntimeBitsSema(pt)) return;
-    try sema.ensureNavResolved(src, nav_index, .fully);
+    try sema.ensureNavResolved(block, src, nav_index, .fully);
     const nav_val = zcu.navValue(nav_index);
     if (!ip.isFuncBody(nav_val.toIntern())) return;
-    try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = nav_val.toIntern() }));
+    try sema.addReferenceEntry(block, src, AnalUnit.wrap(.{ .func = nav_val.toIntern() }));
     try zcu.ensureFuncBodyAnalysisQueued(nav_val.toIntern());
 }
 @@ -31939,8 +31957,8 @@ fn analyzeRef(
     if (try sema.resolveValue(operand)) |val| {
         switch (zcu.intern_pool.indexToKey(val.toIntern())) {
-            .@"extern" => |e| return sema.analyzeNavRef(src, e.owner_nav),
+            .@"extern" => |e| return sema.analyzeNavRef(block, src, e.owner_nav),
-            .func => |f| return sema.analyzeNavRef(src, f.owner_nav),
+            .func => |f| return sema.analyzeNavRef(block, src, f.owner_nav),
             else => return uavRef(sema, val.toIntern()),
         }
     }
 @@ -35504,7 +35522,7 @@ fn resolveInferredErrorSet(
         }
         // In this case we are dealing with the actual InferredErrorSet object that
         // corresponds to the function, not one created to track an inline/comptime call.
-        try sema.addReferenceEntry(src, AnalUnit.wrap(.{ .func = func_index }));
+        try sema.addReferenceEntry(block, src, AnalUnit.wrap(.{ .func = func_index }));
         try pt.ensureFuncBodyUpToDate(func_index);
     }

src/Sema/comptime_ptr_access.zig+1-1

...	@@ -228,7 +228,7 @@ fn loadComptimePtrInner(	...	@@ -228,7 +228,7 @@ fn loadComptimePtrInner(
228		228
229	const base_val: MutableValue = switch (ptr.base_addr) {	229	const base_val: MutableValue = switch (ptr.base_addr) {
230	.nav => \|nav\| val: {	230	.nav => \|nav\| val: {
231	try sema.ensureNavResolved(src, nav, .fully);	231	try sema.ensureNavResolved(block, src, nav, .fully);
232	const val = ip.getNav(nav).status.fully_resolved.val;	232	const val = ip.getNav(nav).status.fully_resolved.val;
233	switch (ip.indexToKey(val)) {	233	switch (ip.indexToKey(val)) {
234	.variable => return .runtime_load,	234	.variable => return .runtime_load,

src/Zcu.zig+78-2

...	@@ -215,6 +215,9 @@ all_references: std.ArrayListUnmanaged(Reference) = .empty,	...	@@ -215,6 +215,9 @@ all_references: std.ArrayListUnmanaged(Reference) = .empty,
215	/// Freelist of indices in `all_references`.	215	/// Freelist of indices in `all_references`.
216	free_references: std.ArrayListUnmanaged(u32) = .empty,	216	free_references: std.ArrayListUnmanaged(u32) = .empty,
217		217
		218	inline_reference_frames: std.ArrayListUnmanaged(InlineReferenceFrame) = .empty,
		219	free_inline_reference_frames: std.ArrayListUnmanaged(InlineReferenceFrame.Index) = .empty,
		220
218	/// Key is the `AnalUnit` performing the reference. This representation allows	221	/// Key is the `AnalUnit` performing the reference. This representation allows
219	/// incremental updates to quickly delete references caused by a specific `AnalUnit`.	222	/// incremental updates to quickly delete references caused by a specific `AnalUnit`.
220	/// Value is index into `all_type_reference` of the first reference triggered by the unit.	223	/// Value is index into `all_type_reference` of the first reference triggered by the unit.
...	@@ -583,6 +586,42 @@ pub const Reference = struct {	...	@@ -583,6 +586,42 @@ pub const Reference = struct {
583	next: u32,	586	next: u32,
584	/// The source location of the reference.	587	/// The source location of the reference.
585	src: LazySrcLoc,	588	src: LazySrcLoc,
		589	/// If not `.none`, this is the index of the `InlineReferenceFrame` which should appear
		590	/// between the referencer and `referenced` in the reference trace. These frames represent
		591	/// inline calls, which do not create actual references (since they happen in the caller's
		592	/// `AnalUnit`), but do show in the reference trace.
		593	inline_frame: InlineReferenceFrame.Index.Optional,
		594	};
		595
		596	pub const InlineReferenceFrame = struct {
		597	/// The inline callee; that is, the function which was called inline.
		598	/// The caller is either `parent`, or else the unit causing the original `Reference`.
		599	callee: InternPool.Index,
		600	/// The source location of the inline call, in the caller.
		601	call_src: LazySrcLoc,
		602	/// If not `.none`, a frame which should appear directly below this one.
		603	/// This will be the "parent" inline call; this frame's `callee` is our caller.
		604	parent: InlineReferenceFrame.Index.Optional,
		605
		606	pub const Index = enum(u32) {
		607	_,
		608	pub fn ptr(idx: Index, zcu: Zcu) InlineReferenceFrame {
		609	return &zcu.inline_reference_frames.items[@intFromEnum(idx)];
		610	}
		611	pub fn toOptional(idx: Index) Optional {
		612	return @enumFromInt(@intFromEnum(idx));
		613	}
		614	pub const Optional = enum(u32) {
		615	none = std.math.maxInt(u32),
		616	_,
		617	pub fn unwrap(opt: Optional) ?Index {
		618	return switch (opt) {
		619	.none => null,
		620	_ => @enumFromInt(@intFromEnum(opt)),
		621	};
		622	}
		623	};
		624	};
586	};	625	};
587		626
588	pub const TypeReference = struct {	627	pub const TypeReference = struct {
...	@@ -3440,12 +3479,28 @@ pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {	...	@@ -3440,12 +3479,28 @@ pub fn deleteUnitReferences(zcu: *Zcu, anal_unit: AnalUnit) void {
3440	var idx = kv.value;	3479	var idx = kv.value;
3441		3480
3442	while (idx != std.math.maxInt(u32)) {	3481	while (idx != std.math.maxInt(u32)) {
		3482	const ref = zcu.all_references.items[idx];
3443	zcu.free_references.append(gpa, idx) catch {	3483	zcu.free_references.append(gpa, idx) catch {
3444	// This space will be reused eventually, so we need not propagate this error.	3484	// This space will be reused eventually, so we need not propagate this error.
3445	// Just leak it for now, and let GC reclaim it later on.	3485	// Just leak it for now, and let GC reclaim it later on.
3446	break :unit_refs;	3486	break :unit_refs;
3447	};	3487	};
3448	idx = zcu.all_references.items[idx].next;	3488	idx = ref.next;
		3489
		3490	var opt_inline_frame = ref.inline_frame;
		3491	while (opt_inline_frame.unwrap()) \|inline_frame\| {
		3492	// The same inline frame could be used multiple times by one unit. We need to
		3493	// detect this case to avoid adding it to `free_inline_reference_frames` more
		3494	// than once. We do that by setting `parent` to itself as a marker.
		3495	if (inline_frame.ptr(zcu).parent == inline_frame.toOptional()) break;
		3496	zcu.free_inline_reference_frames.append(gpa, inline_frame) catch {
		3497	// This space will be reused eventually, so we need not propagate this error.
		3498	// Just leak it for now, and let GC reclaim it later on.
		3499	break :unit_refs;
		3500	};
		3501	opt_inline_frame = inline_frame.ptr(zcu).parent;
		3502	inline_frame.ptr(zcu).parent = inline_frame.toOptional(); // signal to code above
		3503	}
3449	}	3504	}
3450	}	3505	}
3451		3506
...	@@ -3480,7 +3535,22 @@ pub fn deleteUnitCompileLogs(zcu: *Zcu, anal_unit: AnalUnit) void {	...	@@ -3480,7 +3535,22 @@ pub fn deleteUnitCompileLogs(zcu: *Zcu, anal_unit: AnalUnit) void {
3480	}	3535	}
3481	}	3536	}
3482		3537
3483	pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit, ref_src: LazySrcLoc) Allocator.Error!void {	3538	pub fn addInlineReferenceFrame(zcu: *Zcu, frame: InlineReferenceFrame) Allocator.Error!Zcu.InlineReferenceFrame.Index {
		3539	const frame_idx: InlineReferenceFrame.Index = zcu.free_inline_reference_frames.pop() orelse idx: {
		3540	_ = try zcu.inline_reference_frames.addOne(zcu.gpa);
		3541	break :idx @enumFromInt(zcu.inline_reference_frames.items.len - 1);
		3542	};
		3543	frame_idx.ptr(zcu).* = frame;
		3544	return frame_idx;
		3545	}
		3546
		3547	pub fn addUnitReference(
		3548	zcu: *Zcu,
		3549	src_unit: AnalUnit,
		3550	referenced_unit: AnalUnit,
		3551	ref_src: LazySrcLoc,
		3552	inline_frame: InlineReferenceFrame.Index.Optional,
		3553	) Allocator.Error!void {
3484	const gpa = zcu.gpa;	3554	const gpa = zcu.gpa;
3485		3555
3486	zcu.clearCachedResolvedReferences();	3556	zcu.clearCachedResolvedReferences();
...	@@ -3500,6 +3570,7 @@ pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit	...	@@ -3500,6 +3570,7 @@ pub fn addUnitReference(zcu: *Zcu, src_unit: AnalUnit, referenced_unit: AnalUnit
3500	.referenced = referenced_unit,	3570	.referenced = referenced_unit,
3501	.next = if (gop.found_existing) gop.value_ptr.* else std.math.maxInt(u32),	3571	.next = if (gop.found_existing) gop.value_ptr.* else std.math.maxInt(u32),
3502	.src = ref_src,	3572	.src = ref_src,
		3573	.inline_frame = inline_frame,
3503	};	3574	};
3504		3575
3505	gop.value_ptr.* = @intCast(ref_idx);	3576	gop.value_ptr.* = @intCast(ref_idx);
...	@@ -3828,7 +3899,10 @@ pub fn unionTagFieldIndex(zcu: *const Zcu, loaded_union: InternPool.LoadedUnionT	...	@@ -3828,7 +3899,10 @@ pub fn unionTagFieldIndex(zcu: *const Zcu, loaded_union: InternPool.LoadedUnionT
3828		3899
3829	pub const ResolvedReference = struct {	3900	pub const ResolvedReference = struct {
3830	referencer: AnalUnit,	3901	referencer: AnalUnit,
		3902	/// If `inline_frame` is not `.none`, this is the deepest source location in the chain of
		3903	/// inline calls. For source locations further up the inline call stack, consult `inline_frame`.
3831	src: LazySrcLoc,	3904	src: LazySrcLoc,
		3905	inline_frame: InlineReferenceFrame.Index.Optional,
3832	};	3906	};
3833		3907
3834	/// Returns a mapping from an `AnalUnit` to where it is referenced.	3908	/// Returns a mapping from an `AnalUnit` to where it is referenced.
...	@@ -4037,6 +4111,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolv	...	@@ -4037,6 +4111,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolv
4037	try unit_queue.put(gpa, ref.referenced, .{	4111	try unit_queue.put(gpa, ref.referenced, .{
4038	.referencer = unit,	4112	.referencer = unit,
4039	.src = ref.src,	4113	.src = ref.src,
		4114	.inline_frame = ref.inline_frame,
4040	});	4115	});
4041	}	4116	}
4042	ref_idx = ref.next;	4117	ref_idx = ref.next;
...	@@ -4055,6 +4130,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolv	...	@@ -4055,6 +4130,7 @@ fn resolveReferencesInner(zcu: *Zcu) !std.AutoHashMapUnmanaged(AnalUnit, ?Resolv
4055	try type_queue.put(gpa, ref.referenced, .{	4130	try type_queue.put(gpa, ref.referenced, .{
4056	.referencer = unit,	4131	.referencer = unit,
4057	.src = ref.src,	4132	.src = ref.src,
		4133	.inline_frame = .none,
4058	});	4134	});
4059	}	4135	}
4060	ref_idx = ref.next;	4136	ref_idx = ref.next;