authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-07-16 11:37:53+01:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-07-16 11:38:21+01:00
logf84a4953d29ffc2bdc94fa353cac685430e6bbe4
tree9e7e0c705451b464979cb8330e6b87de67ae1085
parent67cd14dbdbf2ce435a2bd81dc82d167b99fad6e3
signaturelock-open Commit is signed but in an unrecognized format.

Value: eliminate static recursion loop from value printing

8 files changed, 154 insertions(+), 110 deletions(-)

src/Sema.zig+50-50
......@@ -2318,7 +2318,7 @@ fn failWithIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc, int_ty:
23182318 if (int_ty.zigTypeTag(zcu) == .Vector) {
23192319 const msg = msg: {
23202320 const msg = try sema.errMsg(src, "overflow of vector type '{}' with value '{}'", .{
2321 int_ty.fmt(pt), val.fmtValue(pt, sema),
2321 int_ty.fmt(pt), val.fmtValueSema(pt, sema),
23222322 });
23232323 errdefer msg.destroy(sema.gpa);
23242324 try sema.errNote(src, msg, "when computing vector element at index '{d}'", .{vector_index});
......@@ -2327,7 +2327,7 @@ fn failWithIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc, int_ty:
23272327 return sema.failWithOwnedErrorMsg(block, msg);
23282328 }
23292329 return sema.fail(block, src, "overflow of integer type '{}' with value '{}'", .{
2330 int_ty.fmt(pt), val.fmtValue(pt, sema),
2330 int_ty.fmt(pt), val.fmtValueSema(pt, sema),
23312331 });
23322332}
23332333
......@@ -2912,7 +2912,7 @@ fn createAnonymousDeclTypeNamed(
29122912 // in turn helps to avoid unreasonably long symbol names for namespaced
29132913 // symbols. Such names should ideally be human-readable, and additionally,
29142914 // some tooling may not support very long symbol names.
2915 try writer.print("{}", .{Value.fmtValueFull(.{
2915 try writer.print("{}", .{Value.fmtValueSemaFull(.{
29162916 .val = arg_val,
29172917 .pt = pt,
29182918 .opt_sema = sema,
......@@ -3202,7 +3202,7 @@ fn zirEnumDecl(
32023202 .offset = .{ .container_field_value = conflict.prev_field_idx },
32033203 };
32043204 const msg = msg: {
3205 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{last_tag_val.?.fmtValue(pt, sema)});
3205 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{last_tag_val.?.fmtValueSema(pt, sema)});
32063206 errdefer msg.destroy(gpa);
32073207 try sema.errNote(other_field_src, msg, "other occurrence here", .{});
32083208 break :msg msg;
......@@ -3224,7 +3224,7 @@ fn zirEnumDecl(
32243224 .offset = .{ .container_field_value = conflict.prev_field_idx },
32253225 };
32263226 const msg = msg: {
3227 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{last_tag_val.?.fmtValue(pt, sema)});
3227 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{last_tag_val.?.fmtValueSema(pt, sema)});
32283228 errdefer msg.destroy(gpa);
32293229 try sema.errNote(other_field_src, msg, "other occurrence here", .{});
32303230 break :msg msg;
......@@ -3242,7 +3242,7 @@ fn zirEnumDecl(
32423242
32433243 if (tag_overflow) {
32443244 const msg = try sema.errMsg(value_src, "enumeration value '{}' too large for type '{}'", .{
3245 last_tag_val.?.fmtValue(pt, sema), int_tag_ty.fmt(pt),
3245 last_tag_val.?.fmtValueSema(pt, sema), int_tag_ty.fmt(pt),
32463246 });
32473247 return sema.failWithOwnedErrorMsg(block, msg);
32483248 }
......@@ -4430,10 +4430,10 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
44304430 .input_index = len_idx,
44314431 } });
44324432 try sema.errNote(a_src, msg, "length {} here", .{
4433 v.fmtValue(pt, sema),
4433 v.fmtValueSema(pt, sema),
44344434 });
44354435 try sema.errNote(arg_src, msg, "length {} here", .{
4436 arg_val.fmtValue(pt, sema),
4436 arg_val.fmtValueSema(pt, sema),
44374437 });
44384438 break :msg msg;
44394439 };
......@@ -5853,7 +5853,7 @@ fn zirCompileLog(
58535853 const arg_ty = sema.typeOf(arg);
58545854 if (try sema.resolveValueResolveLazy(arg)) |val| {
58555855 try writer.print("@as({}, {})", .{
5856 arg_ty.fmt(pt), val.fmtValue(pt, sema),
5856 arg_ty.fmt(pt), val.fmtValueSema(pt, sema),
58575857 });
58585858 } else {
58595859 try writer.print("@as({}, [runtime value])", .{arg_ty.fmt(pt)});
......@@ -8949,7 +8949,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
89498949 return Air.internedToRef((try pt.getCoerced(int_val, dest_ty)).toIntern());
89508950 }
89518951 return sema.fail(block, src, "int value '{}' out of range of non-exhaustive enum '{}'", .{
8952 int_val.fmtValue(pt, sema), dest_ty.fmt(pt),
8952 int_val.fmtValueSema(pt, sema), dest_ty.fmt(pt),
89538953 });
89548954 }
89558955 if (int_val.isUndef(mod)) {
......@@ -8957,7 +8957,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
89578957 }
89588958 if (!(try sema.enumHasInt(dest_ty, int_val))) {
89598959 return sema.fail(block, src, "enum '{}' has no tag with value '{}'", .{
8960 dest_ty.fmt(pt), int_val.fmtValue(pt, sema),
8960 dest_ty.fmt(pt), int_val.fmtValueSema(pt, sema),
89618961 });
89628962 }
89638963 return Air.internedToRef((try pt.getCoerced(int_val, dest_ty)).toIntern());
......@@ -14067,7 +14067,7 @@ fn zirShl(
1406714067 const rhs_elem = try rhs_val.elemValue(pt, i);
1406814068 if (rhs_elem.compareHetero(.gte, bit_value, pt)) {
1406914069 return sema.fail(block, rhs_src, "shift amount '{}' at index '{d}' is too large for operand type '{}'", .{
14070 rhs_elem.fmtValue(pt, sema),
14070 rhs_elem.fmtValueSema(pt, sema),
1407114071 i,
1407214072 scalar_ty.fmt(pt),
1407314073 });
......@@ -14075,7 +14075,7 @@ fn zirShl(
1407514075 }
1407614076 } else if (rhs_val.compareHetero(.gte, bit_value, pt)) {
1407714077 return sema.fail(block, rhs_src, "shift amount '{}' is too large for operand type '{}'", .{
14078 rhs_val.fmtValue(pt, sema),
14078 rhs_val.fmtValueSema(pt, sema),
1407914079 scalar_ty.fmt(pt),
1408014080 });
1408114081 }
......@@ -14086,14 +14086,14 @@ fn zirShl(
1408614086 const rhs_elem = try rhs_val.elemValue(pt, i);
1408714087 if (rhs_elem.compareHetero(.lt, try pt.intValue(scalar_rhs_ty, 0), pt)) {
1408814088 return sema.fail(block, rhs_src, "shift by negative amount '{}' at index '{d}'", .{
14089 rhs_elem.fmtValue(pt, sema),
14089 rhs_elem.fmtValueSema(pt, sema),
1409014090 i,
1409114091 });
1409214092 }
1409314093 }
1409414094 } else if (rhs_val.compareHetero(.lt, try pt.intValue(rhs_ty, 0), pt)) {
1409514095 return sema.fail(block, rhs_src, "shift by negative amount '{}'", .{
14096 rhs_val.fmtValue(pt, sema),
14096 rhs_val.fmtValueSema(pt, sema),
1409714097 });
1409814098 }
1409914099 }
......@@ -14233,7 +14233,7 @@ fn zirShr(
1423314233 const rhs_elem = try rhs_val.elemValue(pt, i);
1423414234 if (rhs_elem.compareHetero(.gte, bit_value, pt)) {
1423514235 return sema.fail(block, rhs_src, "shift amount '{}' at index '{d}' is too large for operand type '{}'", .{
14236 rhs_elem.fmtValue(pt, sema),
14236 rhs_elem.fmtValueSema(pt, sema),
1423714237 i,
1423814238 scalar_ty.fmt(pt),
1423914239 });
......@@ -14241,7 +14241,7 @@ fn zirShr(
1424114241 }
1424214242 } else if (rhs_val.compareHetero(.gte, bit_value, pt)) {
1424314243 return sema.fail(block, rhs_src, "shift amount '{}' is too large for operand type '{}'", .{
14244 rhs_val.fmtValue(pt, sema),
14244 rhs_val.fmtValueSema(pt, sema),
1424514245 scalar_ty.fmt(pt),
1424614246 });
1424714247 }
......@@ -14252,14 +14252,14 @@ fn zirShr(
1425214252 const rhs_elem = try rhs_val.elemValue(pt, i);
1425314253 if (rhs_elem.compareHetero(.lt, try pt.intValue(rhs_ty.childType(mod), 0), pt)) {
1425414254 return sema.fail(block, rhs_src, "shift by negative amount '{}' at index '{d}'", .{
14255 rhs_elem.fmtValue(pt, sema),
14255 rhs_elem.fmtValueSema(pt, sema),
1425614256 i,
1425714257 });
1425814258 }
1425914259 }
1426014260 } else if (rhs_val.compareHetero(.lt, try pt.intValue(rhs_ty, 0), pt)) {
1426114261 return sema.fail(block, rhs_src, "shift by negative amount '{}'", .{
14262 rhs_val.fmtValue(pt, sema),
14262 rhs_val.fmtValueSema(pt, sema),
1426314263 });
1426414264 }
1426514265 if (maybe_lhs_val) |lhs_val| {
......@@ -15190,7 +15190,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1519015190 block,
1519115191 src,
1519215192 "ambiguous coercion of division operands '{}' and '{}'; non-zero remainder '{}'",
15193 .{ lhs_ty.fmt(pt), rhs_ty.fmt(pt), rem.fmtValue(pt, sema) },
15193 .{ lhs_ty.fmt(pt), rhs_ty.fmt(pt), rem.fmtValueSema(pt, sema) },
1519415194 );
1519515195 }
1519615196 }
......@@ -21359,7 +21359,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
2135921359 const field_index = enum_ty.enumTagFieldIndex(val, mod) orelse {
2136021360 const msg = msg: {
2136121361 const msg = try sema.errMsg(src, "no field with value '{}' in enum '{}'", .{
21362 val.fmtValue(pt, sema), mod.declPtr(enum_decl_index).name.fmt(ip),
21362 val.fmtValueSema(pt, sema), mod.declPtr(enum_decl_index).name.fmt(ip),
2136321363 });
2136421364 errdefer msg.destroy(sema.gpa);
2136521365 try sema.errNote(enum_ty.srcLoc(mod), msg, "declared here", .{});
......@@ -22005,7 +22005,7 @@ fn reifyEnum(
2200522005 // TODO: better source location
2200622006 return sema.fail(block, src, "field '{}' with enumeration value '{}' is too large for backing int type '{}'", .{
2200722007 field_name.fmt(ip),
22008 field_value_val.fmtValue(pt, sema),
22008 field_value_val.fmtValueSema(pt, sema),
2200922009 tag_ty.fmt(pt),
2201022010 });
2201122011 }
......@@ -22021,7 +22021,7 @@ fn reifyEnum(
2202122021 break :msg msg;
2202222022 },
2202322023 .value => msg: {
22024 const msg = try sema.errMsg(src, "enum tag value {} already taken", .{field_value_val.fmtValue(pt, sema)});
22024 const msg = try sema.errMsg(src, "enum tag value {} already taken", .{field_value_val.fmtValueSema(pt, sema)});
2202522025 errdefer msg.destroy(gpa);
2202622026 _ = conflict.prev_field_idx; // TODO: this note is incorrect
2202722027 try sema.errNote(src, msg, "other enum tag value here", .{});
......@@ -23193,12 +23193,12 @@ fn ptrCastFull(
2319323193 return sema.failWithOwnedErrorMsg(block, msg: {
2319423194 const msg = if (src_info.sentinel == .none) blk: {
2319523195 break :blk try sema.errMsg(src, "destination pointer requires '{}' sentinel", .{
23196 Value.fromInterned(dest_info.sentinel).fmtValue(pt, sema),
23196 Value.fromInterned(dest_info.sentinel).fmtValueSema(pt, sema),
2319723197 });
2319823198 } else blk: {
2319923199 break :blk try sema.errMsg(src, "pointer sentinel '{}' cannot coerce into pointer sentinel '{}'", .{
23200 Value.fromInterned(src_info.sentinel).fmtValue(pt, sema),
23201 Value.fromInterned(dest_info.sentinel).fmtValue(pt, sema),
23200 Value.fromInterned(src_info.sentinel).fmtValueSema(pt, sema),
23201 Value.fromInterned(dest_info.sentinel).fmtValueSema(pt, sema),
2320223202 });
2320323203 };
2320423204 errdefer msg.destroy(sema.gpa);
......@@ -25691,10 +25691,10 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2569125691 const msg = try sema.errMsg(src, "non-matching @memcpy lengths", .{});
2569225692 errdefer msg.destroy(sema.gpa);
2569325693 try sema.errNote(dest_src, msg, "length {} here", .{
25694 dest_len_val.fmtValue(pt, sema),
25694 dest_len_val.fmtValueSema(pt, sema),
2569525695 });
2569625696 try sema.errNote(src_src, msg, "length {} here", .{
25697 src_len_val.fmtValue(pt, sema),
25697 src_len_val.fmtValueSema(pt, sema),
2569825698 });
2569925699 break :msg msg;
2570025700 };
......@@ -29560,7 +29560,7 @@ fn coerceExtra(
2956029560 // comptime-known integer to other number
2956129561 if (!(try sema.intFitsInType(val, dest_ty, null))) {
2956229562 if (!opts.report_err) return error.NotCoercible;
29563 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(pt), val.fmtValue(pt, sema) });
29563 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(pt), val.fmtValueSema(pt, sema) });
2956429564 }
2956529565 return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
2956629566 .undef => try pt.undefRef(dest_ty),
......@@ -29605,7 +29605,7 @@ fn coerceExtra(
2960529605 block,
2960629606 inst_src,
2960729607 "type '{}' cannot represent float value '{}'",
29608 .{ dest_ty.fmt(pt), val.fmtValue(pt, sema) },
29608 .{ dest_ty.fmt(pt), val.fmtValueSema(pt, sema) },
2960929609 );
2961029610 }
2961129611 return Air.internedToRef(result_val.toIntern());
......@@ -30003,11 +30003,11 @@ const InMemoryCoercionResult = union(enum) {
3000330003 .array_sentinel => |sentinel| {
3000430004 if (sentinel.actual.toIntern() != .unreachable_value) {
3000530005 try sema.errNote(src, msg, "array sentinel '{}' cannot cast into array sentinel '{}'", .{
30006 sentinel.actual.fmtValue(pt, sema), sentinel.wanted.fmtValue(pt, sema),
30006 sentinel.actual.fmtValueSema(pt, sema), sentinel.wanted.fmtValueSema(pt, sema),
3000730007 });
3000830008 } else {
3000930009 try sema.errNote(src, msg, "destination array requires '{}' sentinel", .{
30010 sentinel.wanted.fmtValue(pt, sema),
30010 sentinel.wanted.fmtValueSema(pt, sema),
3001130011 });
3001230012 }
3001330013 break;
......@@ -30129,11 +30129,11 @@ const InMemoryCoercionResult = union(enum) {
3012930129 .ptr_sentinel => |sentinel| {
3013030130 if (sentinel.actual.toIntern() != .unreachable_value) {
3013130131 try sema.errNote(src, msg, "pointer sentinel '{}' cannot cast into pointer sentinel '{}'", .{
30132 sentinel.actual.fmtValue(pt, sema), sentinel.wanted.fmtValue(pt, sema),
30132 sentinel.actual.fmtValueSema(pt, sema), sentinel.wanted.fmtValueSema(pt, sema),
3013330133 });
3013430134 } else {
3013530135 try sema.errNote(src, msg, "destination pointer requires '{}' sentinel", .{
30136 sentinel.wanted.fmtValue(pt, sema),
30136 sentinel.wanted.fmtValueSema(pt, sema),
3013730137 });
3013830138 }
3013930139 break;
......@@ -31379,7 +31379,7 @@ fn coerceEnumToUnion(
3137931379 if (try sema.resolveDefinedValue(block, inst_src, enum_tag)) |val| {
3138031380 const field_index = union_ty.unionTagFieldIndex(val, pt.zcu) orelse {
3138131381 return sema.fail(block, inst_src, "union '{}' has no tag with value '{}'", .{
31382 union_ty.fmt(pt), val.fmtValue(pt, sema),
31382 union_ty.fmt(pt), val.fmtValueSema(pt, sema),
3138331383 });
3138431384 };
3138531385
......@@ -32611,8 +32611,8 @@ fn analyzeSlice(
3261132611 msg,
3261232612 "expected '{}', found '{}'",
3261332613 .{
32614 Value.zero_comptime_int.fmtValue(pt, sema),
32615 start_value.fmtValue(pt, sema),
32614 Value.zero_comptime_int.fmtValueSema(pt, sema),
32615 start_value.fmtValueSema(pt, sema),
3261632616 },
3261732617 );
3261832618 break :msg msg;
......@@ -32627,8 +32627,8 @@ fn analyzeSlice(
3262732627 msg,
3262832628 "expected '{}', found '{}'",
3262932629 .{
32630 Value.one_comptime_int.fmtValue(pt, sema),
32631 end_value.fmtValue(pt, sema),
32630 Value.one_comptime_int.fmtValueSema(pt, sema),
32631 end_value.fmtValueSema(pt, sema),
3263232632 },
3263332633 );
3263432634 break :msg msg;
......@@ -32641,7 +32641,7 @@ fn analyzeSlice(
3264132641 block,
3264232642 end_src,
3264332643 "end index {} out of bounds for slice of single-item pointer",
32644 .{end_value.fmtValue(pt, sema)},
32644 .{end_value.fmtValueSema(pt, sema)},
3264532645 );
3264632646 }
3264732647 }
......@@ -32736,8 +32736,8 @@ fn analyzeSlice(
3273632736 end_src,
3273732737 "end index {} out of bounds for array of length {}{s}",
3273832738 .{
32739 end_val.fmtValue(pt, sema),
32740 len_val.fmtValue(pt, sema),
32739 end_val.fmtValueSema(pt, sema),
32740 len_val.fmtValueSema(pt, sema),
3274132741 sentinel_label,
3274232742 },
3274332743 );
......@@ -32781,7 +32781,7 @@ fn analyzeSlice(
3278132781 end_src,
3278232782 "end index {} out of bounds for slice of length {d}{s}",
3278332783 .{
32784 end_val.fmtValue(pt, sema),
32784 end_val.fmtValueSema(pt, sema),
3278532785 try slice_val.sliceLen(pt),
3278632786 sentinel_label,
3278732787 },
......@@ -32841,8 +32841,8 @@ fn analyzeSlice(
3284132841 start_src,
3284232842 "start index {} is larger than end index {}",
3284332843 .{
32844 start_val.fmtValue(pt, sema),
32845 end_val.fmtValue(pt, sema),
32844 start_val.fmtValueSema(pt, sema),
32845 end_val.fmtValueSema(pt, sema),
3284632846 },
3284732847 );
3284832848 }
......@@ -32879,8 +32879,8 @@ fn analyzeSlice(
3287932879 const msg = try sema.errMsg(src, "value in memory does not match slice sentinel", .{});
3288032880 errdefer msg.destroy(sema.gpa);
3288132881 try sema.errNote(src, msg, "expected '{}', found '{}'", .{
32882 expected_sentinel.fmtValue(pt, sema),
32883 actual_sentinel.fmtValue(pt, sema),
32882 expected_sentinel.fmtValueSema(pt, sema),
32883 actual_sentinel.fmtValueSema(pt, sema),
3288432884 });
3288532885
3288632886 break :msg msg;
......@@ -36623,7 +36623,7 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_type: InternPool.L
3662336623 .offset = .{ .container_field_value = @intCast(gop.index) },
3662436624 };
3662536625 const msg = msg: {
36626 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValue(pt, &sema)});
36626 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValueSema(pt, &sema)});
3662736627 errdefer msg.destroy(gpa);
3662836628 try sema.errNote(other_value_src, msg, "other occurrence here", .{});
3662936629 break :msg msg;
......@@ -37855,7 +37855,7 @@ fn intFromFloatScalar(
3785537855 block,
3785637856 src,
3785737857 "fractional component prevents float value '{}' from coercion to type '{}'",
37858 .{ val.fmtValue(pt, sema), int_ty.fmt(pt) },
37858 .{ val.fmtValueSema(pt, sema), int_ty.fmt(pt) },
3785937859 );
3786037860
3786137861 const float = val.toFloat(f128, pt);
......@@ -37877,7 +37877,7 @@ fn intFromFloatScalar(
3787737877
3787837878 if (!(try sema.intFitsInType(cti_result, int_ty, null))) {
3787937879 return sema.fail(block, src, "float value '{}' cannot be stored in integer type '{}'", .{
37880 val.fmtValue(pt, sema), int_ty.fmt(pt),
37880 val.fmtValueSema(pt, sema), int_ty.fmt(pt),
3788137881 });
3788237882 }
3788337883 return pt.getCoerced(cti_result, int_ty);
src/Type.zig+4-4
......@@ -194,8 +194,8 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
194194
195195 if (info.sentinel != .none) switch (info.flags.size) {
196196 .One, .C => unreachable,
197 .Many => try writer.print("[*:{}]", .{Value.fromInterned(info.sentinel).fmtValue(pt, null)}),
198 .Slice => try writer.print("[:{}]", .{Value.fromInterned(info.sentinel).fmtValue(pt, null)}),
197 .Many => try writer.print("[*:{}]", .{Value.fromInterned(info.sentinel).fmtValue(pt)}),
198 .Slice => try writer.print("[:{}]", .{Value.fromInterned(info.sentinel).fmtValue(pt)}),
199199 } else switch (info.flags.size) {
200200 .One => try writer.writeAll("*"),
201201 .Many => try writer.writeAll("[*]"),
......@@ -241,7 +241,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
241241 } else {
242242 try writer.print("[{d}:{}]", .{
243243 array_type.len,
244 Value.fromInterned(array_type.sentinel).fmtValue(pt, null),
244 Value.fromInterned(array_type.sentinel).fmtValue(pt),
245245 });
246246 try print(Type.fromInterned(array_type.child), writer, pt);
247247 }
......@@ -359,7 +359,7 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
359359 try print(Type.fromInterned(field_ty), writer, pt);
360360
361361 if (val != .none) {
362 try writer.print(" = {}", .{Value.fromInterned(val).fmtValue(pt, null)});
362 try writer.print(" = {}", .{Value.fromInterned(val).fmtValue(pt)});
363363 }
364364 }
365365 try writer.writeAll("}");
src/Value.zig+23-13
......@@ -40,16 +40,25 @@ pub fn fmtDebug(val: Value) std.fmt.Formatter(dump) {
4040 return .{ .data = val };
4141}
4242
43pub fn fmtValue(val: Value, pt: Zcu.PerThread, opt_sema: ?*Sema) std.fmt.Formatter(print_value.format) {
43pub fn fmtValue(val: Value, pt: Zcu.PerThread) std.fmt.Formatter(print_value.format) {
4444 return .{ .data = .{
4545 .val = val,
4646 .pt = pt,
47 .opt_sema = opt_sema,
47 .opt_sema = null,
4848 .depth = 3,
4949 } };
5050}
5151
52pub fn fmtValueFull(ctx: print_value.FormatContext) std.fmt.Formatter(print_value.format) {
52pub fn fmtValueSema(val: Value, pt: Zcu.PerThread, sema: *Sema) std.fmt.Formatter(print_value.formatSema) {
53 return .{ .data = .{
54 .val = val,
55 .pt = pt,
56 .opt_sema = sema,
57 .depth = 3,
58 } };
59}
60
61pub fn fmtValueSemaFull(ctx: print_value.FormatContext) std.fmt.Formatter(print_value.formatSema) {
5362 return .{ .data = ctx };
5463}
5564
......@@ -4071,7 +4080,7 @@ pub const PointerDeriveStep = union(enum) {
40714080};
40724081
40734082pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread) Allocator.Error!PointerDeriveStep {
4074 return ptr_val.pointerDerivationAdvanced(arena, pt, null) catch |err| switch (err) {
4083 return ptr_val.pointerDerivationAdvanced(arena, pt, false, {}) catch |err| switch (err) {
40754084 error.OutOfMemory => |e| return e,
40764085 error.AnalysisFail => unreachable,
40774086 };
......@@ -4081,7 +4090,7 @@ pub fn pointerDerivation(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread) Al
40814090/// only field and element pointers with no casts. This can be used by codegen backends
40824091/// which prefer field/elem accesses when lowering constant pointer values.
40834092/// It is also used by the Value printing logic for pointers.
4084pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, opt_sema: ?*Sema) !PointerDeriveStep {
4093pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerThread, comptime have_sema: bool, sema: if (have_sema) *Sema else void) !PointerDeriveStep {
40854094 const zcu = pt.zcu;
40864095 const ptr = zcu.intern_pool.indexToKey(ptr_val.toIntern()).ptr;
40874096 const base_derive: PointerDeriveStep = switch (ptr.base_addr) {
......@@ -4104,8 +4113,9 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
41044113 } };
41054114 },
41064115 .comptime_alloc => |idx| base: {
4107 const alloc = opt_sema.?.getComptimeAlloc(idx);
4108 const val = try alloc.val.intern(pt, opt_sema.?.arena);
4116 if (!have_sema) unreachable;
4117 const alloc = sema.getComptimeAlloc(idx);
4118 const val = try alloc.val.intern(pt, sema.arena);
41094119 const ty = val.typeOf(zcu);
41104120 break :base .{ .comptime_alloc_ptr = .{
41114121 .val = val,
......@@ -4122,7 +4132,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
41224132 const base_ptr = Value.fromInterned(eu_ptr);
41234133 const base_ptr_ty = base_ptr.typeOf(zcu);
41244134 const parent_step = try arena.create(PointerDeriveStep);
4125 parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(eu_ptr), arena, pt, opt_sema);
4135 parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(eu_ptr), arena, pt, have_sema, sema);
41264136 break :base .{ .eu_payload_ptr = .{
41274137 .parent = parent_step,
41284138 .result_ptr_ty = try pt.adjustPtrTypeChild(base_ptr_ty, base_ptr_ty.childType(zcu).errorUnionPayload(zcu)),
......@@ -4132,7 +4142,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
41324142 const base_ptr = Value.fromInterned(opt_ptr);
41334143 const base_ptr_ty = base_ptr.typeOf(zcu);
41344144 const parent_step = try arena.create(PointerDeriveStep);
4135 parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(opt_ptr), arena, pt, opt_sema);
4145 parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(opt_ptr), arena, pt, have_sema, sema);
41364146 break :base .{ .opt_payload_ptr = .{
41374147 .parent = parent_step,
41384148 .result_ptr_ty = try pt.adjustPtrTypeChild(base_ptr_ty, base_ptr_ty.childType(zcu).optionalChild(zcu)),
......@@ -4143,8 +4153,8 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
41434153 const base_ptr_ty = base_ptr.typeOf(zcu);
41444154 const agg_ty = base_ptr_ty.childType(zcu);
41454155 const field_ty, const field_align = switch (agg_ty.zigTypeTag(zcu)) {
4146 .Struct => .{ agg_ty.structFieldType(@intCast(field.index), zcu), try agg_ty.structFieldAlignAdvanced(@intCast(field.index), pt, .sema) },
4147 .Union => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.structFieldAlignAdvanced(@intCast(field.index), pt, .sema) },
4156 .Struct => .{ agg_ty.structFieldType(@intCast(field.index), zcu), try agg_ty.structFieldAlignAdvanced(@intCast(field.index), pt, if (have_sema) .sema else .normal) },
4157 .Union => .{ agg_ty.unionFieldTypeByIndex(@intCast(field.index), zcu), try agg_ty.structFieldAlignAdvanced(@intCast(field.index), pt, if (have_sema) .sema else .normal) },
41484158 .Pointer => .{ switch (field.index) {
41494159 Value.slice_ptr_index => agg_ty.slicePtrFieldType(zcu),
41504160 Value.slice_len_index => Type.usize,
......@@ -4167,7 +4177,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
41674177 },
41684178 });
41694179 const parent_step = try arena.create(PointerDeriveStep);
4170 parent_step.* = try pointerDerivationAdvanced(base_ptr, arena, pt, opt_sema);
4180 parent_step.* = try pointerDerivationAdvanced(base_ptr, arena, pt, have_sema, sema);
41714181 break :base .{ .field_ptr = .{
41724182 .parent = parent_step,
41734183 .field_idx = @intCast(field.index),
......@@ -4176,7 +4186,7 @@ pub fn pointerDerivationAdvanced(ptr_val: Value, arena: Allocator, pt: Zcu.PerTh
41764186 },
41774187 .arr_elem => |arr_elem| base: {
41784188 const parent_step = try arena.create(PointerDeriveStep);
4179 parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(arr_elem.base), arena, pt, opt_sema);
4189 parent_step.* = try pointerDerivationAdvanced(Value.fromInterned(arr_elem.base), arena, pt, have_sema, sema);
41804190 const parent_ptr_info = (try parent_step.ptrType(pt)).ptrInfo(zcu);
41814191 const result_ptr_ty = try pt.ptrType(.{
41824192 .child = parent_ptr_info.child,
src/arch/x86_64/CodeGen.zig+2-2
......@@ -17975,8 +17975,8 @@ fn airShuffle(self: *Self, inst: Air.Inst.Index) !void {
1797517975
1797617976 break :result null;
1797717977 }) orelse return self.fail("TODO implement airShuffle from {} and {} to {} with {}", .{
17978 lhs_ty.fmt(pt), rhs_ty.fmt(pt), dst_ty.fmt(pt),
17979 Value.fromInterned(extra.mask).fmtValue(pt, null),
17978 lhs_ty.fmt(pt), rhs_ty.fmt(pt), dst_ty.fmt(pt),
17979 Value.fromInterned(extra.mask).fmtValue(pt),
1798017980 });
1798117981 return self.finishAir(inst, result, .{ extra.a, extra.b, .none });
1798217982}
src/codegen.zig+4-4
......@@ -188,7 +188,7 @@ pub fn generateSymbol(
188188 const target = mod.getTarget();
189189 const endian = target.cpu.arch.endian();
190190
191 log.debug("generateSymbol: val = {}", .{val.fmtValue(pt, null)});
191 log.debug("generateSymbol: val = {}", .{val.fmtValue(pt)});
192192
193193 if (val.isUndefDeep(mod)) {
194194 const abi_size = math.cast(usize, ty.abiSize(pt)) orelse return error.Overflow;
......@@ -838,7 +838,7 @@ fn genDeclRef(
838838 const zcu = pt.zcu;
839839 const ip = &zcu.intern_pool;
840840 const ty = val.typeOf(zcu);
841 log.debug("genDeclRef: val = {}", .{val.fmtValue(pt, null)});
841 log.debug("genDeclRef: val = {}", .{val.fmtValue(pt)});
842842
843843 const ptr_decl = zcu.declPtr(ptr_decl_index);
844844 const namespace = zcu.namespacePtr(ptr_decl.src_namespace);
......@@ -943,7 +943,7 @@ fn genUnnamedConst(
943943 owner_decl_index: InternPool.DeclIndex,
944944) CodeGenError!GenResult {
945945 const gpa = lf.comp.gpa;
946 log.debug("genUnnamedConst: val = {}", .{val.fmtValue(pt, null)});
946 log.debug("genUnnamedConst: val = {}", .{val.fmtValue(pt)});
947947
948948 const local_sym_index = lf.lowerUnnamedConst(pt, val, owner_decl_index) catch |err| {
949949 return GenResult.fail(gpa, src_loc, "lowering unnamed constant failed: {s}", .{@errorName(err)});
......@@ -985,7 +985,7 @@ pub fn genTypedValue(
985985 const ip = &zcu.intern_pool;
986986 const ty = val.typeOf(zcu);
987987
988 log.debug("genTypedValue: val = {}", .{val.fmtValue(pt, null)});
988 log.debug("genTypedValue: val = {}", .{val.fmtValue(pt)});
989989
990990 if (val.isUndef(zcu))
991991 return GenResult.mcv(.undef);
src/codegen/spirv.zig+1-1
......@@ -892,7 +892,7 @@ const DeclGen = struct {
892892 const result_ty_id = try self.resolveType(ty, repr);
893893 const ip = &mod.intern_pool;
894894
895 log.debug("lowering constant: ty = {}, val = {}", .{ ty.fmt(pt), val.fmtValue(pt, null) });
895 log.debug("lowering constant: ty = {}, val = {}", .{ ty.fmt(pt), val.fmtValue(pt) });
896896 if (val.isUndefDeep(mod)) {
897897 return self.spv.constUndef(result_ty_id);
898898 }
src/print_air.zig+1-1
......@@ -957,7 +957,7 @@ const Writer = struct {
957957 const ty = Type.fromInterned(pt.zcu.intern_pool.indexToKey(ip_index).typeOf());
958958 try s.print("<{}, {}>", .{
959959 ty.fmt(pt),
960 Value.fromInterned(ip_index).fmtValue(pt, null),
960 Value.fromInterned(ip_index).fmtValue(pt),
961961 });
962962 } else {
963963 return w.writeInstIndex(s, operand.toIndex().?, dies);
src/print_value.zig+69-35
......@@ -20,18 +20,35 @@ pub const FormatContext = struct {
2020 depth: u8,
2121};
2222
23pub fn format(
23pub fn formatSema(
2424 ctx: FormatContext,
2525 comptime fmt: []const u8,
2626 options: std.fmt.FormatOptions,
2727 writer: anytype,
2828) !void {
2929 _ = options;
30 const sema = ctx.opt_sema.?;
3031 comptime std.debug.assert(fmt.len == 0);
31 return print(ctx.val, writer, ctx.depth, ctx.pt, ctx.opt_sema) catch |err| switch (err) {
32 return print(ctx.val, writer, ctx.depth, ctx.pt, true, sema) catch |err| switch (err) {
3233 error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function
3334 error.ComptimeBreak, error.ComptimeReturn => unreachable,
34 error.AnalysisFail => unreachable, // TODO: re-evaluate when we use `opt_sema` more fully
35 error.AnalysisFail => unreachable, // TODO: re-evaluate when we use `sema` more fully
36 else => |e| return e,
37 };
38}
39
40pub fn format(
41 ctx: FormatContext,
42 comptime fmt: []const u8,
43 options: std.fmt.FormatOptions,
44 writer: anytype,
45) !void {
46 _ = options;
47 std.debug.assert(ctx.opt_sema == null);
48 comptime std.debug.assert(fmt.len == 0);
49 return print(ctx.val, writer, ctx.depth, ctx.pt, false, {}) catch |err| switch (err) {
50 error.OutOfMemory => @panic("OOM"), // We're not allowed to return this from a format function
51 error.ComptimeBreak, error.ComptimeReturn, error.AnalysisFail => unreachable,
3552 else => |e| return e,
3653 };
3754}
......@@ -42,7 +59,8 @@ pub fn print(
4259 level: u8,
4360 pt: Zcu.PerThread,
4461 /// If this `Sema` is provided, we will recurse through pointers where possible to provide friendly output.
45 opt_sema: ?*Sema,
62 comptime have_sema: bool,
63 sema: if (have_sema) *Sema else void,
4664) (@TypeOf(writer).Error || Zcu.CompileError)!void {
4765 const mod = pt.zcu;
4866 const ip = &mod.intern_pool;
......@@ -80,11 +98,11 @@ pub fn print(
8098 }),
8199 .int => |int| switch (int.storage) {
82100 inline .u64, .i64, .big_int => |x| try writer.print("{}", .{x}),
83 .lazy_align => |ty| if (opt_sema != null) {
101 .lazy_align => |ty| if (have_sema) {
84102 const a = (try Type.fromInterned(ty).abiAlignmentAdvanced(pt, .sema)).scalar;
85103 try writer.print("{}", .{a.toByteUnits() orelse 0});
86104 } else try writer.print("@alignOf({})", .{Type.fromInterned(ty).fmt(pt)}),
87 .lazy_size => |ty| if (opt_sema != null) {
105 .lazy_size => |ty| if (have_sema) {
88106 const s = (try Type.fromInterned(ty).abiSizeAdvanced(pt, .sema)).scalar;
89107 try writer.print("{}", .{s});
90108 } else try writer.print("@sizeOf({})", .{Type.fromInterned(ty).fmt(pt)}),
......@@ -96,7 +114,7 @@ pub fn print(
96114 .err_name => |err_name| try writer.print("error.{}", .{
97115 err_name.fmt(ip),
98116 }),
99 .payload => |payload| try print(Value.fromInterned(payload), writer, level, pt, opt_sema),
117 .payload => |payload| try print(Value.fromInterned(payload), writer, level, pt, have_sema, sema),
100118 },
101119 .enum_literal => |enum_literal| try writer.print(".{}", .{
102120 enum_literal.fmt(ip),
......@@ -110,7 +128,7 @@ pub fn print(
110128 return writer.writeAll("@enumFromInt(...)");
111129 }
112130 try writer.writeAll("@enumFromInt(");
113 try print(Value.fromInterned(enum_tag.int), writer, level - 1, pt, opt_sema);
131 try print(Value.fromInterned(enum_tag.int), writer, level - 1, pt, have_sema, sema);
114132 try writer.writeAll(")");
115133 },
116134 .empty_enum_value => try writer.writeAll("(empty enum value)"),
......@@ -124,15 +142,15 @@ pub fn print(
124142 .decl, .int => false,
125143 };
126144 if (print_contents) {
127 // TODO: eventually we want to load the slice as an array with `opt_sema`, but that's
145 // TODO: eventually we want to load the slice as an array with `sema`, but that's
128146 // currently not possible without e.g. triggering compile errors.
129147 }
130 try printPtr(Value.fromInterned(slice.ptr), writer, level, pt, opt_sema);
148 try printPtr(Value.fromInterned(slice.ptr), writer, level, pt, have_sema, sema);
131149 try writer.writeAll("[0..");
132150 if (level == 0) {
133151 try writer.writeAll("(...)");
134152 } else {
135 try print(Value.fromInterned(slice.len), writer, level - 1, pt, opt_sema);
153 try print(Value.fromInterned(slice.len), writer, level - 1, pt, have_sema, sema);
136154 }
137155 try writer.writeAll("]");
138156 },
......@@ -143,16 +161,16 @@ pub fn print(
143161 .decl, .int => false,
144162 };
145163 if (print_contents) {
146 // TODO: eventually we want to load the pointer with `opt_sema`, but that's
164 // TODO: eventually we want to load the pointer with `sema`, but that's
147165 // currently not possible without e.g. triggering compile errors.
148166 }
149 try printPtr(val, writer, level, pt, opt_sema);
167 try printPtr(val, writer, level, pt, have_sema, sema);
150168 },
151169 .opt => |opt| switch (opt.val) {
152170 .none => try writer.writeAll("null"),
153 else => |payload| try print(Value.fromInterned(payload), writer, level, pt, opt_sema),
171 else => |payload| try print(Value.fromInterned(payload), writer, level, pt, have_sema, sema),
154172 },
155 .aggregate => |aggregate| try printAggregate(val, aggregate, false, writer, level, pt, opt_sema),
173 .aggregate => |aggregate| try printAggregate(val, aggregate, false, writer, level, pt, have_sema, sema),
156174 .un => |un| {
157175 if (level == 0) {
158176 try writer.writeAll(".{ ... }");
......@@ -161,13 +179,13 @@ pub fn print(
161179 if (un.tag == .none) {
162180 const backing_ty = try val.typeOf(mod).unionBackingType(pt);
163181 try writer.print("@bitCast(@as({}, ", .{backing_ty.fmt(pt)});
164 try print(Value.fromInterned(un.val), writer, level - 1, pt, opt_sema);
182 try print(Value.fromInterned(un.val), writer, level - 1, pt, have_sema, sema);
165183 try writer.writeAll("))");
166184 } else {
167185 try writer.writeAll(".{ ");
168 try print(Value.fromInterned(un.tag), writer, level - 1, pt, opt_sema);
186 try print(Value.fromInterned(un.tag), writer, level - 1, pt, have_sema, sema);
169187 try writer.writeAll(" = ");
170 try print(Value.fromInterned(un.val), writer, level - 1, pt, opt_sema);
188 try print(Value.fromInterned(un.val), writer, level - 1, pt, have_sema, sema);
171189 try writer.writeAll(" }");
172190 }
173191 },
......@@ -182,7 +200,8 @@ fn printAggregate(
182200 writer: anytype,
183201 level: u8,
184202 pt: Zcu.PerThread,
185 opt_sema: ?*Sema,
203 comptime have_sema: bool,
204 sema: if (have_sema) *Sema else void,
186205) (@TypeOf(writer).Error || Zcu.CompileError)!void {
187206 if (level == 0) {
188207 if (is_ref) try writer.writeByte('&');
......@@ -203,7 +222,7 @@ fn printAggregate(
203222 if (i != 0) try writer.writeAll(", ");
204223 const field_name = ty.structFieldName(@intCast(i), zcu).unwrap().?;
205224 try writer.print(".{i} = ", .{field_name.fmt(ip)});
206 try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
225 try print(try val.fieldValue(pt, i), writer, level - 1, pt, have_sema, sema);
207226 }
208227 try writer.writeAll(" }");
209228 return;
......@@ -253,7 +272,7 @@ fn printAggregate(
253272 const max_len = @min(len, max_aggregate_items);
254273 for (0..max_len) |i| {
255274 if (i != 0) try writer.writeAll(", ");
256 try print(try val.fieldValue(pt, i), writer, level - 1, pt, opt_sema);
275 try print(try val.fieldValue(pt, i), writer, level - 1, pt, have_sema, sema);
257276 }
258277 if (len > max_aggregate_items) {
259278 try writer.writeAll(", ...");
......@@ -261,7 +280,14 @@ fn printAggregate(
261280 return writer.writeAll(" }");
262281}
263282
264fn printPtr(ptr_val: Value, writer: anytype, level: u8, pt: Zcu.PerThread, opt_sema: ?*Sema) (@TypeOf(writer).Error || Zcu.CompileError)!void {
283fn printPtr(
284 ptr_val: Value,
285 writer: anytype,
286 level: u8,
287 pt: Zcu.PerThread,
288 comptime have_sema: bool,
289 sema: if (have_sema) *Sema else void,
290) (@TypeOf(writer).Error || Zcu.CompileError)!void {
265291 const ptr = switch (pt.zcu.intern_pool.indexToKey(ptr_val.toIntern())) {
266292 .undef => return writer.writeAll("undefined"),
267293 .ptr => |ptr| ptr,
......@@ -278,7 +304,8 @@ fn printPtr(ptr_val: Value, writer: anytype, level: u8, pt: Zcu.PerThread, opt_s
278304 writer,
279305 level,
280306 pt,
281 opt_sema,
307 have_sema,
308 sema,
282309 ),
283310 else => {},
284311 }
......@@ -286,12 +313,19 @@ fn printPtr(ptr_val: Value, writer: anytype, level: u8, pt: Zcu.PerThread, opt_s
286313
287314 var arena = std.heap.ArenaAllocator.init(pt.zcu.gpa);
288315 defer arena.deinit();
289 const derivation = try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, opt_sema);
290 try printPtrDerivation(derivation, writer, level, pt, opt_sema);
316 const derivation = try ptr_val.pointerDerivationAdvanced(arena.allocator(), pt, have_sema, sema);
317 try printPtrDerivation(derivation, writer, level, pt, have_sema, sema);
291318}
292319
293320/// Print `derivation` as an lvalue, i.e. such that writing `&` before this gives the pointer value.
294fn printPtrDerivation(derivation: Value.PointerDeriveStep, writer: anytype, level: u8, pt: Zcu.PerThread, opt_sema: ?*Sema) (@TypeOf(writer).Error || Zcu.CompileError)!void {
321fn printPtrDerivation(
322 derivation: Value.PointerDeriveStep,
323 writer: anytype,
324 level: u8,
325 pt: Zcu.PerThread,
326 comptime have_sema: bool,
327 sema: if (have_sema) *Sema else void,
328) (@TypeOf(writer).Error || Zcu.CompileError)!void {
295329 const zcu = pt.zcu;
296330 const ip = &zcu.intern_pool;
297331 switch (derivation) {
......@@ -305,31 +339,31 @@ fn printPtrDerivation(derivation: Value.PointerDeriveStep, writer: anytype, leve
305339 .anon_decl_ptr => |anon| {
306340 const ty = Value.fromInterned(anon.val).typeOf(zcu);
307341 try writer.print("@as({}, ", .{ty.fmt(pt)});
308 try print(Value.fromInterned(anon.val), writer, level - 1, pt, opt_sema);
342 try print(Value.fromInterned(anon.val), writer, level - 1, pt, have_sema, sema);
309343 try writer.writeByte(')');
310344 },
311345 .comptime_alloc_ptr => |info| {
312346 try writer.print("@as({}, ", .{info.val.typeOf(zcu).fmt(pt)});
313 try print(info.val, writer, level - 1, pt, opt_sema);
347 try print(info.val, writer, level - 1, pt, have_sema, sema);
314348 try writer.writeByte(')');
315349 },
316350 .comptime_field_ptr => |val| {
317351 const ty = val.typeOf(zcu);
318352 try writer.print("@as({}, ", .{ty.fmt(pt)});
319 try print(val, writer, level - 1, pt, opt_sema);
353 try print(val, writer, level - 1, pt, have_sema, sema);
320354 try writer.writeByte(')');
321355 },
322356 .eu_payload_ptr => |info| {
323357 try writer.writeByte('(');
324 try printPtrDerivation(info.parent.*, writer, level, pt, opt_sema);
358 try printPtrDerivation(info.parent.*, writer, level, pt, have_sema, sema);
325359 try writer.writeAll(" catch unreachable)");
326360 },
327361 .opt_payload_ptr => |info| {
328 try printPtrDerivation(info.parent.*, writer, level, pt, opt_sema);
362 try printPtrDerivation(info.parent.*, writer, level, pt, have_sema, sema);
329363 try writer.writeAll(".?");
330364 },
331365 .field_ptr => |field| {
332 try printPtrDerivation(field.parent.*, writer, level, pt, opt_sema);
366 try printPtrDerivation(field.parent.*, writer, level, pt, have_sema, sema);
333367 const agg_ty = (try field.parent.ptrType(pt)).childType(zcu);
334368 switch (agg_ty.zigTypeTag(zcu)) {
335369 .Struct => if (agg_ty.structFieldName(field.field_idx, zcu).unwrap()) |field_name| {
......@@ -351,16 +385,16 @@ fn printPtrDerivation(derivation: Value.PointerDeriveStep, writer: anytype, leve
351385 }
352386 },
353387 .elem_ptr => |elem| {
354 try printPtrDerivation(elem.parent.*, writer, level, pt, opt_sema);
388 try printPtrDerivation(elem.parent.*, writer, level, pt, have_sema, sema);
355389 try writer.print("[{d}]", .{elem.elem_idx});
356390 },
357391 .offset_and_cast => |oac| if (oac.byte_offset == 0) {
358392 try writer.print("@as({}, @ptrCast(", .{oac.new_ptr_ty.fmt(pt)});
359 try printPtrDerivation(oac.parent.*, writer, level, pt, opt_sema);
393 try printPtrDerivation(oac.parent.*, writer, level, pt, have_sema, sema);
360394 try writer.writeAll("))");
361395 } else {
362396 try writer.print("@as({}, @ptrFromInt(@intFromPtr(", .{oac.new_ptr_ty.fmt(pt)});
363 try printPtrDerivation(oac.parent.*, writer, level, pt, opt_sema);
397 try printPtrDerivation(oac.parent.*, writer, level, pt, have_sema, sema);
364398 try writer.print(") + {d}))", .{oac.byte_offset});
365399 },
366400 }