Commit 04c9f50aec5c1d01ee2c230534454a0ddf551c38 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-01-05 11:28:16+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-01-11 08:54:47+00:00
log	04c9f50aec5c1d01ee2c230534454a0ddf551c38
tree	60b898e67a3a570bf44c15531647c6f575ac5c09
parent	6cfc9c0e02cb1ccf9edfbdc64fcca285fea022fb

compiler: improve "... contains reference to comptime var" errors

`Sema.explainWhyValueContainsReferenceToComptimeVar` (concise name!)
adds notes to an error explaining how to get from a given `Value` to a
pointer to some `comptime var` (or a comptime field). Previously, this
error could be very opaque in any case where it wasn't obvious where the
comptime var pointer came from; particularly for type captures. Now, the
error notes explain this to the user.

12 files changed, 567 insertions(+), 228 deletions(-)

lib
- std
  - zig
    AstGen.zig
    Zir.zig
src
test
- cases
  - compile_errors
    compile_log_a_pointer_to_an_opaque_value.zig
    comptime_var_referenced_at_runtime.zig
    comptime_var_referenced_by_decl.zig
    comptime_var_referenced_by_type.zig
  - comptime_aggregate_print.zig

lib/std/zig/AstGen.zig+41-22

 @@ -5315,8 +5315,9 @@ fn structDeclInner(
     const fields_slice = wip_members.fieldsSlice();
     const bodies_slice = astgen.scratch.items[bodies_start..];
     try astgen.extra.ensureUnusedCapacity(gpa, backing_int_body_len + 2 +
-        decls_slice.len + namespace.captures.count() + fields_slice.len + bodies_slice.len);
+        decls_slice.len + namespace.captures.count() * 2 + fields_slice.len + bodies_slice.len);
     astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
+    astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
     if (backing_int_ref != .none) {
         astgen.extra.appendAssumeCapacity(@intCast(backing_int_body_len));
         if (backing_int_body_len == 0) {
 @@ -5595,8 +5596,9 @@ fn unionDeclInner(
     wip_members.finishBits(bits_per_field);
     const decls_slice = wip_members.declsSlice();
     const fields_slice = wip_members.fieldsSlice();
-    try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() + decls_slice.len + body_len + fields_slice.len);
+    try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() * 2 + decls_slice.len + body_len + fields_slice.len);
     astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
+    astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
     astgen.extra.appendSliceAssumeCapacity(decls_slice);
     astgen.appendBodyWithFixups(body);
     astgen.extra.appendSliceAssumeCapacity(fields_slice);
 @@ -5855,8 +5857,9 @@ fn containerDecl(
             wip_members.finishBits(bits_per_field);
             const decls_slice = wip_members.declsSlice();
             const fields_slice = wip_members.fieldsSlice();
-            try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() + decls_slice.len + body_len + fields_slice.len);
+            try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() * 2 + decls_slice.len + body_len + fields_slice.len);
             astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
+            astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
             astgen.extra.appendSliceAssumeCapacity(decls_slice);
             astgen.appendBodyWithFixups(body);
             astgen.extra.appendSliceAssumeCapacity(fields_slice);
 @@ -5910,8 +5913,9 @@ fn containerDecl(
             wip_members.finishBits(0);
             const decls_slice = wip_members.declsSlice();
-            try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() + decls_slice.len);
+            try astgen.extra.ensureUnusedCapacity(gpa, namespace.captures.count() * 2 + decls_slice.len);
             astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.keys()));
+            astgen.extra.appendSliceAssumeCapacity(@ptrCast(namespace.captures.values()));
             astgen.extra.appendSliceAssumeCapacity(decls_slice);
             block_scope.unstack();
 @@ -8548,6 +8552,7 @@ fn localVarRef(
                     num_namespaces_out,
                     .{ .ref = local_val.inst },
                     .{ .token = local_val.token_src },
+                    name_str_index,
                 ) else local_val.inst;
                 return rvalueNoCoercePreRef(gz, ri, value_inst, ident);
 @@ -8580,6 +8585,7 @@ fn localVarRef(
                             num_namespaces_out,
                             .{ .ref = local_ptr.ptr },
                             .{ .token = local_ptr.token_src },
+                            name_str_index,
                         ) else local_ptr.ptr;
                         local_ptr.used_as_lvalue = true;
                         return ptr_inst;
 @@ -8591,6 +8597,7 @@ fn localVarRef(
                             num_namespaces_out,
                             .{ .ref_load = local_ptr.ptr },
                             .{ .token = local_ptr.token_src },
+                            name_str_index,
                         ) else try gz.addUnNode(.load, local_ptr.ptr, ident);
                         return rvalueNoCoercePreRef(gz, ri, val_inst, ident);
                     },
 @@ -8636,6 +8643,7 @@ fn localVarRef(
                 found_namespaces_out,
                 .{ .decl_ref = name_str_index },
                 .{ .node = found_already.? },
+                name_str_index,
             ),
             else => {
                 const result = try tunnelThroughClosure(
 @@ -8644,6 +8652,7 @@ fn localVarRef(
                     found_namespaces_out,
                     .{ .decl_val = name_str_index },
                     .{ .node = found_already.? },
+                    name_str_index,
                 );
                 return rvalueNoCoercePreRef(gz, ri, result, ident);
             },
 @@ -8680,6 +8689,7 @@ fn tunnelThroughClosure(
         token: Ast.TokenIndex,
         node: Ast.Node.Index,
     },
+    name_str_index: Zir.NullTerminatedString,
 ) !Zir.Inst.Ref {
     switch (value) {
         .ref => |v| if (v.toIndex() == null) return v, // trivial value; do not need tunnel
 @@ -8714,34 +8724,43 @@ fn tunnelThroughClosure(
     // Now that we know the scopes we're tunneling through, begin adding
     // captures as required, starting with the outermost namespace.
-    const root_capture = Zir.Inst.Capture.wrap(switch (value) {
+    const root_capture: Zir.Inst.Capture = .wrap(switch (value) {
         .ref => |v| .{ .instruction = v.toIndex().? },
         .ref_load => |v| .{ .instruction_load = v.toIndex().? },
         .decl_val => |str| .{ .decl_val = str },
         .decl_ref => |str| .{ .decl_ref = str },
     });
-    var cur_capture_index = std.math.cast(
-        u16,
-        (try root_ns.captures.getOrPut(gpa, root_capture)).index,
-    ) orelse return astgen.failNodeNotes(root_ns.node, "this compiler implementation only supports up to 65536 captures per namespace", .{}, &.{
-        switch (decl_src) {
-            .token => |t| try astgen.errNoteTok(t, "captured value here", .{}),
-            .node => |n| try astgen.errNoteNode(n, "captured value here", .{}),
-        },
-        try astgen.errNoteNode(inner_ref_node, "value used here", .{}),
-    });
-    for (intermediate_tunnels) |tunnel_ns| {
+    const root_gop = try root_ns.captures.getOrPut(gpa, root_capture);
-        cur_capture_index = std.math.cast(
+    root_gop.value_ptr.* = name_str_index;
-            u16,
+    var cur_capture_index = std.math.cast(u16, root_gop.index) orelse return astgen.failNodeNotes(
-            (try tunnel_ns.captures.getOrPut(gpa, Zir.Inst.Capture.wrap(.{ .nested = cur_capture_index }))).index,
+        root_ns.node,
-        ) orelse return astgen.failNodeNotes(tunnel_ns.node, "this compiler implementation only supports up to 65536 captures per namespace", .{}, &.{
+        "this compiler implementation only supports up to 65536 captures per namespace",
+        .{},
+        &.{
             switch (decl_src) {
                 .token => |t| try astgen.errNoteTok(t, "captured value here", .{}),
                 .node => |n| try astgen.errNoteNode(n, "captured value here", .{}),
             },
             try astgen.errNoteNode(inner_ref_node, "value used here", .{}),
-        });
+        },
+    );
+    for (intermediate_tunnels) |tunnel_ns| {
+        const tunnel_gop = try tunnel_ns.captures.getOrPut(gpa, .wrap(.{ .nested = cur_capture_index }));
+        tunnel_gop.value_ptr.* = name_str_index;
+        cur_capture_index = std.math.cast(u16, tunnel_gop.index) orelse return astgen.failNodeNotes(
+            tunnel_ns.node,
+            "this compiler implementation only supports up to 65536 captures per namespace",
+            .{},
+            &.{
+                switch (decl_src) {
+                    .token => |t| try astgen.errNoteTok(t, "captured value here", .{}),
+                    .node => |n| try astgen.errNoteNode(n, "captured value here", .{}),
+                },
+                try astgen.errNoteNode(inner_ref_node, "value used here", .{}),
+            },
+        );
     }
     // Incorporate the capture index into the source hash, so that changes in
 @@ -11920,7 +11939,7 @@ const Scope = struct {
         declaring_gz: ?*GenZir,
         /// Set of captures used by this namespace.
-        captures: std.AutoArrayHashMapUnmanaged(Zir.Inst.Capture, void) = .empty,
+        captures: std.AutoArrayHashMapUnmanaged(Zir.Inst.Capture, Zir.NullTerminatedString) = .empty,
         fn deinit(self: *Namespace, gpa: Allocator) void {
             self.decls.deinit(gpa);

lib/std/zig/Zir.zig+27-23

 @@ -3284,24 +3284,25 @@ pub const Inst = struct {
     /// 1. fields_len: u32, // if has_fields_len
     /// 2. decls_len: u32, // if has_decls_len
     /// 3. capture: Capture // for every captures_len
-    /// 4. backing_int_body_len: u32, // if has_backing_int
+    /// 4. capture_name: NullTerminatedString // for every captures_len
-    /// 5. backing_int_ref: Ref, // if has_backing_int and backing_int_body_len is 0
+    /// 5. backing_int_body_len: u32, // if has_backing_int
-    /// 6. backing_int_body_inst: Inst, // if has_backing_int and backing_int_body_len is > 0
+    /// 6. backing_int_ref: Ref, // if has_backing_int and backing_int_body_len is 0
-    /// 7. decl: Index, // for every decls_len; points to a `declaration` instruction
+    /// 7. backing_int_body_inst: Inst, // if has_backing_int and backing_int_body_len is > 0
-    /// 8. flags: u32 // for every 8 fields
+    /// 8. decl: Index, // for every decls_len; points to a `declaration` instruction
+    /// 9. flags: u32 // for every 8 fields
     ///    - sets of 4 bits:
     ///      0b000X: whether corresponding field has an align expression
     ///      0b00X0: whether corresponding field has a default expression
     ///      0b0X00: whether corresponding field is comptime
     ///      0bX000: whether corresponding field has a type expression
-    /// 9. fields: { // for every fields_len
+    /// 10. fields: { // for every fields_len
     ///        field_name: u32,
     ///        field_type: Ref, // if corresponding bit is not set. none means anytype.
     ///        field_type_body_len: u32, // if corresponding bit is set
     ///        align_body_len: u32, // if corresponding bit is set
     ///        init_body_len: u32, // if corresponding bit is set
     ///    }
-    /// 10. bodies: { // for every fields_len
+    /// 11. bodies: { // for every fields_len
     ///        field_type_body_inst: Inst, // for each field_type_body_len
     ///        align_body_inst: Inst, // for each align_body_len
     ///        init_body_inst: Inst, // for each init_body_len
 @@ -3450,11 +3451,12 @@ pub const Inst = struct {
     /// 3. fields_len: u32, // if has_fields_len
     /// 4. decls_len: u32, // if has_decls_len
     /// 5. capture: Capture // for every captures_len
-    /// 6. decl: Index, // for every decls_len; points to a `declaration` instruction
+    /// 6. capture_name: NullTerminatedString // for every captures_len
-    /// 7. inst: Index // for every body_len
+    /// 7. decl: Index, // for every decls_len; points to a `declaration` instruction
-    /// 8. has_bits: u32 // for every 32 fields
+    /// 8. inst: Index // for every body_len
+    /// 9. has_bits: u32 // for every 32 fields
     ///    - the bit is whether corresponding field has an value expression
-    /// 9. fields: { // for every fields_len
+    /// 10. fields: { // for every fields_len
     ///        field_name: u32,
     ///        value: Ref, // if corresponding bit is set
     ///    }
 @@ -3488,15 +3490,16 @@ pub const Inst = struct {
     /// 3. fields_len: u32, // if has_fields_len
     /// 4. decls_len: u32, // if has_decls_len
     /// 5. capture: Capture // for every captures_len
-    /// 6. decl: Index, // for every decls_len; points to a `declaration` instruction
+    /// 6. capture_name: NullTerminatedString // for every captures_len
-    /// 7. inst: Index // for every body_len
+    /// 7. decl: Index, // for every decls_len; points to a `declaration` instruction
-    /// 8. has_bits: u32 // for every 8 fields
+    /// 8. inst: Index // for every body_len
+    /// 9. has_bits: u32 // for every 8 fields
     ///    - sets of 4 bits:
     ///      0b000X: whether corresponding field has a type expression
     ///      0b00X0: whether corresponding field has a align expression
     ///      0b0X00: whether corresponding field has a tag value expression
     ///      0bX000: unused
-    /// 9. fields: { // for every fields_len
+    /// 10. fields: { // for every fields_len
     ///        field_name: NullTerminatedString, // null terminated string index
     ///        field_type: Ref, // if corresponding bit is set
     ///        align: Ref, // if corresponding bit is set
 @@ -3537,7 +3540,8 @@ pub const Inst = struct {
     /// 0. captures_len: u32, // if has_captures_len
     /// 1. decls_len: u32, // if has_decls_len
     /// 2. capture: Capture, // for every captures_len
-    /// 3. decl: Index, // for every decls_len; points to a `declaration` instruction
+    /// 3. capture_name: NullTerminatedString // for every captures_len
+    /// 4. decl: Index, // for every decls_len; points to a `declaration` instruction
     pub const OpaqueDecl = struct {
         src_line: u32,
         /// This node provides a new absolute baseline node for all instructions within this struct.
 @@ -3852,7 +3856,7 @@ pub fn declIterator(zir: Zir, decl_inst: Zir.Inst.Index) DeclIterator {
                 break :decls_len decls_len;
             } else 0;
-            extra_index += captures_len;
+            extra_index += captures_len * 2;
             if (small.has_backing_int) {
                 const backing_int_body_len = zir.extra[extra_index];
 @@ -3887,7 +3891,7 @@ pub fn declIterator(zir: Zir, decl_inst: Zir.Inst.Index) DeclIterator {
                 break :decls_len decls_len;
             } else 0;
-            extra_index += captures_len;
+            extra_index += captures_len * 2;
             return .{
                 .extra_index = extra_index,
 @@ -3912,7 +3916,7 @@ pub fn declIterator(zir: Zir, decl_inst: Zir.Inst.Index) DeclIterator {
                 break :decls_len decls_len;
             } else 0;
-            extra_index += captures_len;
+            extra_index += captures_len * 2;
             return .{
                 .extra_index = extra_index,
 @@ -3934,7 +3938,7 @@ pub fn declIterator(zir: Zir, decl_inst: Zir.Inst.Index) DeclIterator {
                 break :captures_len captures_len;
             } else 0;
-            extra_index += captures_len;
+            extra_index += captures_len * 2;
             return .{
                 .extra_index = extra_index,
 @@ -4349,7 +4353,7 @@ fn findTrackableInner(
                         extra_index += 1;
                         break :blk decls_len;
                     } else 0;
-                    extra_index += captures_len;
+                    extra_index += captures_len * 2;
                     if (small.has_backing_int) {
                         const backing_int_body_len = zir.extra[extra_index];
                         extra_index += 1;
 @@ -4441,7 +4445,7 @@ fn findTrackableInner(
                         extra_index += 1;
                         break :blk decls_len;
                     } else 0;
-                    extra_index += captures_len;
+                    extra_index += captures_len * 2;
                     extra_index += decls_len;
                     const body = zir.bodySlice(extra_index, body_len);
                     try zir.findTrackableBody(gpa, contents, defers, body);
 @@ -4471,7 +4475,7 @@ fn findTrackableInner(
                         extra_index += 1;
                         break :blk decls_len;
                     } else 0;
-                    extra_index += captures_len;
+                    extra_index += captures_len * 2;
                     extra_index += decls_len;
                     const body = zir.bodySlice(extra_index, body_len);
                     try zir.findTrackableBody(gpa, contents, defers, body);

src/Sema.zig+224-36

 @@ -134,6 +134,7 @@ const MaybeComptimeAlloc = struct {
 const ComptimeAlloc = struct {
     val: MutableValue,
     is_const: bool,
+    src: LazySrcLoc,
     /// `.none` indicates that the alignment is the natural alignment of `val`.
     alignment: Alignment,
     /// This is the `runtime_index` at the point of this allocation. If an store
 @@ -142,11 +143,13 @@ const ComptimeAlloc = struct {
     runtime_index: RuntimeIndex,
 };
-fn newComptimeAlloc(sema: *Sema, block: *Block, ty: Type, alignment: Alignment) !ComptimeAllocIndex {
+/// `src` may be `null` if `is_const` will be set.
+fn newComptimeAlloc(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type, alignment: Alignment) !ComptimeAllocIndex {
     const idx = sema.comptime_allocs.items.len;
     try sema.comptime_allocs.append(sema.gpa, .{
         .val = .{ .interned = try sema.pt.intern(.{ .undef = ty.toIntern() }) },
         .is_const = false,
+        .src = src,
         .alignment = alignment,
         .runtime_index = block.runtime_index,
     });
 @@ -1308,7 +1311,7 @@ fn analyzeBodyInner(
             .shl_exact => try sema.zirShl(block, inst, .shl_exact),
             .shl_sat   => try sema.zirShl(block, inst, .shl_sat),
-            .ret_ptr  => try sema.zirRetPtr(block),
+            .ret_ptr  => try sema.zirRetPtr(block, inst),
             .ret_type => Air.internedToRef(sema.fn_ret_ty.toIntern()),
             // Instructions that we know to *always* be noreturn based solely on their tag.
 @@ -2301,7 +2304,9 @@ pub fn resolveFinalDeclValue(
     };
     if (val.canMutateComptimeVarState(zcu)) {
-        return sema.fail(block, src, "global variable contains reference to comptime var", .{});
+        const ip = &zcu.intern_pool;
+        const nav = ip.getNav(sema.owner.unwrap().nav_val);
+        return sema.failWithContainsReferenceToComptimeVar(block, src, nav.name, "global variable", val);
     }
     return val;
 @@ -2757,7 +2762,8 @@ fn zirTupleDecl(
                 const coerced_field_init = try sema.coerce(block, field_type, uncoerced_field_init, init_src);
                 const field_init_val = try sema.resolveConstDefinedValue(block, init_src, coerced_field_init, .{ .simple = .tuple_field_default_value });
                 if (field_init_val.canMutateComptimeVarState(zcu)) {
-                    return sema.fail(block, init_src, "field default value contains reference to comptime-mutable memory", .{});
+                    const field_name = try zcu.intern_pool.getOrPutStringFmt(gpa, pt.tid, "{}", .{field_index}, .no_embedded_nulls);
+                    return sema.failWithContainsReferenceToComptimeVar(block, init_src, field_name, "field default value", field_init_val);
                 }
                 break :init field_init_val.toIntern();
             }
 @@ -2813,8 +2819,10 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
     const captures = try sema.arena.alloc(InternPool.CaptureValue, captures_len);
-    for (sema.code.extra[extra_index..][0..captures_len], captures) |raw, *capture| {
+    for (sema.code.extra[extra_index..][0..captures_len], sema.code.extra[extra_index + captures_len ..][0..captures_len], captures) |raw, raw_name, *capture| {
         const zir_capture: Zir.Inst.Capture = @bitCast(raw);
+        const zir_name: Zir.NullTerminatedString = @enumFromInt(raw_name);
+        const zir_name_slice = sema.code.nullTerminatedString(zir_name);
         capture.* = switch (zir_capture.unwrap()) {
             .nested => |parent_idx| parent_captures.get(ip)[parent_idx],
             .instruction_load => |ptr_inst| InternPool.CaptureValue.wrap(capture: {
 @@ -2828,8 +2836,8 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
                 };
                 const loaded_val = try sema.resolveLazyValue(unresolved_loaded_val);
                 if (loaded_val.canMutateComptimeVarState(zcu)) {
-                    // TODO: source location of captured value
+                    const field_name = try ip.getOrPutString(zcu.gpa, pt.tid, zir_name_slice, .no_embedded_nulls);
-                    return sema.fail(block, type_src, "type capture contains reference to comptime var", .{});
+                    return sema.failWithContainsReferenceToComptimeVar(block, type_src, field_name, "captured value", loaded_val);
                 }
                 break :capture .{ .@"comptime" = loaded_val.toIntern() };
             }),
 @@ -2837,8 +2845,8 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
                 const air_ref = try sema.resolveInst(inst.toRef());
                 if (try sema.resolveValueResolveLazy(air_ref)) |val| {
                     if (val.canMutateComptimeVarState(zcu)) {
-                        // TODO: source location of captured value
+                        const field_name = try ip.getOrPutString(zcu.gpa, pt.tid, zir_name_slice, .no_embedded_nulls);
-                        return sema.fail(block, type_src, "type capture contains reference to comptime var", .{});
+                        return sema.failWithContainsReferenceToComptimeVar(block, type_src, field_name, "captured value", val);
                     }
                     break :capture .{ .@"comptime" = val.toIntern() };
                 }
 @@ -2908,7 +2916,7 @@ fn zirStructDecl(
     } else 0;
     const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len;
+    extra_index += captures_len * 2;
     if (small.has_backing_int) {
         const backing_int_body_len = sema.code.extra[extra_index];
 @@ -3132,7 +3140,7 @@ fn zirEnumDecl(
     } else 0;
     const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len;
+    extra_index += captures_len * 2;
     const decls = sema.code.bodySlice(extra_index, decls_len);
     extra_index += decls_len;
 @@ -3275,7 +3283,7 @@ fn zirUnionDecl(
     } else 0;
     const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len;
+    extra_index += captures_len * 2;
     const union_init: InternPool.UnionTypeInit = .{
         .flags = .{
 @@ -3393,7 +3401,7 @@ fn zirOpaqueDecl(
     } else 0;
     const captures = try sema.getCaptures(block, src, extra_index, captures_len);
-    extra_index += captures_len;
+    extra_index += captures_len * 2;
     const opaque_init: InternPool.OpaqueTypeInit = .{
         .key = .{ .declared = .{
 @@ -3474,15 +3482,17 @@ fn zirErrorSetDecl(
     return Air.internedToRef((try pt.errorSetFromUnsortedNames(names.keys())).toIntern());
 }
-fn zirRetPtr(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
+fn zirRetPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const tracy = trace(@src());
     defer tracy.end();
     const pt = sema.pt;
+    const src = block.nodeOffset(sema.code.instructions.items(.data)[@intFromEnum(inst)].node);
     if (block.isComptime() or try sema.fn_ret_ty.comptimeOnlySema(pt)) {
         try sema.fn_ret_ty.resolveFields(pt);
-        return sema.analyzeComptimeAlloc(block, sema.fn_ret_ty, .none);
+        return sema.analyzeComptimeAlloc(block, src, sema.fn_ret_ty, .none);
     }
     const target = pt.zcu.getTarget();
 @@ -3658,6 +3668,7 @@ fn zirAllocExtended(
     const extra = sema.code.extraData(Zir.Inst.AllocExtended, extended.operand);
     const ty_src = block.src(.{ .node_offset_var_decl_ty = extra.data.src_node });
     const align_src = block.src(.{ .node_offset_var_decl_align = extra.data.src_node });
+    const init_src = block.src(.{ .node_offset_var_decl_init = extra.data.src_node });
     const small: Zir.Inst.AllocExtended.Small = @bitCast(extended.small);
     var extra_index: usize = extra.end;
 @@ -3676,7 +3687,7 @@ fn zirAllocExtended(
     if (block.isComptime() or small.is_comptime) {
         if (small.has_type) {
-            return sema.analyzeComptimeAlloc(block, var_ty, alignment);
+            return sema.analyzeComptimeAlloc(block, init_src, var_ty, alignment);
         } else {
             try sema.air_instructions.append(gpa, .{
                 .tag = .inferred_alloc_comptime,
 @@ -3691,7 +3702,7 @@ fn zirAllocExtended(
     }
     if (small.has_type and try var_ty.comptimeOnlySema(pt)) {
-        return sema.analyzeComptimeAlloc(block, var_ty, alignment);
+        return sema.analyzeComptimeAlloc(block, init_src, var_ty, alignment);
     }
     if (small.has_type) {
 @@ -3741,8 +3752,9 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
+    const init_src = block.src(.{ .node_offset_var_decl_init = inst_data.src_node });
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
-    return sema.analyzeComptimeAlloc(block, var_ty, .none);
+    return sema.analyzeComptimeAlloc(block, init_src, var_ty, .none);
 }
 fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
 @@ -3860,7 +3872,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref,
     // The simple strategy failed: we must create a mutable comptime alloc and
     // perform all of the runtime store operations at comptime.
-    const ct_alloc = try sema.newComptimeAlloc(block, elem_ty, ptr_info.flags.alignment);
+    const ct_alloc = try sema.newComptimeAlloc(block, .unneeded, elem_ty, ptr_info.flags.alignment);
     const alloc_ptr = try pt.intern(.{ .ptr = .{
         .ty = alloc_ty.toIntern(),
 @@ -4073,7 +4085,7 @@ fn finishResolveComptimeKnownAllocPtr(
     if (Value.fromInterned(result_val).canMutateComptimeVarState(zcu)) {
         const alloc_index = existing_comptime_alloc orelse a: {
-            const idx = try sema.newComptimeAlloc(block, alloc_ty.childType(zcu), alloc_ty.ptrAlignment(zcu));
+            const idx = try sema.newComptimeAlloc(block, .unneeded, alloc_ty.childType(zcu), alloc_ty.ptrAlignment(zcu));
             const alloc = sema.getComptimeAlloc(idx);
             alloc.val = .{ .interned = result_val };
             break :a idx;
 @@ -4139,10 +4151,11 @@ fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
+    const init_src = block.src(.{ .node_offset_var_decl_init = inst_data.src_node });
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
     if (block.isComptime() or try var_ty.comptimeOnlySema(pt)) {
-        return sema.analyzeComptimeAlloc(block, var_ty, .none);
+        return sema.analyzeComptimeAlloc(block, init_src, var_ty, .none);
     }
     if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
         const mut_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
 @@ -4168,9 +4181,10 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node;
     const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node });
+    const init_src = block.src(.{ .node_offset_var_decl_init = inst_data.src_node });
     const var_ty = try sema.resolveType(block, ty_src, inst_data.operand);
     if (block.isComptime()) {
-        return sema.analyzeComptimeAlloc(block, var_ty, .none);
+        return sema.analyzeComptimeAlloc(block, init_src, var_ty, .none);
     }
     if (sema.func_is_naked and try var_ty.hasRuntimeBitsSema(pt)) {
         const var_src = block.src(.{ .node_offset_store_ptr = inst_data.src_node });
 @@ -5726,7 +5740,7 @@ fn storeToInferredAllocComptime(
             .byte_offset = 0,
         } });
     } else {
-        const alloc_index = try sema.newComptimeAlloc(block, operand_ty, iac.alignment);
+        const alloc_index = try sema.newComptimeAlloc(block, src, operand_ty, iac.alignment);
         sema.getComptimeAlloc(alloc_index).val = .{ .interned = operand_val.toIntern() };
         iac.ptr = try pt.intern(.{ .ptr = .{
             .ty = alloc_ty.toIntern(),
 @@ -31206,14 +31220,7 @@ fn markMaybeComptimeAllocRuntime(sema: *Sema, block: *Block, alloc_inst: Air.Ins
         }
         const other_data = sema.air_instructions.items(.data)[@intFromEnum(other_inst)].bin_op;
         const other_operand = other_data.rhs;
-        if (!sema.checkRuntimeValue(other_operand)) {
+        try sema.validateRuntimeValue(block, other_src, other_operand);
-            return sema.failWithOwnedErrorMsg(block, msg: {
-                const msg = try sema.errMsg(other_src, "runtime value contains reference to comptime var", .{});
-                errdefer msg.destroy(sema.gpa);
-                try sema.errNote(other_src, msg, "comptime var pointers are not available at runtime", .{});
-                break :msg msg;
-            });
-        }
     }
 }
 @@ -35328,7 +35335,7 @@ fn backingIntType(
         extra_index += @intFromBool(small.has_fields_len);
         extra_index += @intFromBool(small.has_decls_len);
-        extra_index += captures_len;
+        extra_index += captures_len * 2;
         const backing_int_body_len = zir.extra[extra_index];
         extra_index += 1;
 @@ -35904,7 +35911,7 @@ fn structZirInfo(zir: Zir, zir_index: Zir.Inst.Index) struct {
         break :decls_len decls_len;
     } else 0;
-    extra_index += captures_len;
+    extra_index += captures_len * 2;
     // The backing integer cannot be handled until `resolveStructLayout()`.
     if (small.has_backing_int) {
 @@ -36233,7 +36240,8 @@ fn structFieldInits(
             const default_val = try sema.resolveConstValue(&block_scope, init_src, coerced, null);
             if (default_val.canMutateComptimeVarState(zcu)) {
-                return sema.fail(&block_scope, init_src, "field default value contains reference to comptime-mutable memory", .{});
+                const field_name = struct_type.fieldName(ip, field_i).unwrap().?;
+                return sema.failWithContainsReferenceToComptimeVar(&block_scope, init_src, field_name, "field default value", default_val);
             }
             struct_type.field_inits.get(ip)[field_i] = default_val.toIntern();
         }
 @@ -36293,7 +36301,7 @@ fn unionFields(
     } else 0;
     // Skip over captures and decls.
-    extra_index += captures_len + decls_len;
+    extra_index += captures_len * 2 + decls_len;
     const body = zir.bodySlice(extra_index, body_len);
     extra_index += body.len;
 @@ -37055,6 +37063,7 @@ fn isComptimeKnown(
 fn analyzeComptimeAlloc(
     sema: *Sema,
     block: *Block,
+    src: LazySrcLoc,
     var_type: Type,
     alignment: Alignment,
 ) CompileError!Air.Inst.Ref {
 @@ -37072,7 +37081,7 @@ fn analyzeComptimeAlloc(
         },
     });
-    const alloc = try sema.newComptimeAlloc(block, var_type, alignment);
+    const alloc = try sema.newComptimeAlloc(block, src, var_type, alignment);
     return Air.internedToRef((try pt.intern(.{ .ptr = .{
         .ty = ptr_type.toIntern(),
 @@ -37979,10 +37988,189 @@ fn validateRuntimeValue(sema: *Sema, block: *Block, val_src: LazySrcLoc, val: Ai
         const msg = try sema.errMsg(val_src, "runtime value contains reference to comptime var", .{});
         errdefer msg.destroy(sema.gpa);
         try sema.errNote(val_src, msg, "comptime var pointers are not available at runtime", .{});
+        const pt = sema.pt;
+        const zcu = pt.zcu;
+        const val_str = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, "runtime_value", .no_embedded_nulls);
+        try sema.explainWhyValueContainsReferenceToComptimeVar(msg, val_src, val_str, .fromInterned(val.toInterned().?));
+        break :msg msg;
+    });
+}
+fn failWithContainsReferenceToComptimeVar(sema: *Sema, block: *Block, src: LazySrcLoc, value_name: InternPool.NullTerminatedString, kind_of_value: []const u8, val: ?Value) CompileError {
+    return sema.failWithOwnedErrorMsg(block, msg: {
+        const msg = try sema.errMsg(src, "{s} contains reference to comptime var", .{kind_of_value});
+        errdefer msg.destroy(sema.gpa);
+        if (val) |v| try sema.explainWhyValueContainsReferenceToComptimeVar(msg, src, value_name, v);
         break :msg msg;
     });
 }
+fn explainWhyValueContainsReferenceToComptimeVar(sema: *Sema, msg: *Zcu.ErrorMsg, src: LazySrcLoc, value_name: InternPool.NullTerminatedString, val: Value) Allocator.Error!void {
+    // Our goal is something like this:
+    //   note: '(value.? catch unreachable)[0]' points to 'v0.?.foo'
+    //   note: '(v0.?.bar catch unreachable)' points to 'v1'
+    //   note: 'v1.?' points to a comptime var
+    var intermediate_value_count: u32 = 0;
+    var cur_val: Value = val;
+    while (true) {
+        switch (try sema.notePathToComptimeAllocPtr(msg, src, cur_val, intermediate_value_count, value_name)) {
+            .done => return,
+            .new_val => |new_val| {
+                intermediate_value_count += 1;
+                cur_val = new_val;
+            },
+        }
+    }
+}
+fn notePathToComptimeAllocPtr(sema: *Sema, msg: *Zcu.ErrorMsg, src: LazySrcLoc, val: Value, intermediate_value_count: u32, start_value_name: InternPool.NullTerminatedString) Allocator.Error!union(enum) {
+    done,
+    new_val: Value,
+} {
+    const arena = sema.arena;
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    var first_path: std.ArrayListUnmanaged(u8) = .empty;
+    if (intermediate_value_count == 0) {
+        try first_path.writer(arena).print("{i}", .{start_value_name.fmt(ip)});
+    } else {
+        try first_path.writer(arena).print("v{}", .{intermediate_value_count - 1});
+    }
+    const comptime_ptr = try sema.notePathToComptimeAllocPtrInner(val, &first_path);
+    switch (ip.indexToKey(comptime_ptr.toIntern()).ptr.base_addr) {
+        .comptime_field => {
+            try sema.errNote(src, msg, "'{s}' points to comptime field", .{first_path.items});
+            return .done;
+        },
+        .comptime_alloc => |idx| {
+            const cta = sema.getComptimeAlloc(idx);
+            if (!cta.is_const) {
+                try sema.errNote(cta.src, msg, "'{s}' points to comptime var declared here", .{first_path.items});
+                return .done;
+            }
+        },
+        else => {}, // there will be another stage
+    }
+    const derivation = comptime_ptr.pointerDerivationAdvanced(arena, pt, false, sema) catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        error.AnalysisFail => unreachable,
+    };
+    var second_path: std.ArrayListUnmanaged(u8) = .empty;
+    const inter_name = try std.fmt.allocPrint(arena, "v{d}", .{intermediate_value_count});
+    const deriv_start = @import("print_value.zig").printPtrDerivation(
+        derivation,
+        second_path.writer(arena),
+        pt,
+        .lvalue,
+        .{ .str = inter_name },
+        20,
+    ) catch |err| switch (err) {
+        error.OutOfMemory => |e| return e,
+        error.AnalysisFail => unreachable,
+        error.GenericPoison => unreachable,
+        error.ComptimeReturn => unreachable,
+        error.ComptimeBreak => unreachable,
+    };
+    switch (deriv_start) {
+        .int, .nav_ptr => unreachable,
+        .uav_ptr => |uav| {
+            try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path.items });
+            return .{ .new_val = .fromInterned(uav.val) };
+        },
+        .comptime_alloc_ptr => |cta_info| {
+            try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path.items });
+            const cta = sema.getComptimeAlloc(cta_info.idx);
+            if (cta.is_const) {
+                return .{ .new_val = cta_info.val };
+            } else {
+                try sema.errNote(cta.src, msg, "'{s}' is a comptime var declared here", .{inter_name});
+                return .done;
+            }
+        },
+        .comptime_field_ptr => {
+            try sema.errNote(src, msg, "'{s}' points to '{s}', where", .{ first_path.items, second_path.items });
+            try sema.errNote(src, msg, "'{s}' is a comptime field", .{inter_name});
+            return .done;
+        },
+        .eu_payload_ptr,
+        .opt_payload_ptr,
+        .field_ptr,
+        .elem_ptr,
+        .offset_and_cast,
+        => unreachable,
+    }
+}
+fn notePathToComptimeAllocPtrInner(sema: *Sema, val: Value, path: *std.ArrayListUnmanaged(u8)) Allocator.Error!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const ip = &zcu.intern_pool;
+    const arena = sema.arena;
+    assert(val.canMutateComptimeVarState(zcu));
+    switch (ip.indexToKey(val.toIntern())) {
+        .ptr => return val,
+        .error_union => |eu| {
+            try path.insert(arena, 0, '(');
+            try path.appendSlice(arena, " catch unreachable)");
+            return sema.notePathToComptimeAllocPtrInner(.fromInterned(eu.val.payload), path);
+        },
+        .slice => |slice| {
+            try path.appendSlice(arena, ".ptr");
+            return sema.notePathToComptimeAllocPtrInner(.fromInterned(slice.ptr), path);
+        },
+        .opt => |opt| {
+            try path.appendSlice(arena, ".?");
+            return sema.notePathToComptimeAllocPtrInner(.fromInterned(opt.val), path);
+        },
+        .un => |un| {
+            assert(un.tag != .none);
+            const union_ty: Type = .fromInterned(un.ty);
+            const backing_enum = union_ty.unionTagTypeHypothetical(zcu);
+            const field_idx = backing_enum.enumTagFieldIndex(.fromInterned(un.tag), zcu).?;
+            const field_name = backing_enum.enumFieldName(field_idx, zcu);
+            try path.writer(arena).print(".{i}", .{field_name.fmt(ip)});
+            return sema.notePathToComptimeAllocPtrInner(.fromInterned(un.val), path);
+        },
+        .aggregate => |agg| {
+            const elem: InternPool.Index, const elem_idx: usize = switch (agg.storage) {
+                .bytes => unreachable,
+                .repeated_elem => |elem| .{ elem, 0 },
+                .elems => |elems| for (elems, 0..) |elem, elem_idx| {
+                    if (Value.fromInterned(elem).canMutateComptimeVarState(zcu)) {
+                        break .{ elem, elem_idx };
+                    }
+                } else unreachable,
+            };
+            const agg_ty: Type = .fromInterned(agg.ty);
+            switch (agg_ty.zigTypeTag(zcu)) {
+                .array, .vector => try path.writer(arena).print("[{d}]", .{elem_idx}),
+                .pointer => switch (elem_idx) {
+                    Value.slice_ptr_index => try path.appendSlice(arena, ".ptr"),
+                    Value.slice_len_index => try path.appendSlice(arena, ".len"),
+                    else => unreachable,
+                },
+                .@"struct" => if (agg_ty.isTuple(zcu)) {
+                    try path.writer(arena).print("[{d}]", .{elem_idx});
+                } else {
+                    const name = agg_ty.structFieldName(elem_idx, zcu).unwrap().?;
+                    try path.writer(arena).print(".{i}", .{name.fmt(ip)});
+                },
+                else => unreachable,
+            }
+            return sema.notePathToComptimeAllocPtrInner(.fromInterned(elem), path);
+        },
+        else => unreachable,
+    }
+}
 /// Returns true if any value contained in `val` is undefined.
 fn anyUndef(sema: *Sema, block: *Block, src: LazySrcLoc, val: Value) !bool {
     const pt = sema.pt;

src/Value.zig+51-15

 @@ -4064,6 +4064,7 @@ pub const PointerDeriveStep = union(enum) {
     nav_ptr: InternPool.Nav.Index,
     uav_ptr: InternPool.Key.Ptr.BaseAddr.Uav,
     comptime_alloc_ptr: struct {
+        idx: InternPool.ComptimeAllocIndex,
         val: Value,
         ptr_ty: Type,
     },
 @@ -4110,7 +4111,7 @@ pub const PointerDeriveStep = union(enum) {
 };
 pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread) Allocator.Error!PointerDeriveStep {
-    return ptr_val.pointerDerivationAdvanced(arena, pt, false, {}) catch |err| switch (err) {
+    return ptr_val.pointerDerivationAdvanced(arena, pt, false, null) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
         error.AnalysisFail => unreachable,
     };
 @@ -4120,7 +4121,7 @@ pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread) Al
 /// only field and element pointers with no casts. This can be used by codegen backends
 /// which prefer field/elem accesses when lowering constant pointer values.
 /// It is also used by the Value printing logic for pointers.
-pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, comptime have_sema: bool, sema: if (have_sema) *Sema else void) !PointerDeriveStep {
+pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, comptime resolve_types: bool, opt_sema: ?*Sema) !PointerDeriveStep {
     const zcu = pt.zcu;
     const ptr = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
     const base_derive: PointerDeriveStep = switch (ptr.base_addr) {
 @@ -4143,11 +4144,12 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             } };
         },
         .comptime_alloc => |idx| base: {
-            if (!have_sema) unreachable;
+            const sema = opt_sema.?;
             const alloc = sema.getComptimeAlloc(idx);
             const val = try alloc.val.intern(pt, sema.arena);
             const ty = val.typeOf(zcu);
             break :base .{ .comptime_alloc_ptr = .{
+                .idx = idx,
                 .val = val,
                 .ptr_ty = try pt.ptrType(.{
                     .child = ty.toIntern(),
 @@ -4162,7 +4164,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const base_ptr = Value.fromInterned(eu_ptr);
             const base_ptr_ty = base_ptr.typeOf(zcu);
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(eu_ptr), arena, pt, have_sema, sema);
+            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(eu_ptr), arena, pt, resolve_types, opt_sema);
             break :base .{ .eu_payload_ptr = .{
                 .parent = parent_step,
                 .result_ptr_ty = try pt.adjustPtrTypeChild(base_ptr_ty, base_ptr_ty.childType(zcu).errorUnionPayload(zcu)),
 @@ -4172,7 +4174,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const base_ptr = Value.fromInterned(opt_ptr);
             const base_ptr_ty = base_ptr.typeOf(zcu);
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(opt_ptr), arena, pt, have_sema, sema);
+            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(opt_ptr), arena, pt, resolve_types, opt_sema);
             break :base .{ .opt_payload_ptr = .{
                 .parent = parent_step,
                 .result_ptr_ty = try pt.adjustPtrTypeChild(base_ptr_ty, base_ptr_ty.childType(zcu).optionalChild(zcu)),
 @@ -4185,15 +4187,15 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             const field_ty, const field_align = switch (agg_ty.zigTypeTag(zcu)) {
                 .@"struct" => .{ agg_ty.fieldType(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner(
                     @intCast(field.index),
-                    if (have_sema) .sema else .normal,
+                    if (resolve_types) .sema else .normal,
                     pt.zcu,
-                    if (have_sema) pt.tid else {},
+                    if (resolve_types) pt.tid else {},
                 ) },
                 .@"union" => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.fieldAlignmentInner(
                     @intCast(field.index),
-                    if (have_sema) .sema else .normal,
+                    if (resolve_types) .sema else .normal,
                     pt.zcu,
-                    if (have_sema) pt.tid else {},
+                    if (resolve_types) pt.tid else {},
                 ) },
                 .pointer => .{ switch (field.index) {
                     Value.slice_ptr_index => agg_ty.slicePtrFieldType(zcu),
 @@ -4217,7 +4219,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
                 },
             });
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(base_ptr, arena, pt, have_sema, sema);
+            parent_step.* = try pointerDerivationAdvanced(base_ptr, arena, pt, resolve_types, opt_sema);
             break :base .{ .field_ptr = .{
                 .parent = parent_step,
                 .field_idx = @intCast(field.index),
 @@ -4226,7 +4228,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
         },
         .arr_elem => |arr_elem| base: {
             const parent_step = try arena.create(PointerDeriveStep);
-            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(arr_elem.base), arena, pt, have_sema, sema);
+            parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(arr_elem.base), arena, pt, resolve_types, opt_sema);
             const parent_ptr_info = (try parent_step.ptrType(pt)).ptrInfo(zcu);
             const result_ptr_ty = try pt.ptrType(.{
                 .child = parent_ptr_info.child,
 @@ -4248,7 +4250,8 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
         return base_derive;
     }
-    const need_child = Type.fromInterned(ptr.ty).childType(zcu);
+    const ptr_ty_info = Type.fromInterned(ptr.ty).ptrInfo(zcu);
+    const need_child: Type = .fromInterned(ptr_ty_info.child);
     if (need_child.comptimeOnly(zcu)) {
         // No refinement can happen - this pointer is presumably invalid.
         // Just offset it.
 @@ -4293,16 +4296,34 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
             .frame,
             .@"enum",
             .vector,
-            .optional,
             .@"union",
             => break,
+            .optional => {
+                ptr_opt: {
+                    if (!cur_ty.isPtrLikeOptional(zcu)) break :ptr_opt;
+                    if (need_child.zigTypeTag(zcu) != .pointer) break :ptr_opt;
+                    switch (need_child.ptrSize(zcu)) {
+                        .One, .Many => {},
+                        .Slice, .C => break :ptr_opt,
+                    }
+                    const parent = try arena.create(PointerDeriveStep);
+                    parent.* = cur_derive;
+                    cur_derive = .{ .opt_payload_ptr = .{
+                        .parent = parent,
+                        .result_ptr_ty = try pt.adjustPtrTypeChild(try parent.ptrType(pt), cur_ty.optionalChild(zcu)),
+                    } };
+                    continue;
+                }
+                break;
+            },
             .array => {
                 const elem_ty = cur_ty.childType(zcu);
                 const elem_size = elem_ty.abiSize(zcu);
                 const start_idx = cur_offset / elem_size;
                 const end_idx = (cur_offset + need_bytes + elem_size - 1) / elem_size;
-                if (end_idx == start_idx + 1) {
+                if (end_idx == start_idx + 1 and ptr_ty_info.flags.size == .One) {
                     const parent = try arena.create(PointerDeriveStep);
                     parent.* = cur_derive;
                     cur_derive = .{ .elem_ptr = .{
 @@ -4363,7 +4384,22 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
         }
     };
-    if (cur_offset == 0 and (try cur_derive.ptrType(pt)).toIntern() == ptr.ty) {
+    if (cur_offset == 0) compatible: {
+        const src_ptr_ty_info = (try cur_derive.ptrType(pt)).ptrInfo(zcu);
+        // We allow silently doing some "coercible" pointer things.
+        // In particular, we only give up if cv qualifiers are *removed*.
+        if (src_ptr_ty_info.flags.is_const and !ptr_ty_info.flags.is_const) break :compatible;
+        if (src_ptr_ty_info.flags.is_volatile and !ptr_ty_info.flags.is_volatile) break :compatible;
+        if (src_ptr_ty_info.flags.is_allowzero and !ptr_ty_info.flags.is_allowzero) break :compatible;
+        // Everything else has to match exactly.
+        if (src_ptr_ty_info.child != ptr_ty_info.child) break :compatible;
+        if (src_ptr_ty_info.sentinel != ptr_ty_info.sentinel) break :compatible;
+        if (src_ptr_ty_info.packed_offset != ptr_ty_info.packed_offset) break :compatible;
+        if (src_ptr_ty_info.flags.size != ptr_ty_info.flags.size) break :compatible;
+        if (src_ptr_ty_info.flags.alignment != ptr_ty_info.flags.alignment) break :compatible;
+        if (src_ptr_ty_info.flags.address_space != ptr_ty_info.flags.address_space) break :compatible;
+        if (src_ptr_ty_info.flags.vector_index != ptr_ty_info.flags.vector_index) break :compatible;
         return cur_derive;
     }

src/Zcu/PerThread.zig+5-5

...	@@ -3944,7 +3944,7 @@ fn recreateEnumType(	...	@@ -3944,7 +3944,7 @@ fn recreateEnumType(
3944		3944
3945	assert(captures_len == key.captures.owned.len); // synchronises with logic in `Zcu.mapOldZirToNew`	3945	assert(captures_len == key.captures.owned.len); // synchronises with logic in `Zcu.mapOldZirToNew`
3946		3946
3947	extra_index += captures_len;	3947	extra_index += captures_len * 2;
3948	extra_index += decls_len;	3948	extra_index += decls_len;
3949		3949
3950	const body = zir.bodySlice(extra_index, body_len);	3950	const body = zir.bodySlice(extra_index, body_len);
...	@@ -4071,7 +4071,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace	...	@@ -4071,7 +4071,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
4071	extra_index += 1;	4071	extra_index += 1;
4072	break :blk decls_len;	4072	break :blk decls_len;
4073	} else 0;	4073	} else 0;
4074	extra_index += captures_len;	4074	extra_index += captures_len * 2;
4075	if (small.has_backing_int) {	4075	if (small.has_backing_int) {
4076	const backing_int_body_len = zir.extra[extra_index];	4076	const backing_int_body_len = zir.extra[extra_index];
4077	extra_index += 1; // backing_int_body_len	4077	extra_index += 1; // backing_int_body_len
...	@@ -4101,7 +4101,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace	...	@@ -4101,7 +4101,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
4101	extra_index += 1;	4101	extra_index += 1;
4102	break :blk decls_len;	4102	break :blk decls_len;
4103	} else 0;	4103	} else 0;
4104	extra_index += captures_len;	4104	extra_index += captures_len * 2;
4105	break :decls zir.bodySlice(extra_index, decls_len);	4105	break :decls zir.bodySlice(extra_index, decls_len);
4106	},	4106	},
4107	.@"enum" => decls: {	4107	.@"enum" => decls: {
...	@@ -4122,7 +4122,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace	...	@@ -4122,7 +4122,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
4122	extra_index += 1;	4122	extra_index += 1;
4123	break :blk decls_len;	4123	break :blk decls_len;
4124	} else 0;	4124	} else 0;
4125	extra_index += captures_len;	4125	extra_index += captures_len * 2;
4126	break :decls zir.bodySlice(extra_index, decls_len);	4126	break :decls zir.bodySlice(extra_index, decls_len);
4127	},	4127	},
4128	.@"opaque" => decls: {	4128	.@"opaque" => decls: {
...	@@ -4140,7 +4140,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace	...	@@ -4140,7 +4140,7 @@ pub fn ensureNamespaceUpToDate(pt: Zcu.PerThread, namespace_index: Zcu.Namespace
4140	extra_index += 1;	4140	extra_index += 1;
4141	break :blk decls_len;	4141	break :blk decls_len;
4142	} else 0;	4142	} else 0;
4143	extra_index += captures_len;	4143	extra_index += captures_len * 2;
4144	break :decls zir.bodySlice(extra_index, decls_len);	4144	break :decls zir.bodySlice(extra_index, decls_len);
4145	},	4145	},
4146	};	4146	};

src/print_value.zig+145-70

...	@@ -29,7 +29,7 @@ pub fn formatSema(	...	@@ -29,7 +29,7 @@ pub fn formatSema(
29	_ = options;	29	_ = options;
30	const sema = ctx.opt_sema.?;	30	const sema = ctx.opt_sema.?;
31	comptime std.debug.assert(fmt.len == 0);	31	comptime std.debug.assert(fmt.len == 0);
32	return print(ctx.val, writer, ctx.depth, ctx.pt, true, sema) catch \|err\| switch (err) {	32	return print(ctx.val, writer, ctx.depth, ctx.pt, sema) catch \|err\| switch (err) {
33	error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function	33	error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function
34	error.ComptimeBreak, error.ComptimeReturn => unreachable,	34	error.ComptimeBreak, error.ComptimeReturn => unreachable,
35	error.AnalysisFail => unreachable, // TODO: re-evaluate when we use `sema` more fully	35	error.AnalysisFail => unreachable, // TODO: re-evaluate when we use `sema` more fully
...	@@ -46,7 +46,7 @@ pub fn format(	...	@@ -46,7 +46,7 @@ pub fn format(
46	_ = options;	46	_ = options;
47	std.debug.assert(ctx.opt_sema == null);	47	std.debug.assert(ctx.opt_sema == null);
48	comptime std.debug.assert(fmt.len == 0);	48	comptime std.debug.assert(fmt.len == 0);
49	return print(ctx.val, writer, ctx.depth, ctx.pt, false, {}) catch \|err\| switch (err) {	49	return print(ctx.val, writer, ctx.depth, ctx.pt, null) catch \|err\| switch (err) {
50	error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function	50	error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function
51	error.ComptimeBreak, error.ComptimeReturn, error.AnalysisFail => unreachable,	51	error.ComptimeBreak, error.ComptimeReturn, error.AnalysisFail => unreachable,
52	else => \|e\| return e,	52	else => \|e\| return e,
...	@@ -58,9 +58,7 @@ pub fn print(	...	@@ -58,9 +58,7 @@ pub fn print(
58	writer: anytype,	58	writer: anytype,
59	level: u8,	59	level: u8,
60	pt: Zcu.PerThread,	60	pt: Zcu.PerThread,
61	/// If this `Sema` is provided, we will recurse through pointers where possible to provide friendly output.	61	opt_sema: ?*Sema,
62	comptime have_sema: bool,
63	sema: if (have_sema) *Sema else void,
64	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {	62	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {
65	const zcu = pt.zcu;	63	const zcu = pt.zcu;
66	const ip = &zcu.intern_pool;	64	const ip = &zcu.intern_pool;
...	@@ -94,11 +92,11 @@ pub fn print(	...	@@ -94,11 +92,11 @@ pub fn print(
94	.func => \|func\| try writer.print("(function '{}')", .{ip.getNav(func.owner_nav).name.fmt(ip)}),	92	.func => \|func\| try writer.print("(function '{}')", .{ip.getNav(func.owner_nav).name.fmt(ip)}),
95	.int => \|int\| switch (int.storage) {	93	.int => \|int\| switch (int.storage) {
96	inline .u64, .i64, .big_int => \|x\| try writer.print("{}", .{x}),	94	inline .u64, .i64, .big_int => \|x\| try writer.print("{}", .{x}),
97	.lazy_align => \|ty\| if (have_sema) {	95	.lazy_align => \|ty\| if (opt_sema != null) {
98	const a = try Type.fromInterned(ty).abiAlignmentSema(pt);	96	const a = try Type.fromInterned(ty).abiAlignmentSema(pt);
99	try writer.print("{}", .{a.toByteUnits() orelse 0});	97	try writer.print("{}", .{a.toByteUnits() orelse 0});
100	} else try writer.print("@alignOf({})", .{Type.fromInterned(ty).fmt(pt)}),	98	} else try writer.print("@alignOf({})", .{Type.fromInterned(ty).fmt(pt)}),
101	.lazy_size => \|ty\| if (have_sema) {	99	.lazy_size => \|ty\| if (opt_sema != null) {
102	const s = try Type.fromInterned(ty).abiSizeSema(pt);	100	const s = try Type.fromInterned(ty).abiSizeSema(pt);
103	try writer.print("{}", .{s});	101	try writer.print("{}", .{s});
104	} else try writer.print("@sizeOf({})", .{Type.fromInterned(ty).fmt(pt)}),	102	} else try writer.print("@sizeOf({})", .{Type.fromInterned(ty).fmt(pt)}),
...	@@ -110,7 +108,7 @@ pub fn print(	...	@@ -110,7 +108,7 @@ pub fn print(
110	.err_name => \|err_name\| try writer.print("error.{}", .{	108	.err_name => \|err_name\| try writer.print("error.{}", .{
111	err_name.fmt(ip),	109	err_name.fmt(ip),
112	}),	110	}),
113	.payload => \|payload\| try print(Value.fromInterned(payload), writer, level, pt, have_sema, sema),	111	.payload => \|payload\| try print(Value.fromInterned(payload), writer, level, pt, opt_sema),
114	},	112	},
115	.enum_literal => \|enum_literal\| try writer.print(".{}", .{	113	.enum_literal => \|enum_literal\| try writer.print(".{}", .{
116	enum_literal.fmt(ip),	114	enum_literal.fmt(ip),
...	@@ -124,7 +122,7 @@ pub fn print(	...	@@ -124,7 +122,7 @@ pub fn print(
124	return writer.writeAll("@enumFromInt(...)");	122	return writer.writeAll("@enumFromInt(...)");
125	}	123	}
126	try writer.writeAll("@enumFromInt(");	124	try writer.writeAll("@enumFromInt(");
127	try print(Value.fromInterned(enum_tag.int), writer, level - 1, pt, have_sema, sema);	125	try print(Value.fromInterned(enum_tag.int), writer, level - 1, pt, opt_sema);
128	try writer.writeAll(")");	126	try writer.writeAll(")");
129	},	127	},
130	.empty_enum_value => try writer.writeAll("(empty enum value)"),	128	.empty_enum_value => try writer.writeAll("(empty enum value)"),
...	@@ -141,12 +139,12 @@ pub fn print(	...	@@ -141,12 +139,12 @@ pub fn print(
141	// TODO: eventually we want to load the slice as an array with `sema`, but that's	139	// TODO: eventually we want to load the slice as an array with `sema`, but that's
142	// currently not possible without e.g. triggering compile errors.	140	// currently not possible without e.g. triggering compile errors.
143	}	141	}
144	try printPtr(Value.fromInterned(slice.ptr), writer, level, pt, have_sema, sema);	142	try printPtr(Value.fromInterned(slice.ptr), null, writer, level, pt, opt_sema);
145	try writer.writeAll("[0..");	143	try writer.writeAll("[0..");
146	if (level == 0) {	144	if (level == 0) {
147	try writer.writeAll("(...)");	145	try writer.writeAll("(...)");
148	} else {	146	} else {
149	try print(Value.fromInterned(slice.len), writer, level - 1, pt, have_sema, sema);	147	try print(Value.fromInterned(slice.len), writer, level - 1, pt, opt_sema);
150	}	148	}
151	try writer.writeAll("]");	149	try writer.writeAll("]");
152	},	150	},
...	@@ -160,13 +158,13 @@ pub fn print(	...	@@ -160,13 +158,13 @@ pub fn print(
160	// TODO: eventually we want to load the pointer with `sema`, but that's	158	// TODO: eventually we want to load the pointer with `sema`, but that's
161	// currently not possible without e.g. triggering compile errors.	159	// currently not possible without e.g. triggering compile errors.
162	}	160	}
163	try printPtr(val, writer, level, pt, have_sema, sema);	161	try printPtr(val, .rvalue, writer, level, pt, opt_sema);
164	},	162	},
165	.opt => \|opt\| switch (opt.val) {	163	.opt => \|opt\| switch (opt.val) {
166	.none => try writer.writeAll("null"),	164	.none => try writer.writeAll("null"),
167	else => \|payload\| try print(Value.fromInterned(payload), writer, level, pt, have_sema, sema),	165	else => \|payload\| try print(Value.fromInterned(payload), writer, level, pt, opt_sema),
168	},	166	},
169	.aggregate => \|aggregate\| try printAggregate(val, aggregate, false, writer, level, pt, have_sema, sema),	167	.aggregate => \|aggregate\| try printAggregate(val, aggregate, false, writer, level, pt, opt_sema),
170	.un => \|un\| {	168	.un => \|un\| {
171	if (level == 0) {	169	if (level == 0) {
172	try writer.writeAll(".{ ... }");	170	try writer.writeAll(".{ ... }");
...	@@ -175,13 +173,13 @@ pub fn print(	...	@@ -175,13 +173,13 @@ pub fn print(
175	if (un.tag == .none) {	173	if (un.tag == .none) {
176	const backing_ty = try val.typeOf(zcu).unionBackingType(pt);	174	const backing_ty = try val.typeOf(zcu).unionBackingType(pt);
177	try writer.print("@bitCast(@as({}, ", .{backing_ty.fmt(pt)});	175	try writer.print("@bitCast(@as({}, ", .{backing_ty.fmt(pt)});
178	try print(Value.fromInterned(un.val), writer, level - 1, pt, have_sema, sema);	176	try print(Value.fromInterned(un.val), writer, level - 1, pt, opt_sema);
179	try writer.writeAll("))");	177	try writer.writeAll("))");
180	} else {	178	} else {
181	try writer.writeAll(".{ ");	179	try writer.writeAll(".{ ");
182	try print(Value.fromInterned(un.tag), writer, level - 1, pt, have_sema, sema);	180	try print(Value.fromInterned(un.tag), writer, level - 1, pt, opt_sema);
183	try writer.writeAll(" = ");	181	try writer.writeAll(" = ");
184	try print(Value.fromInterned(un.val), writer, level - 1, pt, have_sema, sema);	182	try print(Value.fromInterned(un.val), writer, level - 1, pt, opt_sema);
185	try writer.writeAll(" }");	183	try writer.writeAll(" }");
186	}	184	}
187	},	185	},
...	@@ -196,8 +194,7 @@ fn printAggregate(	...	@@ -196,8 +194,7 @@ fn printAggregate(
196	writer: anytype,	194	writer: anytype,
197	level: u8,	195	level: u8,
198	pt: Zcu.PerThread,	196	pt: Zcu.PerThread,
199	comptime have_sema: bool,	197	opt_sema: ?*Sema,
200	sema: if (have_sema) *Sema else void,
201	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {	198	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {
202	if (level == 0) {	199	if (level == 0) {
203	if (is_ref) try writer.writeByte('&');	200	if (is_ref) try writer.writeByte('&');
...	@@ -218,7 +215,7 @@ fn printAggregate(	...	@@ -218,7 +215,7 @@ fn printAggregate(
218	if (i != 0) try writer.writeAll(", ");	215	if (i != 0) try writer.writeAll(", ");
219	const field_name = ty.structFieldName(@intCast(i), zcu).unwrap().?;	216	const field_name = ty.structFieldName(@intCast(i), zcu).unwrap().?;
220	try writer.print(".{i} = ", .{field_name.fmt(ip)});	217	try writer.print(".{i} = ", .{field_name.fmt(ip)});
221	try print(try val.fieldValue(pt, i), writer, level - 1, pt, have_sema, sema);	218	try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
222	}	219	}
223	try writer.writeAll(" }");	220	try writer.writeAll(" }");
224	return;	221	return;
...	@@ -268,7 +265,7 @@ fn printAggregate(	...	@@ -268,7 +265,7 @@ fn printAggregate(
268	const max_len = @min(len, max_aggregate_items);	265	const max_len = @min(len, max_aggregate_items);
269	for (0..max_len) \|i\| {	266	for (0..max_len) \|i\| {
270	if (i != 0) try writer.writeAll(", ");	267	if (i != 0) try writer.writeAll(", ");
271	try print(try val.fieldValue(pt, i), writer, level - 1, pt, have_sema, sema);	268	try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
272	}	269	}
273	if (len > max_aggregate_items) {	270	if (len > max_aggregate_items) {
274	try writer.writeAll(", ...");	271	try writer.writeAll(", ...");
...	@@ -278,11 +275,12 @@ fn printAggregate(	...	@@ -278,11 +275,12 @@ fn printAggregate(
278		275
279	fn printPtr(	276	fn printPtr(
280	ptr_val: Value,	277	ptr_val: Value,
		278	/// Whether to print `derivation` as an lvalue or rvalue. If `null`, the more concise option is chosen.
		279	want_kind: ?PrintPtrKind,
281	writer: anytype,	280	writer: anytype,
282	level: u8,	281	level: u8,
283	pt: Zcu.PerThread,	282	pt: Zcu.PerThread,
284	comptime have_sema: bool,	283	opt_sema: ?*Sema,
285	sema: if (have_sema) *Sema else void,
286	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {	284	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {
287	const ptr = switch (pt.zcu.intern_pool.indexToKey(ptr_val.toIntern())) {	285	const ptr = switch (pt.zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
288	.undef => return writer.writeAll("undefined"),	286	.undef => return writer.writeAll("undefined"),
...	@@ -300,8 +298,7 @@ fn printPtr(	...	@@ -300,8 +298,7 @@ fn printPtr(
300	writer,	298	writer,
301	level,	299	level,
302	pt,	300	pt,
303	have_sema,	301	opt_sema,
304	sema,
305	),	302	),
306	else => {},	303	else => {},
307	}	304	}
...	@@ -309,57 +306,96 @@ fn printPtr(	...	@@ -309,57 +306,96 @@ fn printPtr(
309		306
310	var arena = std.heap.ArenaAllocator.init(pt.zcu.gpa);	307	var arena = std.heap.ArenaAllocator.init(pt.zcu.gpa);
311	defer arena.deinit();	308	defer arena.deinit();
312	const derivation = try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, have_sema, sema);	309	const derivation = if (opt_sema) \|sema\|
313	try printPtrDerivation(derivation, writer, level, pt, have_sema, sema);	310	try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, true, sema)
		311	else
		312	try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, false, null);
		313
		314	_ = try printPtrDerivation(derivation, writer, pt, want_kind, .{ .print_val = .{
		315	.level = level,
		316	.opt_sema = opt_sema,
		317	} }, 20);
314	}	318	}
315		319
316	/// Print `derivation` as an lvalue, i.e. such that writing `&` before this gives the pointer value.	320	const PrintPtrKind = enum { lvalue, rvalue };
317	fn printPtrDerivation(	321
		322	/// Print the pointer defined by `derivation` as an lvalue or an rvalue.
		323	/// Returns the root derivation, which may be ignored.
		324	pub fn printPtrDerivation(
318	derivation: Value.PointerDeriveStep,	325	derivation: Value.PointerDeriveStep,
319	writer: anytype,	326	writer: anytype,
320	level: u8,
321	pt: Zcu.PerThread,	327	pt: Zcu.PerThread,
322	comptime have_sema: bool,	328	/// Whether to print `derivation` as an lvalue or rvalue. If `null`, the more concise option is chosen.
323	sema: if (have_sema) *Sema else void,	329	/// If this is `.rvalue`, the result may look like `&foo`, so it's not necessarily valid to treat it as
324	) (@TypeOf(writer).Error \|\| Zcu.CompileError)!void {	330	/// an atom -- e.g. `&foo.` is distinct from `(&foo).`.
		331	want_kind: ?PrintPtrKind,
		332	/// How to print the "root" of the derivation. `.print_val` will recursively print other values if needed,
		333	/// e.g. for UAV refs. `.str` will just write the root as the given string.
		334	root_strat: union(enum) {
		335	str: []const u8,
		336	print_val: struct {
		337	level: u8,
		338	opt_sema: ?*Sema,
		339	},
		340	},
		341	/// The maximum recursion depth. We can never recurse infinitely here, but the depth can be arbitrary,
		342	/// so at this depth we just write "..." to prevent stack overflow.
		343	ptr_depth: u8,
		344	) !Value.PointerDeriveStep {
325	const zcu = pt.zcu;	345	const zcu = pt.zcu;
326	const ip = &zcu.intern_pool;	346	const ip = &zcu.intern_pool;
327	switch (derivation) {	347
328	.int => \|int\| try writer.print("@as({}, @ptrFromInt({x})).*", .{	348	if (ptr_depth == 0) {
329	int.ptr_ty.fmt(pt),	349	const root_step = root: switch (derivation) {
330	int.addr,	350	inline .eu_payload_ptr,
331	}),	351	.opt_payload_ptr,
332	.nav_ptr => \|nav\| {	352	.field_ptr,
333	try writer.print("{}", .{ip.getNav(nav).fqn.fmt(ip)});	353	.elem_ptr,
334	},	354	.offset_and_cast,
335	.uav_ptr => \|uav\| {	355	=> \|step\| continue :root step.parent.*,
336	const ty = Value.fromInterned(uav.val).typeOf(zcu);	356	else => \|step\| break :root step,
337	try writer.print("@as({}, ", .{ty.fmt(pt)});	357	};
338	try print(Value.fromInterned(uav.val), writer, level - 1, pt, have_sema, sema);	358	try writer.writeAll("...");
339	try writer.writeByte(')');	359	return root_step;
340	},	360	}
341	.comptime_alloc_ptr => \|info\| {	361
342	try writer.print("@as({}, ", .{info.val.typeOf(zcu).fmt(pt)});	362	const result_kind: PrintPtrKind = switch (derivation) {
343	try print(info.val, writer, level - 1, pt, have_sema, sema);	363	.nav_ptr,
344	try writer.writeByte(')');	364	.uav_ptr,
345	},	365	.comptime_alloc_ptr,
346	.comptime_field_ptr => \|val\| {	366	.comptime_field_ptr,
347	const ty = val.typeOf(zcu);	367	.eu_payload_ptr,
348	try writer.print("@as({}, ", .{ty.fmt(pt)});	368	.opt_payload_ptr,
349	try print(val, writer, level - 1, pt, have_sema, sema);	369	.field_ptr,
350	try writer.writeByte(')');	370	.elem_ptr,
351	},	371	=> .lvalue,
352	.eu_payload_ptr => \|info\| {	372
		373	.offset_and_cast,
		374	.int,
		375	=> .rvalue,
		376	};
		377
		378	const need_kind = want_kind orelse result_kind;
		379
		380	if (need_kind == .rvalue and result_kind == .lvalue) {
		381	try writer.writeByte('&');
		382	}
		383
		384	// null if `derivation` is the root.
		385	const root_or_null: ?Value.PointerDeriveStep = switch (derivation) {
		386	.eu_payload_ptr => \|info\| root: {
353	try writer.writeByte('(');	387	try writer.writeByte('(');
354	try printPtrDerivation(info.parent.*, writer, level, pt, have_sema, sema);	388	const root = try printPtrDerivation(info.parent.*, writer, pt, .lvalue, root_strat, ptr_depth - 1);
355	try writer.writeAll(" catch unreachable)");	389	try writer.writeAll(" catch unreachable)");
		390	break :root root;
356	},	391	},
357	.opt_payload_ptr => \|info\| {	392	.opt_payload_ptr => \|info\| root: {
358	try printPtrDerivation(info.parent.*, writer, level, pt, have_sema, sema);	393	const root = try printPtrDerivation(info.parent.*, writer, pt, .lvalue, root_strat, ptr_depth - 1);
359	try writer.writeAll(".?");	394	try writer.writeAll(".?");
		395	break :root root;
360	},	396	},
361	.field_ptr => \|field\| {	397	.field_ptr => \|field\| root: {
362	try printPtrDerivation(field.parent.*, writer, level, pt, have_sema, sema);	398	const root = try printPtrDerivation(field.parent.*, writer, pt, null, root_strat, ptr_depth - 1);
363	const agg_ty = (try field.parent.ptrType(pt)).childType(zcu);	399	const agg_ty = (try field.parent.ptrType(pt)).childType(zcu);
364	switch (agg_ty.zigTypeTag(zcu)) {	400	switch (agg_ty.zigTypeTag(zcu)) {
365	.@"struct" => if (agg_ty.structFieldName(field.field_idx, zcu).unwrap()) \|field_name\| {	401	.@"struct" => if (agg_ty.structFieldName(field.field_idx, zcu).unwrap()) \|field_name\| {
...	@@ -379,19 +415,58 @@ fn printPtrDerivation(	...	@@ -379,19 +415,58 @@ fn printPtrDerivation(
379	},	415	},
380	else => unreachable,	416	else => unreachable,
381	}	417	}
		418	break :root root;
382	},	419	},
383	.elem_ptr => \|elem\| {	420	.elem_ptr => \|elem\| root: {
384	try printPtrDerivation(elem.parent.*, writer, level, pt, have_sema, sema);	421	const root = try printPtrDerivation(elem.parent.*, writer, pt, null, root_strat, ptr_depth - 1);
385	try writer.print("[{d}]", .{elem.elem_idx});	422	try writer.print("[{d}]", .{elem.elem_idx});
		423	break :root root;
386	},	424	},
387	.offset_and_cast => \|oac\| if (oac.byte_offset == 0) {	425
		426	.offset_and_cast => \|oac\| if (oac.byte_offset == 0) root: {
388	try writer.print("@as({}, @ptrCast(", .{oac.new_ptr_ty.fmt(pt)});	427	try writer.print("@as({}, @ptrCast(", .{oac.new_ptr_ty.fmt(pt)});
389	try printPtrDerivation(oac.parent.*, writer, level, pt, have_sema, sema);	428	const root = try printPtrDerivation(oac.parent.*, writer, pt, .rvalue, root_strat, ptr_depth - 1);
390	try writer.writeAll("))");	429	try writer.writeAll("))");
391	} else {	430	break :root root;
		431	} else root: {
392	try writer.print("@as({}, @ptrFromInt(@intFromPtr(", .{oac.new_ptr_ty.fmt(pt)});	432	try writer.print("@as({}, @ptrFromInt(@intFromPtr(", .{oac.new_ptr_ty.fmt(pt)});
393	try printPtrDerivation(oac.parent.*, writer, level, pt, have_sema, sema);	433	const root = try printPtrDerivation(oac.parent.*, writer, pt, .rvalue, root_strat, ptr_depth - 1);
394	try writer.print(") + {d}))", .{oac.byte_offset});	434	try writer.print(") + {d}))", .{oac.byte_offset});
		435	break :root root;
395	},	436	},
		437
		438	.int, .nav_ptr, .uav_ptr, .comptime_alloc_ptr, .comptime_field_ptr => null,
		439	};
		440
		441	if (root_or_null == null) switch (root_strat) {
		442	.str => \|x\| try writer.writeAll(x),
		443	.print_val => \|x\| switch (derivation) {
		444	.int => \|int\| try writer.print("@as({}, @ptrFromInt(0x{x}))", .{ int.ptr_ty.fmt(pt), int.addr }),
		445	.nav_ptr => \|nav\| try writer.print("{}", .{ip.getNav(nav).fqn.fmt(ip)}),
		446	.uav_ptr => \|uav\| {
		447	const ty = Value.fromInterned(uav.val).typeOf(zcu);
		448	try writer.print("@as({}, ", .{ty.fmt(pt)});
		449	try print(Value.fromInterned(uav.val), writer, x.level - 1, pt, x.opt_sema);
		450	try writer.writeByte(')');
		451	},
		452	.comptime_alloc_ptr => \|info\| {
		453	try writer.print("@as({}, ", .{info.val.typeOf(zcu).fmt(pt)});
		454	try print(info.val, writer, x.level - 1, pt, x.opt_sema);
		455	try writer.writeByte(')');
		456	},
		457	.comptime_field_ptr => \|val\| {
		458	const ty = val.typeOf(zcu);
		459	try writer.print("@as({}, ", .{ty.fmt(pt)});
		460	try print(val, writer, x.level - 1, pt, x.opt_sema);
		461	try writer.writeByte(')');
		462	},
		463	else => unreachable,
		464	},
		465	};
		466
		467	if (need_kind == .lvalue and result_kind == .rvalue) {
		468	try writer.writeAll(".*");
396	}	469	}
		470
		471	return root_or_null orelse derivation;
397	}	472	}

src/print_zir.zig+28-52

 @@ -1430,19 +1430,8 @@ const Writer = struct {
         try stream.print("{s}, ", .{@tagName(small.name_strategy)});
-        if (captures_len == 0) {
+        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
-            try stream.writeAll("{}, ");
+        try stream.writeAll(", ");
-        } else {
-            try stream.writeAll("{ ");
-            try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-            extra_index += 1;
-            for (1..captures_len) |_| {
-                try stream.writeAll(", ");
-                try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-                extra_index += 1;
-            }
-            try stream.writeAll(" }, ");
-        }
         if (small.has_backing_int) {
             const backing_int_body_len = self.code.extra[extra_index];
 @@ -1645,19 +1634,8 @@ const Writer = struct {
         });
         try self.writeFlag(stream, "autoenum, ", small.auto_enum_tag);
-        if (captures_len == 0) {
+        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
-            try stream.writeAll("{}, ");
+        try stream.writeAll(", ");
-        } else {
-            try stream.writeAll("{ ");
-            try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-            extra_index += 1;
-            for (1..captures_len) |_| {
-                try stream.writeAll(", ");
-                try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-                extra_index += 1;
-            }
-            try stream.writeAll(" }, ");
-        }
         if (decls_len == 0) {
             try stream.writeAll("{}");
 @@ -1805,19 +1783,8 @@ const Writer = struct {
         try stream.print("{s}, ", .{@tagName(small.name_strategy)});
         try self.writeFlag(stream, "nonexhaustive, ", small.nonexhaustive);
-        if (captures_len == 0) {
+        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
-            try stream.writeAll("{}, ");
+        try stream.writeAll(", ");
-        } else {
-            try stream.writeAll("{ ");
-            try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-            extra_index += 1;
-            for (1..captures_len) |_| {
-                try stream.writeAll(", ");
-                try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-                extra_index += 1;
-            }
-            try stream.writeAll(" }, ");
-        }
         if (decls_len == 0) {
             try stream.writeAll("{}, ");
 @@ -1910,19 +1877,8 @@ const Writer = struct {
         try stream.print("{s}, ", .{@tagName(small.name_strategy)});
-        if (captures_len == 0) {
+        extra_index = try self.writeCaptures(stream, extra_index, captures_len);
-            try stream.writeAll("{}, ");
+        try stream.writeAll(", ");
-        } else {
-            try stream.writeAll("{ ");
-            try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-            extra_index += 1;
-            for (1..captures_len) |_| {
-                try stream.writeAll(", ");
-                try self.writeCapture(stream, @bitCast(self.code.extra[extra_index]));
-                extra_index += 1;
-            }
-            try stream.writeAll(" }, ");
-        }
         if (decls_len == 0) {
             try stream.writeAll("{}) ");
 @@ -2720,6 +2676,26 @@ const Writer = struct {
         return stream.print("%{d}", .{@intFromEnum(inst)});
     }
+    fn writeCaptures(self: *Writer, stream: anytype, extra_index: usize, captures_len: u32) !usize {
+        if (captures_len == 0) {
+            try stream.writeAll("{}");
+            return extra_index;
+        }
+        const captures: []const Zir.Inst.Capture = @ptrCast(self.code.extra[extra_index..][0..captures_len]);
+        const capture_names: []const Zir.NullTerminatedString = @ptrCast(self.code.extra[extra_index + captures_len ..][0..captures_len]);
+        for (captures, capture_names) |capture, name| {
+            try stream.writeAll("{ ");
+            if (name != .empty) {
+                const name_slice = self.code.nullTerminatedString(name);
+                try stream.print("{s} = ", .{name_slice});
+            }
+            try self.writeCapture(stream, capture);
+        }
+        return extra_index + 2 * captures_len;
+    }
     fn writeCapture(self: *Writer, stream: anytype, capture: Zir.Inst.Capture) !void {
         switch (capture.unwrap()) {
             .nested => |i| return stream.print("[{d}]", .{i}),

test/cases/compile_errors/compile_log_a_pointer_to_an_opaque_value.zig+1-3

 @@ -3,10 +3,8 @@ export fn entry() void {
 }
 // error
-// backend=stage2
-// target=native
 //
 // :2:5: error: found compile log statement
 //
 // Compile Log Output:
-// @as(*const anyopaque, @as(*const anyopaque, @ptrCast(tmp.entry)))
+// @as(*const anyopaque, @as(*const anyopaque, @ptrCast(&tmp.entry)))

test/cases/compile_errors/comptime_var_referenced_at_runtime.zig+9

test/cases/compile_errors/comptime_var_referenced_by_decl.zig+9

...	@@ -47,10 +47,19 @@ export var h: *[1]u32 = h: {	...	@@ -47,10 +47,19 @@ export var h: *[1]u32 = h: {
47	// error	47	// error
48	//	48	//
49	// :1:27: error: global variable contains reference to comptime var	49	// :1:27: error: global variable contains reference to comptime var
		50	// :2:18: note: 'a' points to comptime var declared here
50	// :6:30: error: global variable contains reference to comptime var	51	// :6:30: error: global variable contains reference to comptime var
		52	// :7:18: note: 'b[0]' points to comptime var declared here
51	// :11:30: error: global variable contains reference to comptime var	53	// :11:30: error: global variable contains reference to comptime var
		54	// :12:18: note: 'c' points to comptime var declared here
52	// :16:33: error: global variable contains reference to comptime var	55	// :16:33: error: global variable contains reference to comptime var
		56	// :17:18: note: 'd' points to comptime var declared here
53	// :22:24: error: global variable contains reference to comptime var	57	// :22:24: error: global variable contains reference to comptime var
		58	// :23:18: note: 'e.ptr' points to comptime var declared here
54	// :28:33: error: global variable contains reference to comptime var	59	// :28:33: error: global variable contains reference to comptime var
		60	// :29:18: note: 'f' points to comptime var declared here
55	// :34:40: error: global variable contains reference to comptime var	61	// :34:40: error: global variable contains reference to comptime var
		62	// :34:40: note: 'g' points to 'v0[0]', where
		63	// :36:24: note: 'v0[1]' points to comptime var declared here
56	// :42:28: error: global variable contains reference to comptime var	64	// :42:28: error: global variable contains reference to comptime var
		65	// :43:22: note: 'h' points to comptime var declared here

test/cases/compile_errors/comptime_var_referenced_by_type.zig created+25

...	@@ -0,0 +1,25 @@
1	const Wrapper = struct { ptr: *ComptimeThing };
2
3	const ComptimeThing = struct {
4	x: comptime_int,
5	fn NewType(comptime ct: *ComptimeThing) type {
6	const wrapper: Wrapper = .{ .ptr = ct };
7	return struct {
8	pub fn foo() void {
9	_ = wrapper.ct;
10	}
11	};
12	}
13	};
14
15	comptime {
16	var ct: ComptimeThing = .{ .x = 123 };
17	const Inner = ct.NewType();
18	Inner.foo();
19	}
20
21	// error
22	//
23	// :7:16: error: captured value contains reference to comptime var
24	// :16:30: note: 'wrapper.ptr' points to comptime var declared here
25	// :17:29: note: called from here

test/cases/comptime_aggregate_print.zig+2-2

...	@@ -31,5 +31,5 @@ pub fn main() !void {}	...	@@ -31,5 +31,5 @@ pub fn main() !void {}
31	// :20:5: error: found compile log statement	31	// :20:5: error: found compile log statement
32	//	32	//
33	// Compile Log Output:	33	// Compile Log Output:
34	// @as([]i32, @as([*]i32, @ptrCast(@as(tmp.UnionContainer, .{ .buf = .{ 1, 2 } }).buf[0]))[0..2])	34	// @as([]i32, @as([*]i32, @ptrCast(&@as(tmp.UnionContainer, .{ .buf = .{ 1, 2 } }).buf))[0..2])
35	// @as([]i32, @as([*]i32, @ptrCast(@as(tmp.StructContainer, .{ .buf = .{ 3, 4 } }).buf[0]))[0..2])	35	// @as([]i32, @as([*]i32, @ptrCast(&@as(tmp.StructContainer, .{ .buf = .{ 3, 4 } }).buf))[0..2])

...	@@ -67,19 +67,28 @@ export fn far() void {	...	@@ -67,19 +67,28 @@ export fn far() void {
67	//	67	//
68	// :5:19: error: runtime value contains reference to comptime var	68	// :5:19: error: runtime value contains reference to comptime var
69	// :5:19: note: comptime var pointers are not available at runtime	69	// :5:19: note: comptime var pointers are not available at runtime
		70	// :4:27: note: 'runtime_value' points to comptime var declared here
70	// :12:40: error: runtime value contains reference to comptime var	71	// :12:40: error: runtime value contains reference to comptime var
71	// :12:40: note: comptime var pointers are not available at runtime	72	// :12:40: note: comptime var pointers are not available at runtime
		73	// :11:27: note: 'runtime_value' points to comptime var declared here
72	// :19:50: error: runtime value contains reference to comptime var	74	// :19:50: error: runtime value contains reference to comptime var
73	// :19:50: note: comptime var pointers are not available at runtime	75	// :19:50: note: comptime var pointers are not available at runtime
		76	// :18:27: note: 'runtime_value' points to comptime var declared here
74	// :28:9: error: runtime value contains reference to comptime var	77	// :28:9: error: runtime value contains reference to comptime var
75	// :28:9: note: comptime var pointers are not available at runtime	78	// :28:9: note: comptime var pointers are not available at runtime
		79	// :27:27: note: 'runtime_value' points to comptime var declared here
76	// :36:9: error: runtime value contains reference to comptime var	80	// :36:9: error: runtime value contains reference to comptime var
77	// :36:9: note: comptime var pointers are not available at runtime	81	// :36:9: note: comptime var pointers are not available at runtime
		82	// :35:27: note: 'runtime_value' points to comptime var declared here
78	// :41:12: error: runtime value contains reference to comptime var	83	// :41:12: error: runtime value contains reference to comptime var
79	// :41:12: note: comptime var pointers are not available at runtime	84	// :41:12: note: comptime var pointers are not available at runtime
		85	// :40:27: note: 'runtime_value' points to comptime var declared here
80	// :46:39: error: runtime value contains reference to comptime var	86	// :46:39: error: runtime value contains reference to comptime var
81	// :46:39: note: comptime var pointers are not available at runtime	87	// :46:39: note: comptime var pointers are not available at runtime
		88	// :45:27: note: 'runtime_value' points to comptime var declared here
82	// :55:18: error: runtime value contains reference to comptime var	89	// :55:18: error: runtime value contains reference to comptime var
83	// :55:18: note: comptime var pointers are not available at runtime	90	// :55:18: note: comptime var pointers are not available at runtime
		91	// :51:30: note: 'runtime_value' points to comptime var declared here
84	// :63:18: error: runtime value contains reference to comptime var	92	// :63:18: error: runtime value contains reference to comptime var
85	// :63:18: note: comptime var pointers are not available at runtime	93	// :63:18: note: comptime var pointers are not available at runtime
		94	// :59:27: note: 'runtime_value' points to comptime var declared here