authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2024-07-16 19:22:39+01:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2024-07-16 19:22:39+01:00
logee695c8ef40ae7cecb4b9a77c8a6dcbe53d4f013
tree91fbc76758cd5b2630c0f7f846e1b5fc7146369b
parenta58ceb3d554a9565a6cc0443f6384149ae2b3145
parentf84a4953d29ffc2bdc94fa353cac685430e6bbe4
signaturebadge-check Signed by PGP key B5690EEEBB952194

Merge pull request #20637 from mlugg/comptime-resolution-strat

Type,Value: mark `ResolveStrat` parameter of type queries as `comptime`

9 files changed, 183 insertions(+), 135 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", .{});
......@@ -23194,12 +23194,12 @@ fn ptrCastFull(
2319423194 return sema.failWithOwnedErrorMsg(block, msg: {
2319523195 const msg = if (src_info.sentinel == .none) blk: {
2319623196 break :blk try sema.errMsg(src, "destination pointer requires '{}' sentinel", .{
23197 Value.fromInterned(dest_info.sentinel).fmtValue(pt, sema),
23197 Value.fromInterned(dest_info.sentinel).fmtValueSema(pt, sema),
2319823198 });
2319923199 } else blk: {
2320023200 break :blk try sema.errMsg(src, "pointer sentinel '{}' cannot coerce into pointer sentinel '{}'", .{
23201 Value.fromInterned(src_info.sentinel).fmtValue(pt, sema),
23202 Value.fromInterned(dest_info.sentinel).fmtValue(pt, sema),
23201 Value.fromInterned(src_info.sentinel).fmtValueSema(pt, sema),
23202 Value.fromInterned(dest_info.sentinel).fmtValueSema(pt, sema),
2320323203 });
2320423204 };
2320523205 errdefer msg.destroy(sema.gpa);
......@@ -25692,10 +25692,10 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2569225692 const msg = try sema.errMsg(src, "non-matching @memcpy lengths", .{});
2569325693 errdefer msg.destroy(sema.gpa);
2569425694 try sema.errNote(dest_src, msg, "length {} here", .{
25695 dest_len_val.fmtValue(pt, sema),
25695 dest_len_val.fmtValueSema(pt, sema),
2569625696 });
2569725697 try sema.errNote(src_src, msg, "length {} here", .{
25698 src_len_val.fmtValue(pt, sema),
25698 src_len_val.fmtValueSema(pt, sema),
2569925699 });
2570025700 break :msg msg;
2570125701 };
......@@ -29563,7 +29563,7 @@ fn coerceExtra(
2956329563 // comptime-known integer to other number
2956429564 if (!(try sema.intFitsInType(val, dest_ty, null))) {
2956529565 if (!opts.report_err) return error.NotCoercible;
29566 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(pt), val.fmtValue(pt, sema) });
29566 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(pt), val.fmtValueSema(pt, sema) });
2956729567 }
2956829568 return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
2956929569 .undef => try pt.undefRef(dest_ty),
......@@ -29608,7 +29608,7 @@ fn coerceExtra(
2960829608 block,
2960929609 inst_src,
2961029610 "type '{}' cannot represent float value '{}'",
29611 .{ dest_ty.fmt(pt), val.fmtValue(pt, sema) },
29611 .{ dest_ty.fmt(pt), val.fmtValueSema(pt, sema) },
2961229612 );
2961329613 }
2961429614 return Air.internedToRef(result_val.toIntern());
......@@ -30026,11 +30026,11 @@ const InMemoryCoercionResult = union(enum) {
3002630026 .array_sentinel => |sentinel| {
3002730027 if (sentinel.actual.toIntern() != .unreachable_value) {
3002830028 try sema.errNote(src, msg, "array sentinel '{}' cannot cast into array sentinel '{}'", .{
30029 sentinel.actual.fmtValue(pt, sema), sentinel.wanted.fmtValue(pt, sema),
30029 sentinel.actual.fmtValueSema(pt, sema), sentinel.wanted.fmtValueSema(pt, sema),
3003030030 });
3003130031 } else {
3003230032 try sema.errNote(src, msg, "destination array requires '{}' sentinel", .{
30033 sentinel.wanted.fmtValue(pt, sema),
30033 sentinel.wanted.fmtValueSema(pt, sema),
3003430034 });
3003530035 }
3003630036 break;
......@@ -30152,11 +30152,11 @@ const InMemoryCoercionResult = union(enum) {
3015230152 .ptr_sentinel => |sentinel| {
3015330153 if (sentinel.actual.toIntern() != .unreachable_value) {
3015430154 try sema.errNote(src, msg, "pointer sentinel '{}' cannot cast into pointer sentinel '{}'", .{
30155 sentinel.actual.fmtValue(pt, sema), sentinel.wanted.fmtValue(pt, sema),
30155 sentinel.actual.fmtValueSema(pt, sema), sentinel.wanted.fmtValueSema(pt, sema),
3015630156 });
3015730157 } else {
3015830158 try sema.errNote(src, msg, "destination pointer requires '{}' sentinel", .{
30159 sentinel.wanted.fmtValue(pt, sema),
30159 sentinel.wanted.fmtValueSema(pt, sema),
3016030160 });
3016130161 }
3016230162 break;
......@@ -31412,7 +31412,7 @@ fn coerceEnumToUnion(
3141231412 if (try sema.resolveDefinedValue(block, inst_src, enum_tag)) |val| {
3141331413 const field_index = union_ty.unionTagFieldIndex(val, pt.zcu) orelse {
3141431414 return sema.fail(block, inst_src, "union '{}' has no tag with value '{}'", .{
31415 union_ty.fmt(pt), val.fmtValue(pt, sema),
31415 union_ty.fmt(pt), val.fmtValueSema(pt, sema),
3141631416 });
3141731417 };
3141831418
......@@ -32644,8 +32644,8 @@ fn analyzeSlice(
3264432644 msg,
3264532645 "expected '{}', found '{}'",
3264632646 .{
32647 Value.zero_comptime_int.fmtValue(pt, sema),
32648 start_value.fmtValue(pt, sema),
32647 Value.zero_comptime_int.fmtValueSema(pt, sema),
32648 start_value.fmtValueSema(pt, sema),
3264932649 },
3265032650 );
3265132651 break :msg msg;
......@@ -32660,8 +32660,8 @@ fn analyzeSlice(
3266032660 msg,
3266132661 "expected '{}', found '{}'",
3266232662 .{
32663 Value.one_comptime_int.fmtValue(pt, sema),
32664 end_value.fmtValue(pt, sema),
32663 Value.one_comptime_int.fmtValueSema(pt, sema),
32664 end_value.fmtValueSema(pt, sema),
3266532665 },
3266632666 );
3266732667 break :msg msg;
......@@ -32674,7 +32674,7 @@ fn analyzeSlice(
3267432674 block,
3267532675 end_src,
3267632676 "end index {} out of bounds for slice of single-item pointer",
32677 .{end_value.fmtValue(pt, sema)},
32677 .{end_value.fmtValueSema(pt, sema)},
3267832678 );
3267932679 }
3268032680 }
......@@ -32769,8 +32769,8 @@ fn analyzeSlice(
3276932769 end_src,
3277032770 "end index {} out of bounds for array of length {}{s}",
3277132771 .{
32772 end_val.fmtValue(pt, sema),
32773 len_val.fmtValue(pt, sema),
32772 end_val.fmtValueSema(pt, sema),
32773 len_val.fmtValueSema(pt, sema),
3277432774 sentinel_label,
3277532775 },
3277632776 );
......@@ -32814,7 +32814,7 @@ fn analyzeSlice(
3281432814 end_src,
3281532815 "end index {} out of bounds for slice of length {d}{s}",
3281632816 .{
32817 end_val.fmtValue(pt, sema),
32817 end_val.fmtValueSema(pt, sema),
3281832818 try slice_val.sliceLen(pt),
3281932819 sentinel_label,
3282032820 },
......@@ -32874,8 +32874,8 @@ fn analyzeSlice(
3287432874 start_src,
3287532875 "start index {} is larger than end index {}",
3287632876 .{
32877 start_val.fmtValue(pt, sema),
32878 end_val.fmtValue(pt, sema),
32877 start_val.fmtValueSema(pt, sema),
32878 end_val.fmtValueSema(pt, sema),
3287932879 },
3288032880 );
3288132881 }
......@@ -32912,8 +32912,8 @@ fn analyzeSlice(
3291232912 const msg = try sema.errMsg(src, "value in memory does not match slice sentinel", .{});
3291332913 errdefer msg.destroy(sema.gpa);
3291432914 try sema.errNote(src, msg, "expected '{}', found '{}'", .{
32915 expected_sentinel.fmtValue(pt, sema),
32916 actual_sentinel.fmtValue(pt, sema),
32915 expected_sentinel.fmtValueSema(pt, sema),
32916 actual_sentinel.fmtValueSema(pt, sema),
3291732917 });
3291832918
3291932919 break :msg msg;
......@@ -36656,7 +36656,7 @@ fn semaUnionFields(pt: Zcu.PerThread, arena: Allocator, union_type: InternPool.L
3665636656 .offset = .{ .container_field_value = @intCast(gop.index) },
3665736657 };
3665836658 const msg = msg: {
36659 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValue(pt, &sema)});
36659 const msg = try sema.errMsg(value_src, "enum tag value {} already taken", .{enum_tag_val.fmtValueSema(pt, &sema)});
3666036660 errdefer msg.destroy(gpa);
3666136661 try sema.errNote(other_value_src, msg, "other occurrence here", .{});
3666236662 break :msg msg;
......@@ -37888,7 +37888,7 @@ fn intFromFloatScalar(
3788837888 block,
3788937889 src,
3789037890 "fractional component prevents float value '{}' from coercion to type '{}'",
37891 .{ val.fmtValue(pt, sema), int_ty.fmt(pt) },
37891 .{ val.fmtValueSema(pt, sema), int_ty.fmt(pt) },
3789237892 );
3789337893
3789437894 const float = val.toFloat(f128, pt);
......@@ -37910,7 +37910,7 @@ fn intFromFloatScalar(
3791037910
3791137911 if (!(try sema.intFitsInType(cti_result, int_ty, null))) {
3791237912 return sema.fail(block, src, "float value '{}' cannot be stored in integer type '{}'", .{
37913 val.fmtValue(pt, sema), int_ty.fmt(pt),
37913 val.fmtValueSema(pt, sema), int_ty.fmt(pt),
3791437914 });
3791537915 }
3791637916 return pt.getCoerced(cti_result, int_ty);
src/Type.zig+23-19
......@@ -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("}");
......@@ -478,7 +478,7 @@ pub fn hasRuntimeBitsAdvanced(
478478 ty: Type,
479479 pt: Zcu.PerThread,
480480 ignore_comptime_only: bool,
481 strat: ResolveStratLazy,
481 comptime strat: ResolveStratLazy,
482482) RuntimeBitsError!bool {
483483 const mod = pt.zcu;
484484 const ip = &mod.intern_pool;
......@@ -792,7 +792,7 @@ pub fn fnHasRuntimeBits(ty: Type, pt: Zcu.PerThread) bool {
792792/// Determines whether a function type has runtime bits, i.e. whether a
793793/// function with this type can exist at runtime.
794794/// Asserts that `ty` is a function type.
795pub fn fnHasRuntimeBitsAdvanced(ty: Type, pt: Zcu.PerThread, strat: ResolveStrat) SemaError!bool {
795pub fn fnHasRuntimeBitsAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) SemaError!bool {
796796 const fn_info = pt.zcu.typeToFunc(ty).?;
797797 if (fn_info.is_generic) return false;
798798 if (fn_info.is_var_args) return true;
......@@ -824,7 +824,7 @@ pub fn ptrAlignment(ty: Type, pt: Zcu.PerThread) Alignment {
824824 return ptrAlignmentAdvanced(ty, pt, .normal) catch unreachable;
825825}
826826
827pub fn ptrAlignmentAdvanced(ty: Type, pt: Zcu.PerThread, strat: ResolveStrat) !Alignment {
827pub fn ptrAlignmentAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Alignment {
828828 return switch (pt.zcu.intern_pool.indexToKey(ty.toIntern())) {
829829 .ptr_type => |ptr_type| {
830830 if (ptr_type.flags.alignment != .none)
......@@ -891,7 +891,7 @@ pub const ResolveStrat = enum {
891891 /// This should typically be used from semantic analysis.
892892 sema,
893893
894 pub fn toLazy(strat: ResolveStrat) ResolveStratLazy {
894 pub inline fn toLazy(strat: ResolveStrat) ResolveStratLazy {
895895 return switch (strat) {
896896 .normal => .eager,
897897 .sema => .sema,
......@@ -908,7 +908,7 @@ pub const ResolveStrat = enum {
908908pub fn abiAlignmentAdvanced(
909909 ty: Type,
910910 pt: Zcu.PerThread,
911 strat: ResolveStratLazy,
911 comptime strat: ResolveStratLazy,
912912) SemaError!AbiAlignmentAdvanced {
913913 const mod = pt.zcu;
914914 const target = mod.getTarget();
......@@ -932,7 +932,9 @@ pub fn abiAlignmentAdvanced(
932932 if (vector_type.len == 0) return .{ .scalar = .@"1" };
933933 switch (mod.comp.getZigBackend()) {
934934 else => {
935 const elem_bits: u32 = @intCast(try Type.fromInterned(vector_type.child).bitSizeAdvanced(pt, .sema));
935 // This is fine because the child type of a vector always has a bit-size known
936 // without needing any type resolution.
937 const elem_bits: u32 = @intCast(Type.fromInterned(vector_type.child).bitSize(pt));
936938 if (elem_bits == 0) return .{ .scalar = .@"1" };
937939 const bytes = ((elem_bits * vector_type.len) + 7) / 8;
938940 const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
......@@ -1130,7 +1132,7 @@ pub fn abiAlignmentAdvanced(
11301132fn abiAlignmentAdvancedErrorUnion(
11311133 ty: Type,
11321134 pt: Zcu.PerThread,
1133 strat: ResolveStratLazy,
1135 comptime strat: ResolveStratLazy,
11341136 payload_ty: Type,
11351137) SemaError!AbiAlignmentAdvanced {
11361138 // This code needs to be kept in sync with the equivalent switch prong
......@@ -1167,7 +1169,7 @@ fn abiAlignmentAdvancedErrorUnion(
11671169fn abiAlignmentAdvancedOptional(
11681170 ty: Type,
11691171 pt: Zcu.PerThread,
1170 strat: ResolveStratLazy,
1172 comptime strat: ResolveStratLazy,
11711173) SemaError!AbiAlignmentAdvanced {
11721174 const mod = pt.zcu;
11731175 const target = mod.getTarget();
......@@ -1231,7 +1233,7 @@ const AbiSizeAdvanced = union(enum) {
12311233pub fn abiSizeAdvanced(
12321234 ty: Type,
12331235 pt: Zcu.PerThread,
1234 strat: ResolveStratLazy,
1236 comptime strat: ResolveStratLazy,
12351237) SemaError!AbiSizeAdvanced {
12361238 const mod = pt.zcu;
12371239 const target = mod.getTarget();
......@@ -1505,7 +1507,7 @@ pub fn abiSizeAdvanced(
15051507fn abiSizeAdvancedOptional(
15061508 ty: Type,
15071509 pt: Zcu.PerThread,
1508 strat: ResolveStratLazy,
1510 comptime strat: ResolveStratLazy,
15091511) SemaError!AbiSizeAdvanced {
15101512 const mod = pt.zcu;
15111513 const child_ty = ty.optionalChild(mod);
......@@ -1680,7 +1682,7 @@ pub fn bitSize(ty: Type, pt: Zcu.PerThread) u64 {
16801682pub fn bitSizeAdvanced(
16811683 ty: Type,
16821684 pt: Zcu.PerThread,
1683 strat: ResolveStrat,
1685 comptime strat: ResolveStrat,
16841686) SemaError!u64 {
16851687 const mod = pt.zcu;
16861688 const target = mod.getTarget();
......@@ -2739,7 +2741,7 @@ pub fn comptimeOnly(ty: Type, pt: Zcu.PerThread) bool {
27392741
27402742/// `generic_poison` will return false.
27412743/// May return false negatives when structs and unions are having their field types resolved.
2742pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, strat: ResolveStrat) SemaError!bool {
2744pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) SemaError!bool {
27432745 const mod = pt.zcu;
27442746 const ip = &mod.intern_pool;
27452747 return switch (ty.toIntern()) {
......@@ -2829,7 +2831,8 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, strat: ResolveStrat) Se
28292831 .no, .wip => false,
28302832 .yes => true,
28312833 .unknown => {
2832 assert(strat == .sema);
2834 // Inlined `assert` so that the resolution calls below are not statically reachable.
2835 if (strat != .sema) unreachable;
28332836
28342837 if (struct_type.flagsUnordered(ip).field_types_wip) {
28352838 struct_type.setRequiresComptime(ip, .unknown);
......@@ -2874,7 +2877,8 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, strat: ResolveStrat) Se
28742877 .no, .wip => return false,
28752878 .yes => return true,
28762879 .unknown => {
2877 assert(strat == .sema);
2880 // Inlined `assert` so that the resolution calls below are not statically reachable.
2881 if (strat != .sema) unreachable;
28782882
28792883 if (union_type.flagsUnordered(ip).status == .field_types_wip) {
28802884 union_type.setRequiresComptime(ip, .unknown);
......@@ -3198,7 +3202,7 @@ pub fn structFieldAlign(ty: Type, index: usize, pt: Zcu.PerThread) Alignment {
31983202 return ty.structFieldAlignAdvanced(index, pt, .normal) catch unreachable;
31993203}
32003204
3201pub fn structFieldAlignAdvanced(ty: Type, index: usize, pt: Zcu.PerThread, strat: ResolveStrat) !Alignment {
3205pub fn structFieldAlignAdvanced(ty: Type, index: usize, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Alignment {
32023206 const ip = &pt.zcu.intern_pool;
32033207 switch (ip.indexToKey(ty.toIntern())) {
32043208 .struct_type => {
src/Value.zig+31-21
......@@ -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
......@@ -178,7 +187,7 @@ pub fn toBigIntAdvanced(
178187 val: Value,
179188 space: *BigIntSpace,
180189 pt: Zcu.PerThread,
181 strat: ResolveStrat,
190 comptime strat: ResolveStrat,
182191) Module.CompileError!BigIntConst {
183192 return switch (val.toIntern()) {
184193 .bool_false => BigIntMutable.init(&space.limbs, 0).toConst(),
......@@ -240,7 +249,7 @@ pub fn getUnsignedInt(val: Value, pt: Zcu.PerThread) ?u64 {
240249
241250/// If the value fits in a u64, return it, otherwise null.
242251/// Asserts not undefined.
243pub fn getUnsignedIntAdvanced(val: Value, pt: Zcu.PerThread, strat: ResolveStrat) !?u64 {
252pub fn getUnsignedIntAdvanced(val: Value, pt: Zcu.PerThread, comptime strat: ResolveStrat) !?u64 {
244253 const mod = pt.zcu;
245254 return switch (val.toIntern()) {
246255 .undef => unreachable,
......@@ -1042,7 +1051,7 @@ pub fn orderAgainstZero(lhs: Value, pt: Zcu.PerThread) std.math.Order {
10421051pub fn orderAgainstZeroAdvanced(
10431052 lhs: Value,
10441053 pt: Zcu.PerThread,
1045 strat: ResolveStrat,
1054 comptime strat: ResolveStrat,
10461055) Module.CompileError!std.math.Order {
10471056 return switch (lhs.toIntern()) {
10481057 .bool_false => .eq,
......@@ -1081,7 +1090,7 @@ pub fn order(lhs: Value, rhs: Value, pt: Zcu.PerThread) std.math.Order {
10811090}
10821091
10831092/// Asserts the value is comparable.
1084pub fn orderAdvanced(lhs: Value, rhs: Value, pt: Zcu.PerThread, strat: ResolveStrat) !std.math.Order {
1093pub fn orderAdvanced(lhs: Value, rhs: Value, pt: Zcu.PerThread, comptime strat: ResolveStrat) !std.math.Order {
10851094 const lhs_against_zero = try lhs.orderAgainstZeroAdvanced(pt, strat);
10861095 const rhs_against_zero = try rhs.orderAgainstZeroAdvanced(pt, strat);
10871096 switch (lhs_against_zero) {
......@@ -1119,7 +1128,7 @@ pub fn compareHeteroAdvanced(
11191128 op: std.math.CompareOperator,
11201129 rhs: Value,
11211130 pt: Zcu.PerThread,
1122 strat: ResolveStrat,
1131 comptime strat: ResolveStrat,
11231132) !bool {
11241133 if (lhs.pointerDecl(pt.zcu)) |lhs_decl| {
11251134 if (rhs.pointerDecl(pt.zcu)) |rhs_decl| {
......@@ -1199,7 +1208,7 @@ pub fn compareAllWithZeroAdvancedExtra(
11991208 lhs: Value,
12001209 op: std.math.CompareOperator,
12011210 pt: Zcu.PerThread,
1202 strat: ResolveStrat,
1211 comptime strat: ResolveStrat,
12031212) Module.CompileError!bool {
12041213 const mod = pt.zcu;
12051214 if (lhs.isInf(mod)) {
......@@ -1505,7 +1514,7 @@ pub fn floatFromIntAdvanced(
15051514 int_ty: Type,
15061515 float_ty: Type,
15071516 pt: Zcu.PerThread,
1508 strat: ResolveStrat,
1517 comptime strat: ResolveStrat,
15091518) !Value {
15101519 const mod = pt.zcu;
15111520 if (int_ty.zigTypeTag(mod) == .Vector) {
......@@ -1523,7 +1532,7 @@ pub fn floatFromIntAdvanced(
15231532 return floatFromIntScalar(val, float_ty, pt, strat);
15241533}
15251534
1526pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, strat: ResolveStrat) !Value {
1535pub fn floatFromIntScalar(val: Value, float_ty: Type, pt: Zcu.PerThread, comptime strat: ResolveStrat) !Value {
15271536 const mod = pt.zcu;
15281537 return switch (mod.intern_pool.indexToKey(val.toIntern())) {
15291538 .undef => try pt.undefValue(float_ty),
......@@ -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/Zcu/PerThread.zig+2-2
......@@ -3163,7 +3163,7 @@ pub fn unionFieldNormalAlignmentAdvanced(
31633163 pt: Zcu.PerThread,
31643164 loaded_union: InternPool.LoadedUnionType,
31653165 field_index: u32,
3166 strat: Type.ResolveStrat,
3166 comptime strat: Type.ResolveStrat,
31673167) Zcu.SemaError!InternPool.Alignment {
31683168 const ip = &pt.zcu.intern_pool;
31693169 assert(loaded_union.flagsUnordered(ip).layout != .@"packed");
......@@ -3191,7 +3191,7 @@ pub fn structFieldAlignmentAdvanced(
31913191 explicit_alignment: InternPool.Alignment,
31923192 field_ty: Type,
31933193 layout: std.builtin.Type.ContainerLayout,
3194 strat: Type.ResolveStrat,
3194 comptime strat: Type.ResolveStrat,
31953195) Zcu.SemaError!InternPool.Alignment {
31963196 assert(layout != .@"packed");
31973197 if (explicit_alignment != .none) return explicit_alignment;
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 }