authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2023-10-24 05:03:25+01:00
committergravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2023-10-24 14:28:34+01:00
log67caf685056bcdbbe4e696cada927615b0dd6fe9
tree2f715cabde6864720c4943e006cab600c3416e5d
parent7882bdcb7e1b012ff388c4abe0b57aa048bb2ce3
signaturelock-open Commit is signed but in an unrecognized format.

Sema: rename value resolution functions

Having simplified these functions in a previous commit, I felt inclined to refactor their names, which were previously quite inconsistent. There are now 4 "core" functions: * `resolveValue` (previously `resolveMaybeUndefVal`) allows runtime-known and undef values. * `resolveConstValue` (previously `resolveConstMaybeUndefVal`) allows undef but not runtime-known values. * `resolveDefinedValue` (name unchanged) allows runtime-known values but not comptime-known undef. * `resolveConstDefinedValue` (previously `resolveConstValue`) does not allow runtime-known or undef values. You can see the inconsistencies in the old names here - sometimes we specified "maybe undef", and sometimes we went the other way by specifying "defined". With the new names, the most common function, `resolveValue`, has the shortest name and does the most general thing, and is the baseline that the other functions are adding logic to. Some other functions were also renamed: * `resolveMaybeUndefLazyVal` -> `resolveValueResolveLazy` * `resolveMaybeUndefValIntable` -> `resolveValueIntable` * `resolveMaybeUndefValAllowVariables` -> `resolveValueAllowVariables`

1 files changed, 258 insertions(+), 259 deletions(-)

src/Sema.zig+258-259
...@@ -1741,7 +1741,7 @@ fn analyzeBodyInner(...@@ -1741,7 +1741,7 @@ fn analyzeBodyInner(
1741 }1741 }
1742 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);1742 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);
1743 assert(is_non_err != .none);1743 assert(is_non_err != .none);
1744 const is_non_err_val = try sema.resolveConstValue(block, operand_src, is_non_err, .{1744 const is_non_err_val = try sema.resolveConstDefinedValue(block, operand_src, is_non_err, .{
1745 .needed_comptime_reason = "try operand inside comptime block must be comptime-known",1745 .needed_comptime_reason = "try operand inside comptime block must be comptime-known",
1746 .block_comptime_reason = block.comptime_reason,1746 .block_comptime_reason = block.comptime_reason,
1747 });1747 });
...@@ -1767,7 +1767,7 @@ fn analyzeBodyInner(...@@ -1767,7 +1767,7 @@ fn analyzeBodyInner(
1767 const err_union = try sema.analyzeLoad(block, src, operand, operand_src);1767 const err_union = try sema.analyzeLoad(block, src, operand, operand_src);
1768 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);1768 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);
1769 assert(is_non_err != .none);1769 assert(is_non_err != .none);
1770 const is_non_err_val = try sema.resolveConstValue(block, operand_src, is_non_err, .{1770 const is_non_err_val = try sema.resolveConstDefinedValue(block, operand_src, is_non_err, .{
1771 .needed_comptime_reason = "try operand inside comptime block must be comptime-known",1771 .needed_comptime_reason = "try operand inside comptime block must be comptime-known",
1772 .block_comptime_reason = block.comptime_reason,1772 .block_comptime_reason = block.comptime_reason,
1773 });1773 });
...@@ -1866,7 +1866,7 @@ fn resolveConstBool(...@@ -1866,7 +1866,7 @@ fn resolveConstBool(
1866 const air_inst = try sema.resolveInst(zir_ref);1866 const air_inst = try sema.resolveInst(zir_ref);
1867 const wanted_type = Type.bool;1867 const wanted_type = Type.bool;
1868 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);1868 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
1869 const val = try sema.resolveConstValue(block, src, coerced_inst, reason);1869 const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, reason);
1870 return val.toBool();1870 return val.toBool();
1871}1871}
18721872
...@@ -1880,7 +1880,7 @@ pub fn resolveConstString(...@@ -1880,7 +1880,7 @@ pub fn resolveConstString(
1880 const air_inst = try sema.resolveInst(zir_ref);1880 const air_inst = try sema.resolveInst(zir_ref);
1881 const wanted_type = Type.slice_const_u8;1881 const wanted_type = Type.slice_const_u8;
1882 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);1882 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
1883 const val = try sema.resolveConstValue(block, src, coerced_inst, reason);1883 const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, reason);
1884 return val.toAllocatedBytes(wanted_type, sema.arena, sema.mod);1884 return val.toAllocatedBytes(wanted_type, sema.arena, sema.mod);
1885}1885}
18861886
...@@ -1894,7 +1894,7 @@ pub fn resolveConstStringIntern(...@@ -1894,7 +1894,7 @@ pub fn resolveConstStringIntern(
1894 const air_inst = try sema.resolveInst(zir_ref);1894 const air_inst = try sema.resolveInst(zir_ref);
1895 const wanted_type = Type.slice_const_u8;1895 const wanted_type = Type.slice_const_u8;
1896 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);1896 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
1897 const val = try sema.resolveConstValue(block, src, coerced_inst, reason);1897 const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, reason);
1898 return val.toIpString(wanted_type, sema.mod);1898 return val.toIpString(wanted_type, sema.mod);
1899}1899}
19001900
...@@ -2024,7 +2024,7 @@ fn analyzeAsType(...@@ -2024,7 +2024,7 @@ fn analyzeAsType(
2024) !Type {2024) !Type {
2025 const wanted_type = Type.type;2025 const wanted_type = Type.type;
2026 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);2026 const coerced_inst = try sema.coerce(block, wanted_type, air_inst, src);
2027 const val = try sema.resolveConstValue(block, src, coerced_inst, .{2027 const val = try sema.resolveConstDefinedValue(block, src, coerced_inst, .{
2028 .needed_comptime_reason = "types must be comptime-known",2028 .needed_comptime_reason = "types must be comptime-known",
2029 });2029 });
2030 return val.toType();2030 return val.toType();
...@@ -2071,44 +2071,30 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)...@@ -2071,44 +2071,30 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
2071 try block.instructions.insertSlice(gpa, last_arg_index, err_trace_block.instructions.items);2071 try block.instructions.insertSlice(gpa, last_arg_index, err_trace_block.instructions.items);
2072}2072}
20732073
2074/// Return the Value corresponding to a given AIR ref, or `null` if it2074/// Return the Value corresponding to a given AIR ref, or `null` if it refers to a runtime value.
2075/// refers to a runtime value.
2076/// InternPool key `variable` is considered a runtime value.2075/// InternPool key `variable` is considered a runtime value.
2077/// Generic poison causes `error.GenericPoison` to be returned.2076/// Generic poison causes `error.GenericPoison` to be returned.
2078fn resolveMaybeUndefVal(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {2077fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
2079 const val = (try sema.resolveMaybeUndefValAllowVariables(inst)) orelse return null;2078 const val = (try sema.resolveValueAllowVariables(inst)) orelse return null;
2080 if (val.isGenericPoison()) return error.GenericPoison;2079 if (val.isGenericPoison()) return error.GenericPoison;
2081 if (sema.mod.intern_pool.isVariable(val.toIntern())) return null;2080 if (sema.mod.intern_pool.isVariable(val.toIntern())) return null;
2082 return val;2081 return val;
2083}2082}
20842083
2085/// Like `resolveMaybeUndefVal`, but emits an error if the value is not comptime-known.2084/// Like `resolveValue`, but emits an error if the value is not comptime-known.
2086fn resolveConstMaybeUndefVal(2085fn resolveConstValue(
2087 sema: *Sema,2086 sema: *Sema,
2088 block: *Block,2087 block: *Block,
2089 src: LazySrcLoc,2088 src: LazySrcLoc,
2090 inst: Air.Inst.Ref,2089 inst: Air.Inst.Ref,
2091 reason: NeededComptimeReason,2090 reason: NeededComptimeReason,
2092) CompileError!Value {2091) CompileError!Value {
2093 return try sema.resolveMaybeUndefVal(inst) orelse {2092 return try sema.resolveValue(inst) orelse {
2094 return sema.failWithNeededComptime(block, src, reason);2093 return sema.failWithNeededComptime(block, src, reason);
2095 };2094 };
2096}2095}
20972096
2098/// Like `resolveMaybeUndefVal`, but emits an error if the value is not comptime-known or is undefined.2097/// Like `resolveValue`, but emits an error if the value is comptime-known to be undefined.
2099fn resolveConstValue(
2100 sema: *Sema,
2101 block: *Block,
2102 src: LazySrcLoc,
2103 air_ref: Air.Inst.Ref,
2104 reason: NeededComptimeReason,
2105) CompileError!Value {
2106 const val = try sema.resolveConstMaybeUndefVal(block, src, air_ref, reason);
2107 if (val.isUndef(sema.mod)) return sema.failWithUseOfUndef(block, src);
2108 return val;
2109}
2110
2111/// Like `resolveMaybeUndefVal`, but emits an error if the value is comptime-known to be undefined.
2112fn resolveDefinedValue(2098fn resolveDefinedValue(
2113 sema: *Sema,2099 sema: *Sema,
2114 block: *Block,2100 block: *Block,
...@@ -2116,7 +2102,7 @@ fn resolveDefinedValue(...@@ -2116,7 +2102,7 @@ fn resolveDefinedValue(
2116 air_ref: Air.Inst.Ref,2102 air_ref: Air.Inst.Ref,
2117) CompileError!?Value {2103) CompileError!?Value {
2118 const mod = sema.mod;2104 const mod = sema.mod;
2119 const val = try sema.resolveMaybeUndefVal(air_ref) orelse return null;2105 const val = try sema.resolveValue(air_ref) orelse return null;
2120 if (val.isUndef(mod)) {2106 if (val.isUndef(mod)) {
2121 if (block.is_typeof) return null;2107 if (block.is_typeof) return null;
2122 return sema.failWithUseOfUndef(block, src);2108 return sema.failWithUseOfUndef(block, src);
...@@ -2124,16 +2110,29 @@ fn resolveDefinedValue(...@@ -2124,16 +2110,29 @@ fn resolveDefinedValue(
2124 return val;2110 return val;
2125}2111}
21262112
2127/// Like `resolveMaybeUndefVal`, but recursively resolves lazy values.2113/// Like `resolveValue`, but emits an error if the value is not comptime-known or is undefined.
2128fn resolveMaybeUndefLazyVal(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {2114fn resolveConstDefinedValue(
2129 return try sema.resolveLazyValue((try sema.resolveMaybeUndefVal(inst)) orelse return null);2115 sema: *Sema,
2116 block: *Block,
2117 src: LazySrcLoc,
2118 air_ref: Air.Inst.Ref,
2119 reason: NeededComptimeReason,
2120) CompileError!Value {
2121 const val = try sema.resolveConstValue(block, src, air_ref, reason);
2122 if (val.isUndef(sema.mod)) return sema.failWithUseOfUndef(block, src);
2123 return val;
2130}2124}
21312125
2132/// Like `resolveMaybeUndefVal`, but any pointer value which does not correspond2126/// Like `resolveValue`, but recursively resolves lazy values before returning.
2127fn resolveValueResolveLazy(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
2128 return try sema.resolveLazyValue((try sema.resolveValue(inst)) orelse return null);
2129}
2130
2131/// Like `resolveValue`, but any pointer value which does not correspond
2133/// to a comptime-known integer (e.g. a decl pointer) returns `null`.2132/// to a comptime-known integer (e.g. a decl pointer) returns `null`.
2134/// Lazy values are recursively resolved.2133/// Lazy values are recursively resolved.
2135fn resolveMaybeUndefValIntable(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {2134fn resolveValueIntable(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
2136 const val = (try sema.resolveMaybeUndefVal(inst)) orelse return null;2135 const val = (try sema.resolveValue(inst)) orelse return null;
2137 if (sema.mod.intern_pool.getBackingAddrTag(val.toIntern())) |addr| switch (addr) {2136 if (sema.mod.intern_pool.getBackingAddrTag(val.toIntern())) |addr| switch (addr) {
2138 .decl, .anon_decl, .mut_decl, .comptime_field => return null,2137 .decl, .anon_decl, .mut_decl, .comptime_field => return null,
2139 .int => {},2138 .int => {},
...@@ -2143,7 +2142,7 @@ fn resolveMaybeUndefValIntable(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Va...@@ -2143,7 +2142,7 @@ fn resolveMaybeUndefValIntable(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Va
2143}2142}
21442143
2145/// Returns all InternPool keys representing values, including `variable`, `undef`, and `generic_poison`.2144/// Returns all InternPool keys representing values, including `variable`, `undef`, and `generic_poison`.
2146fn resolveMaybeUndefValAllowVariables(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {2145fn resolveValueAllowVariables(sema: *Sema, inst: Air.Inst.Ref) CompileError!?Value {
2147 assert(inst != .none);2146 assert(inst != .none);
2148 // First section of indexes correspond to a set number of constant values.2147 // First section of indexes correspond to a set number of constant values.
2149 if (@intFromEnum(inst) < InternPool.static_len) {2148 if (@intFromEnum(inst) < InternPool.static_len) {
...@@ -2180,7 +2179,7 @@ pub fn resolveInstConst(...@@ -2180,7 +2179,7 @@ pub fn resolveInstConst(
2180 reason: NeededComptimeReason,2179 reason: NeededComptimeReason,
2181) CompileError!TypedValue {2180) CompileError!TypedValue {
2182 const air_ref = try sema.resolveInst(zir_ref);2181 const air_ref = try sema.resolveInst(zir_ref);
2183 const val = try sema.resolveConstValue(block, src, air_ref, reason);2182 const val = try sema.resolveConstDefinedValue(block, src, air_ref, reason);
2184 return .{2183 return .{
2185 .ty = sema.typeOf(air_ref),2184 .ty = sema.typeOf(air_ref),
2186 .val = val,2185 .val = val,
...@@ -2197,7 +2196,7 @@ pub fn resolveInstValueAllowVariables(...@@ -2197,7 +2196,7 @@ pub fn resolveInstValueAllowVariables(
2197 reason: NeededComptimeReason,2196 reason: NeededComptimeReason,
2198) CompileError!TypedValue {2197) CompileError!TypedValue {
2199 const air_ref = try sema.resolveInst(zir_ref);2198 const air_ref = try sema.resolveInst(zir_ref);
2200 const val = try sema.resolveMaybeUndefValAllowVariables(air_ref) orelse {2199 const val = try sema.resolveValueAllowVariables(air_ref) orelse {
2201 return sema.failWithNeededComptime(block, src, reason);2200 return sema.failWithNeededComptime(block, src, reason);
2202 };2201 };
2203 if (val.isGenericPoison()) return error.GenericPoison;2202 if (val.isGenericPoison()) return error.GenericPoison;
...@@ -2640,7 +2639,7 @@ fn analyzeAsInt(...@@ -2640,7 +2639,7 @@ fn analyzeAsInt(
2640) !u64 {2639) !u64 {
2641 const mod = sema.mod;2640 const mod = sema.mod;
2642 const coerced = try sema.coerce(block, dest_ty, air_ref, src);2641 const coerced = try sema.coerce(block, dest_ty, air_ref, src);
2643 const val = try sema.resolveConstValue(block, src, coerced, reason);2642 const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
2644 return (try val.getUnsignedIntAdvanced(mod, sema)).?;2643 return (try val.getUnsignedIntAdvanced(mod, sema)).?;
2645}2644}
26462645
...@@ -2811,7 +2810,7 @@ fn createAnonymousDeclTypeNamed(...@@ -2811,7 +2810,7 @@ fn createAnonymousDeclTypeNamed(
2811 // If not then this is a struct type being returned from a non-generic2810 // If not then this is a struct type being returned from a non-generic
2812 // function and the name doesn't matter since it will later2811 // function and the name doesn't matter since it will later
2813 // result in a compile error.2812 // result in a compile error.
2814 const arg_val = sema.resolveConstMaybeUndefVal(block, .unneeded, arg, undefined) catch2813 const arg_val = sema.resolveConstValue(block, .unneeded, arg, undefined) catch
2815 return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);2814 return sema.createAnonymousDeclTypeNamed(block, src, typed_value, .anon, anon_prefix, null);
28162815
2817 if (arg_i != 0) try writer.writeByte(',');2816 if (arg_i != 0) try writer.writeByte(',');
...@@ -3055,13 +3054,13 @@ fn zirEnumDecl(...@@ -3055,13 +3054,13 @@ fn zirEnumDecl(
3055 const tag_val_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);3054 const tag_val_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
3056 extra_index += 1;3055 extra_index += 1;
3057 const tag_inst = try sema.resolveInst(tag_val_ref);3056 const tag_inst = try sema.resolveInst(tag_val_ref);
3058 last_tag_val = sema.resolveConstValue(block, .unneeded, tag_inst, undefined) catch |err| switch (err) {3057 last_tag_val = sema.resolveConstDefinedValue(block, .unneeded, tag_inst, undefined) catch |err| switch (err) {
3059 error.NeededSourceLocation => {3058 error.NeededSourceLocation => {
3060 const value_src = mod.fieldSrcLoc(new_decl_index, .{3059 const value_src = mod.fieldSrcLoc(new_decl_index, .{
3061 .index = field_i,3060 .index = field_i,
3062 .range = .value,3061 .range = .value,
3063 }).lazy;3062 }).lazy;
3064 _ = try sema.resolveConstValue(block, value_src, tag_inst, .{3063 _ = try sema.resolveConstDefinedValue(block, value_src, tag_inst, .{
3065 .needed_comptime_reason = "enum tag value must be comptime-known",3064 .needed_comptime_reason = "enum tag value must be comptime-known",
3066 });3065 });
3067 unreachable;3066 unreachable;
...@@ -3608,7 +3607,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro...@@ -3608,7 +3607,7 @@ fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
3608 // If this is already a comptime-known allocation, we don't want to emit an error - the stores3607 // If this is already a comptime-known allocation, we don't want to emit an error - the stores
3609 // were already performed at comptime! Just make the pointer constant as normal.3608 // were already performed at comptime! Just make the pointer constant as normal.
3610 implicit_ct: {3609 implicit_ct: {
3611 const ptr_val = try sema.resolveMaybeUndefVal(alloc) orelse break :implicit_ct;3610 const ptr_val = try sema.resolveValue(alloc) orelse break :implicit_ct;
3612 if (!ptr_val.isComptimeMutablePtr(mod)) {3611 if (!ptr_val.isComptimeMutablePtr(mod)) {
3613 // It could still be a constant pointer to a decl.3612 // It could still be a constant pointer to a decl.
3614 switch (mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) {3613 switch (mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr) {
...@@ -3750,7 +3749,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re...@@ -3750,7 +3749,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
3750 Air.Bin,3749 Air.Bin,
3751 tmp_air.instructions.items(.data)[air_ptr].ty_pl.payload,3750 tmp_air.instructions.items(.data)[air_ptr].ty_pl.payload,
3752 ).data;3751 ).data;
3753 const idx_val = (try sema.resolveMaybeUndefVal(data.rhs)).?;3752 const idx_val = (try sema.resolveValue(data.rhs)).?;
3754 break :blk .{3753 break :blk .{
3755 data.lhs,3754 data.lhs,
3756 .{ .elem = idx_val.toUnsignedInt(mod) },3755 .{ .elem = idx_val.toUnsignedInt(mod) },
...@@ -3809,7 +3808,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re...@@ -3809,7 +3808,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
3809 // store instruction, so we must set the union payload now.3808 // store instruction, so we must set the union payload now.
3810 const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;3809 const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
3811 const air_ptr_inst = Air.refToIndex(bin_op.lhs).?;3810 const air_ptr_inst = Air.refToIndex(bin_op.lhs).?;
3812 const tag_val = (try sema.resolveMaybeUndefVal(bin_op.rhs)).?;3811 const tag_val = (try sema.resolveValue(bin_op.rhs)).?;
3813 const union_ty = sema.typeOf(bin_op.lhs).childType(mod);3812 const union_ty = sema.typeOf(bin_op.lhs).childType(mod);
3814 const payload_ty = union_ty.unionFieldType(tag_val, mod).?;3813 const payload_ty = union_ty.unionFieldType(tag_val, mod).?;
3815 if (try sema.typeHasOnePossibleValue(payload_ty)) |payload_val| {3814 if (try sema.typeHasOnePossibleValue(payload_ty)) |payload_val| {
...@@ -3821,7 +3820,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re...@@ -3821,7 +3820,7 @@ fn resolveComptimeKnownAllocValue(sema: *Sema, block: *Block, alloc: Air.Inst.Re
3821 .store, .store_safe => {3820 .store, .store_safe => {
3822 const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;3821 const bin_op = sema.air_instructions.items(.data)[store_inst].bin_op;
3823 const air_ptr_inst = Air.refToIndex(bin_op.lhs).?;3822 const air_ptr_inst = Air.refToIndex(bin_op.lhs).?;
3824 const store_val = (try sema.resolveMaybeUndefVal(bin_op.rhs)).?;3823 const store_val = (try sema.resolveValue(bin_op.rhs)).?;
3825 const new_ptr = ptr_mapping.get(air_ptr_inst).?;3824 const new_ptr = ptr_mapping.get(air_ptr_inst).?;
3826 try sema.storePtrVal(block, .unneeded, new_ptr.toValue(), store_val, mod.intern_pool.typeOf(store_val.toIntern()).toType());3825 try sema.storePtrVal(block, .unneeded, new_ptr.toValue(), store_val, mod.intern_pool.typeOf(store_val.toIntern()).toType());
3827 },3826 },
...@@ -3872,7 +3871,7 @@ fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Ai...@@ -3872,7 +3871,7 @@ fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Ai
3872 const const_ptr_ty = try sema.makePtrTyConst(alloc_ty);3871 const const_ptr_ty = try sema.makePtrTyConst(alloc_ty);
38733872
3874 // Detect if a comptime value simply needs to have its type changed.3873 // Detect if a comptime value simply needs to have its type changed.
3875 if (try sema.resolveMaybeUndefVal(alloc)) |val| {3874 if (try sema.resolveValue(alloc)) |val| {
3876 return Air.internedToRef((try sema.mod.getCoerced(val, const_ptr_ty)).toIntern());3875 return Air.internedToRef((try sema.mod.getCoerced(val, const_ptr_ty)).toIntern());
3877 }3876 }
38783877
...@@ -4596,7 +4595,7 @@ fn validateUnionInit(...@@ -4596,7 +4595,7 @@ fn validateUnionInit(
4596 ).?4595 ).?
4597 else4596 else
4598 block_index, first_block_index);4597 block_index, first_block_index);
4599 init_val = try sema.resolveMaybeUndefVal(bin_op.rhs);4598 init_val = try sema.resolveValue(bin_op.rhs);
4600 break;4599 break;
4601 }4600 }
46024601
...@@ -4830,7 +4829,7 @@ fn validateStructInit(...@@ -4830,7 +4829,7 @@ fn validateStructInit(
4830 ).?4829 ).?
4831 else4830 else
4832 block_index, first_block_index);4831 block_index, first_block_index);
4833 if (try sema.resolveMaybeUndefVal(bin_op.rhs)) |val| {4832 if (try sema.resolveValue(bin_op.rhs)) |val| {
4834 field_values[i] = val.toIntern();4833 field_values[i] = val.toIntern();
4835 } else if (require_comptime) {4834 } else if (require_comptime) {
4836 const field_ptr_data = sema.code.instructions.items(.data)[field_ptr].pl_node;4835 const field_ptr_data = sema.code.instructions.items(.data)[field_ptr].pl_node;
...@@ -5086,7 +5085,7 @@ fn zirValidatePtrArrayInit(...@@ -5086,7 +5085,7 @@ fn zirValidatePtrArrayInit(
5086 ).?5085 ).?
5087 else5086 else
5088 block_index, first_block_index);5087 block_index, first_block_index);
5089 if (try sema.resolveMaybeUndefVal(bin_op.rhs)) |val| {5088 if (try sema.resolveValue(bin_op.rhs)) |val| {
5090 element_vals[i] = val.toIntern();5089 element_vals[i] = val.toIntern();
5091 } else {5090 } else {
5092 array_is_comptime = false;5091 array_is_comptime = false;
...@@ -5168,7 +5167,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr...@@ -5168,7 +5167,7 @@ fn zirValidateDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
5168 }5167 }
51695168
5170 const elem_ty = operand_ty.elemType2(mod);5169 const elem_ty = operand_ty.elemType2(mod);
5171 if (try sema.resolveMaybeUndefVal(operand)) |val| {5170 if (try sema.resolveValue(operand)) |val| {
5172 if (val.isUndef(mod)) {5171 if (val.isUndef(mod)) {
5173 return sema.fail(block, src, "cannot dereference undefined value", .{});5172 return sema.fail(block, src, "cannot dereference undefined value", .{});
5174 }5173 }
...@@ -5375,7 +5374,7 @@ fn storeToInferredAllocComptime(...@@ -5375,7 +5374,7 @@ fn storeToInferredAllocComptime(
5375 const operand_ty = sema.typeOf(operand);5374 const operand_ty = sema.typeOf(operand);
5376 // There will be only one store_to_inferred_ptr because we are running at comptime.5375 // There will be only one store_to_inferred_ptr because we are running at comptime.
5377 // The alloc will turn into a Decl.5376 // The alloc will turn into a Decl.
5378 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {5377 if (try sema.resolveValue(operand)) |operand_val| {
5379 var anon_decl = try block.startAnonDecl(); // TODO: comptime value mutation without Decl5378 var anon_decl = try block.startAnonDecl(); // TODO: comptime value mutation without Decl
5380 defer anon_decl.deinit();5379 defer anon_decl.deinit();
5381 iac.decl_index = try anon_decl.finish(operand_ty, operand_val, iac.alignment);5380 iac.decl_index = try anon_decl.finish(operand_ty, operand_val, iac.alignment);
...@@ -5565,7 +5564,7 @@ fn zirCompileLog(...@@ -5565,7 +5564,7 @@ fn zirCompileLog(
55655564
5566 const arg = try sema.resolveInst(arg_ref);5565 const arg = try sema.resolveInst(arg_ref);
5567 const arg_ty = sema.typeOf(arg);5566 const arg_ty = sema.typeOf(arg);
5568 if (try sema.resolveMaybeUndefLazyVal(arg)) |val| {5567 if (try sema.resolveValueResolveLazy(arg)) |val| {
5569 try writer.print("@as({}, {})", .{5568 try writer.print("@as({}, {})", .{
5570 arg_ty.fmt(mod), val.fmtValue(arg_ty, mod),5569 arg_ty.fmt(mod), val.fmtValue(arg_ty, mod),
5571 });5570 });
...@@ -6479,7 +6478,7 @@ fn lookupInNamespace(...@@ -6479,7 +6478,7 @@ fn lookupInNamespace(
64796478
6480fn funcDeclSrc(sema: *Sema, func_inst: Air.Inst.Ref) !?*Decl {6479fn funcDeclSrc(sema: *Sema, func_inst: Air.Inst.Ref) !?*Decl {
6481 const mod = sema.mod;6480 const mod = sema.mod;
6482 const func_val = (try sema.resolveMaybeUndefVal(func_inst)) orelse return null;6481 const func_val = (try sema.resolveValue(func_inst)) orelse return null;
6483 if (func_val.isUndef(mod)) return null;6482 if (func_val.isUndef(mod)) return null;
6484 const owner_decl_index = switch (mod.intern_pool.indexToKey(func_val.toIntern())) {6483 const owner_decl_index = switch (mod.intern_pool.indexToKey(func_val.toIntern())) {
6485 .extern_func => |extern_func| extern_func.decl,6484 .extern_func => |extern_func| extern_func.decl,
...@@ -7225,7 +7224,7 @@ fn analyzeCall(...@@ -7225,7 +7224,7 @@ fn analyzeCall(
7225 }7224 }
72267225
7227 const result: Air.Inst.Ref = if (is_inline_call) res: {7226 const result: Air.Inst.Ref = if (is_inline_call) res: {
7228 const func_val = try sema.resolveConstValue(block, func_src, func, .{7227 const func_val = try sema.resolveConstDefinedValue(block, func_src, func, .{
7229 .needed_comptime_reason = "function being called at comptime must be comptime-known",7228 .needed_comptime_reason = "function being called at comptime must be comptime-known",
7230 .block_comptime_reason = comptime_reason,7229 .block_comptime_reason = comptime_reason,
7231 });7230 });
...@@ -7475,7 +7474,7 @@ fn analyzeCall(...@@ -7475,7 +7474,7 @@ fn analyzeCall(
7475 }7474 }
74767475
7477 if (should_memoize and is_comptime_call) {7476 if (should_memoize and is_comptime_call) {
7478 const result_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, result, undefined);7477 const result_val = try sema.resolveConstValue(block, .unneeded, result, undefined);
7479 const result_interned = try result_val.intern2(sema.fn_ret_ty, mod);7478 const result_interned = try result_val.intern2(sema.fn_ret_ty, mod);
74807479
7481 // Transform ad-hoc inferred error set types into concrete error sets.7480 // Transform ad-hoc inferred error set types into concrete error sets.
...@@ -7492,7 +7491,7 @@ fn analyzeCall(...@@ -7492,7 +7491,7 @@ fn analyzeCall(
7492 break :res2 Air.internedToRef(result_transformed);7491 break :res2 Air.internedToRef(result_transformed);
7493 }7492 }
74947493
7495 if (try sema.resolveMaybeUndefVal(result)) |result_val| {7494 if (try sema.resolveValue(result)) |result_val| {
7496 const result_interned = try result_val.intern2(sema.fn_ret_ty, mod);7495 const result_interned = try result_val.intern2(sema.fn_ret_ty, mod);
7497 const result_transformed = try sema.resolveAdHocInferredErrorSet(block, call_src, result_interned);7496 const result_transformed = try sema.resolveAdHocInferredErrorSet(block, call_src, result_interned);
7498 break :res2 Air.internedToRef(result_transformed);7497 break :res2 Air.internedToRef(result_transformed);
...@@ -7532,7 +7531,7 @@ fn analyzeCall(...@@ -7532,7 +7531,7 @@ fn analyzeCall(
7532 ip.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn = true;7531 ip.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn = true;
7533 }7532 }
75347533
7535 if (try sema.resolveMaybeUndefVal(func)) |func_val| {7534 if (try sema.resolveValue(func)) |func_val| {
7536 if (mod.intern_pool.isFuncBody(func_val.toIntern())) {7535 if (mod.intern_pool.isFuncBody(func_val.toIntern())) {
7537 try mod.ensureFuncBodyAnalysisQueued(func_val.toIntern());7536 try mod.ensureFuncBodyAnalysisQueued(func_val.toIntern());
7538 }7537 }
...@@ -7560,7 +7559,7 @@ fn analyzeCall(...@@ -7560,7 +7559,7 @@ fn analyzeCall(
7560 if (block.wantSafety() and func_ty_info.return_type == .noreturn_type) skip_safety: {7559 if (block.wantSafety() and func_ty_info.return_type == .noreturn_type) skip_safety: {
7561 // Function pointers and extern functions aren't guaranteed to7560 // Function pointers and extern functions aren't guaranteed to
7562 // actually be noreturn so we add a safety check for them.7561 // actually be noreturn so we add a safety check for them.
7563 if (try sema.resolveMaybeUndefVal(func)) |func_val| {7562 if (try sema.resolveValue(func)) |func_val| {
7564 switch (mod.intern_pool.indexToKey(func_val.toIntern())) {7563 switch (mod.intern_pool.indexToKey(func_val.toIntern())) {
7565 .func => break :skip_safety,7564 .func => break :skip_safety,
7566 .ptr => |ptr| switch (ptr.addr) {7565 .ptr => |ptr| switch (ptr.addr) {
...@@ -7649,19 +7648,19 @@ fn analyzeInlineCallArg(...@@ -7649,19 +7648,19 @@ fn analyzeInlineCallArg(
7649 }7648 }
7650 const arg_src = args_info.argSrc(arg_block, arg_i.*);7649 const arg_src = args_info.argSrc(arg_block, arg_i.*);
7651 if (try ics.callee().typeRequiresComptime(param_ty.toType())) {7650 if (try ics.callee().typeRequiresComptime(param_ty.toType())) {
7652 _ = try ics.caller().resolveConstMaybeUndefVal(arg_block, arg_src, casted_arg, .{7651 _ = try ics.caller().resolveConstValue(arg_block, arg_src, casted_arg, .{
7653 .needed_comptime_reason = "argument to parameter with comptime-only type must be comptime-known",7652 .needed_comptime_reason = "argument to parameter with comptime-only type must be comptime-known",
7654 .block_comptime_reason = param_block.comptime_reason,7653 .block_comptime_reason = param_block.comptime_reason,
7655 });7654 });
7656 } else if (!is_comptime_call and zir_tags[inst] == .param_comptime) {7655 } else if (!is_comptime_call and zir_tags[inst] == .param_comptime) {
7657 _ = try ics.caller().resolveConstMaybeUndefVal(arg_block, arg_src, casted_arg, .{7656 _ = try ics.caller().resolveConstValue(arg_block, arg_src, casted_arg, .{
7658 .needed_comptime_reason = "parameter is comptime",7657 .needed_comptime_reason = "parameter is comptime",
7659 });7658 });
7660 }7659 }
76617660
7662 if (is_comptime_call) {7661 if (is_comptime_call) {
7663 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, casted_arg);7662 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, casted_arg);
7664 const arg_val = try ics.caller().resolveConstMaybeUndefVal(arg_block, arg_src, casted_arg, .{7663 const arg_val = try ics.caller().resolveConstValue(arg_block, arg_src, casted_arg, .{
7665 .needed_comptime_reason = "argument to function being called at comptime must be comptime-known",7664 .needed_comptime_reason = "argument to function being called at comptime must be comptime-known",
7666 .block_comptime_reason = param_block.comptime_reason,7665 .block_comptime_reason = param_block.comptime_reason,
7667 });7666 });
...@@ -7683,7 +7682,7 @@ fn analyzeInlineCallArg(...@@ -7683,7 +7682,7 @@ fn analyzeInlineCallArg(
7683 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, casted_arg);7682 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, casted_arg);
7684 }7683 }
76857684
7686 if (try ics.caller().resolveMaybeUndefVal(casted_arg)) |_| {7685 if (try ics.caller().resolveValue(casted_arg)) |_| {
7687 param_block.inlining.?.has_comptime_args = true;7686 param_block.inlining.?.has_comptime_args = true;
7688 }7687 }
76897688
...@@ -7700,7 +7699,7 @@ fn analyzeInlineCallArg(...@@ -7700,7 +7699,7 @@ fn analyzeInlineCallArg(
77007699
7701 if (is_comptime_call) {7700 if (is_comptime_call) {
7702 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, uncasted_arg);7701 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, uncasted_arg);
7703 const arg_val = try ics.caller().resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, .{7702 const arg_val = try ics.caller().resolveConstValue(arg_block, arg_src, uncasted_arg, .{
7704 .needed_comptime_reason = "argument to function being called at comptime must be comptime-known",7703 .needed_comptime_reason = "argument to function being called at comptime must be comptime-known",
7705 .block_comptime_reason = param_block.comptime_reason,7704 .block_comptime_reason = param_block.comptime_reason,
7706 });7705 });
...@@ -7720,14 +7719,14 @@ fn analyzeInlineCallArg(...@@ -7720,14 +7719,14 @@ fn analyzeInlineCallArg(
7720 memoized_arg_values[arg_i.*] = try resolved_arg_val.intern(ics.caller().typeOf(uncasted_arg), mod);7719 memoized_arg_values[arg_i.*] = try resolved_arg_val.intern(ics.caller().typeOf(uncasted_arg), mod);
7721 } else {7720 } else {
7722 if (zir_tags[inst] == .param_anytype_comptime) {7721 if (zir_tags[inst] == .param_anytype_comptime) {
7723 _ = try ics.caller().resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, .{7722 _ = try ics.caller().resolveConstValue(arg_block, arg_src, uncasted_arg, .{
7724 .needed_comptime_reason = "parameter is comptime",7723 .needed_comptime_reason = "parameter is comptime",
7725 });7724 });
7726 }7725 }
7727 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, uncasted_arg);7726 ics.callee().inst_map.putAssumeCapacityNoClobber(inst, uncasted_arg);
7728 }7727 }
77297728
7730 if (try ics.caller().resolveMaybeUndefVal(uncasted_arg)) |_| {7729 if (try ics.caller().resolveValue(uncasted_arg)) |_| {
7731 param_block.inlining.?.has_comptime_args = true;7730 param_block.inlining.?.has_comptime_args = true;
7732 }7731 }
77337732
...@@ -7769,7 +7768,7 @@ fn instantiateGenericCall(...@@ -7769,7 +7768,7 @@ fn instantiateGenericCall(
7769 const gpa = sema.gpa;7768 const gpa = sema.gpa;
7770 const ip = &mod.intern_pool;7769 const ip = &mod.intern_pool;
77717770
7772 const func_val = try sema.resolveConstValue(block, func_src, func, .{7771 const func_val = try sema.resolveConstDefinedValue(block, func_src, func, .{
7773 .needed_comptime_reason = "generic function being called must be comptime-known",7772 .needed_comptime_reason = "generic function being called must be comptime-known",
7774 });7773 });
7775 const generic_owner = switch (mod.intern_pool.indexToKey(func_val.toIntern())) {7774 const generic_owner = switch (mod.intern_pool.indexToKey(func_val.toIntern())) {
...@@ -7906,7 +7905,7 @@ fn instantiateGenericCall(...@@ -7906,7 +7905,7 @@ fn instantiateGenericCall(
7906 };7905 };
79077906
7908 if (arg_is_comptime) {7907 if (arg_is_comptime) {
7909 if (try sema.resolveMaybeUndefVal(arg_ref)) |arg_val| {7908 if (try sema.resolveValue(arg_ref)) |arg_val| {
7910 comptime_args[arg_index] = arg_val.toIntern();7909 comptime_args[arg_index] = arg_val.toIntern();
7911 child_sema.inst_map.putAssumeCapacityNoClobber(7910 child_sema.inst_map.putAssumeCapacityNoClobber(
7912 param_inst,7911 param_inst,
...@@ -7978,7 +7977,7 @@ fn instantiateGenericCall(...@@ -7978,7 +7977,7 @@ fn instantiateGenericCall(
7978 // We've already handled parameters, so don't resolve the whole body. Instead, just7977 // We've already handled parameters, so don't resolve the whole body. Instead, just
7979 // do the instructions after the params (i.e. the func itself).7978 // do the instructions after the params (i.e. the func itself).
7980 const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body[args_info.count()..], fn_info.param_body_inst);7979 const new_func_inst = try child_sema.resolveBody(&child_block, fn_info.param_body[args_info.count()..], fn_info.param_body_inst);
7981 const callee_index = (child_sema.resolveConstValue(&child_block, .unneeded, new_func_inst, undefined) catch unreachable).toIntern();7980 const callee_index = (child_sema.resolveConstDefinedValue(&child_block, .unneeded, new_func_inst, undefined) catch unreachable).toIntern();
79827981
7983 const callee = mod.funcInfo(callee_index);7982 const callee = mod.funcInfo(callee_index);
7984 callee.branchQuota(ip).* = @max(callee.branchQuota(ip).*, sema.branch_quota);7983 callee.branchQuota(ip).* = @max(callee.branchQuota(ip).*, sema.branch_quota);
...@@ -8229,7 +8228,7 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil...@@ -8229,7 +8228,7 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
8229 try sema.validateArrayElemType(block, elem_type, elem_src);8228 try sema.validateArrayElemType(block, elem_type, elem_src);
8230 const uncasted_sentinel = try sema.resolveInst(extra.sentinel);8229 const uncasted_sentinel = try sema.resolveInst(extra.sentinel);
8231 const sentinel = try sema.coerce(block, elem_type, uncasted_sentinel, sentinel_src);8230 const sentinel = try sema.coerce(block, elem_type, uncasted_sentinel, sentinel_src);
8232 const sentinel_val = try sema.resolveConstValue(block, sentinel_src, sentinel, .{8231 const sentinel_val = try sema.resolveConstDefinedValue(block, sentinel_src, sentinel, .{
8233 .needed_comptime_reason = "array sentinel value must be comptime-known",8232 .needed_comptime_reason = "array sentinel value must be comptime-known",
8234 });8233 });
8235 const array_ty = try sema.mod.arrayType(.{8234 const array_ty = try sema.mod.arrayType(.{
...@@ -8328,7 +8327,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD...@@ -8328,7 +8327,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
8328 const operand = try sema.coerce(block, Type.anyerror, uncasted_operand, operand_src);8327 const operand = try sema.coerce(block, Type.anyerror, uncasted_operand, operand_src);
8329 const err_int_ty = try mod.errorIntType();8328 const err_int_ty = try mod.errorIntType();
83308329
8331 if (try sema.resolveMaybeUndefVal(operand)) |val| {8330 if (try sema.resolveValue(operand)) |val| {
8332 if (val.isUndef(mod)) {8331 if (val.isUndef(mod)) {
8333 return mod.undefRef(err_int_ty);8332 return mod.undefRef(err_int_ty);
8334 }8333 }
...@@ -8501,7 +8500,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError...@@ -8501,7 +8500,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
8501 return Air.internedToRef((try mod.getCoerced(opv, int_tag_ty)).toIntern());8500 return Air.internedToRef((try mod.getCoerced(opv, int_tag_ty)).toIntern());
8502 }8501 }
85038502
8504 if (try sema.resolveMaybeUndefVal(enum_tag)) |enum_tag_val| {8503 if (try sema.resolveValue(enum_tag)) |enum_tag_val| {
8505 const val = try enum_tag_val.intFromEnum(enum_tag_ty, mod);8504 const val = try enum_tag_val.intFromEnum(enum_tag_ty, mod);
8506 return Air.internedToRef(val.toIntern());8505 return Air.internedToRef(val.toIntern());
8507 }8506 }
...@@ -8524,7 +8523,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError...@@ -8524,7 +8523,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
8524 }8523 }
8525 _ = try sema.checkIntType(block, operand_src, sema.typeOf(operand));8524 _ = try sema.checkIntType(block, operand_src, sema.typeOf(operand));
85268525
8527 if (try sema.resolveMaybeUndefVal(operand)) |int_val| {8526 if (try sema.resolveValue(operand)) |int_val| {
8528 if (dest_ty.isNonexhaustiveEnum(mod)) {8527 if (dest_ty.isNonexhaustiveEnum(mod)) {
8529 const int_tag_ty = dest_ty.intTagType(mod);8528 const int_tag_ty = dest_ty.intTagType(mod);
8530 if (try sema.intFitsInType(int_val, int_tag_ty, null)) {8529 if (try sema.intFitsInType(int_val, int_tag_ty, null)) {
...@@ -9032,7 +9031,7 @@ fn resolveGenericBody(...@@ -9032,7 +9031,7 @@ fn resolveGenericBody(
90329031
9033 const uncasted = sema.resolveBody(block, body, func_inst) catch |err| break :err err;9032 const uncasted = sema.resolveBody(block, body, func_inst) catch |err| break :err err;
9034 const result = sema.coerce(block, dest_ty, uncasted, src) catch |err| break :err err;9033 const result = sema.coerce(block, dest_ty, uncasted, src) catch |err| break :err err;
9035 const val = sema.resolveConstValue(block, src, result, reason) catch |err| break :err err;9034 const val = sema.resolveConstDefinedValue(block, src, result, reason) catch |err| break :err err;
9036 return val;9035 return val;
9037 };9036 };
9038 switch (err) {9037 switch (err) {
...@@ -9846,7 +9845,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!...@@ -9846,7 +9845,7 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
9846 };9845 };
9847 return sema.failWithOwnedErrorMsg(block, msg);9846 return sema.failWithOwnedErrorMsg(block, msg);
9848 }9847 }
9849 if (try sema.resolveMaybeUndefValIntable(operand)) |operand_val| ct: {9848 if (try sema.resolveValueIntable(operand)) |operand_val| ct: {
9850 if (!is_vector) {9849 if (!is_vector) {
9851 return Air.internedToRef((try mod.intValue(9850 return Air.internedToRef((try mod.intValue(
9852 Type.usize,9851 Type.usize,
...@@ -10312,7 +10311,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A...@@ -10312,7 +10311,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
10312 ),10311 ),
10313 }10312 }
1031410313
10315 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {10314 if (try sema.resolveValue(operand)) |operand_val| {
10316 if (!is_vector) {10315 if (!is_vector) {
10317 return Air.internedToRef((try operand_val.floatCast(dest_ty, mod)).toIntern());10316 return Air.internedToRef((try operand_val.floatCast(dest_ty, mod)).toIntern());
10318 }10317 }
...@@ -10710,7 +10709,7 @@ const SwitchProngAnalysis = struct {...@@ -10710,7 +10709,7 @@ const SwitchProngAnalysis = struct {
10710 const operand_src: LazySrcLoc = .{ .node_offset_switch_operand = switch_node_offset };10709 const operand_src: LazySrcLoc = .{ .node_offset_switch_operand = switch_node_offset };
1071110710
10712 if (inline_case_capture != .none) {10711 if (inline_case_capture != .none) {
10713 const item_val = sema.resolveConstValue(block, .unneeded, inline_case_capture, undefined) catch unreachable;10712 const item_val = sema.resolveConstDefinedValue(block, .unneeded, inline_case_capture, undefined) catch unreachable;
10714 if (operand_ty.zigTypeTag(mod) == .Union) {10713 if (operand_ty.zigTypeTag(mod) == .Union) {
10715 const field_index: u32 = @intCast(operand_ty.unionTagFieldIndex(item_val, mod).?);10714 const field_index: u32 = @intCast(operand_ty.unionTagFieldIndex(item_val, mod).?);
10716 const union_obj = mod.typeToUnion(operand_ty).?;10715 const union_obj = mod.typeToUnion(operand_ty).?;
...@@ -10767,14 +10766,14 @@ const SwitchProngAnalysis = struct {...@@ -10767,14 +10766,14 @@ const SwitchProngAnalysis = struct {
10767 switch (operand_ty.zigTypeTag(mod)) {10766 switch (operand_ty.zigTypeTag(mod)) {
10768 .Union => {10767 .Union => {
10769 const union_obj = mod.typeToUnion(operand_ty).?;10768 const union_obj = mod.typeToUnion(operand_ty).?;
10770 const first_item_val = sema.resolveConstValue(block, .unneeded, case_vals[0], undefined) catch unreachable;10769 const first_item_val = sema.resolveConstDefinedValue(block, .unneeded, case_vals[0], undefined) catch unreachable;
1077110770
10772 const first_field_index: u32 = mod.unionTagFieldIndex(union_obj, first_item_val).?;10771 const first_field_index: u32 = mod.unionTagFieldIndex(union_obj, first_item_val).?;
10773 const first_field_ty = union_obj.field_types.get(ip)[first_field_index].toType();10772 const first_field_ty = union_obj.field_types.get(ip)[first_field_index].toType();
1077410773
10775 const field_tys = try sema.arena.alloc(Type, case_vals.len);10774 const field_tys = try sema.arena.alloc(Type, case_vals.len);
10776 for (case_vals, field_tys) |item, *field_ty| {10775 for (case_vals, field_tys) |item, *field_ty| {
10777 const item_val = sema.resolveConstValue(block, .unneeded, item, undefined) catch unreachable;10776 const item_val = sema.resolveConstDefinedValue(block, .unneeded, item, undefined) catch unreachable;
10778 const field_idx = mod.unionTagFieldIndex(union_obj, item_val).?;10777 const field_idx = mod.unionTagFieldIndex(union_obj, item_val).?;
10779 field_ty.* = union_obj.field_types.get(ip)[field_idx].toType();10778 field_ty.* = union_obj.field_types.get(ip)[field_idx].toType();
10780 }10779 }
...@@ -11023,7 +11022,7 @@ const SwitchProngAnalysis = struct {...@@ -11023,7 +11022,7 @@ const SwitchProngAnalysis = struct {
11023 }11022 }
1102411023
11025 if (case_vals.len == 1) {11024 if (case_vals.len == 1) {
11026 const item_val = sema.resolveConstValue(block, .unneeded, case_vals[0], undefined) catch unreachable;11025 const item_val = sema.resolveConstDefinedValue(block, .unneeded, case_vals[0], undefined) catch unreachable;
11027 const item_ty = try mod.singleErrorSetType(item_val.getErrorName(mod).unwrap().?);11026 const item_ty = try mod.singleErrorSetType(item_val.getErrorName(mod).unwrap().?);
11028 return sema.bitCast(block, item_ty, spa.operand, operand_src, null);11027 return sema.bitCast(block, item_ty, spa.operand, operand_src, null);
11029 }11028 }
...@@ -11031,7 +11030,7 @@ const SwitchProngAnalysis = struct {...@@ -11031,7 +11030,7 @@ const SwitchProngAnalysis = struct {
11031 var names: InferredErrorSet.NameMap = .{};11030 var names: InferredErrorSet.NameMap = .{};
11032 try names.ensureUnusedCapacity(sema.arena, case_vals.len);11031 try names.ensureUnusedCapacity(sema.arena, case_vals.len);
11033 for (case_vals) |err| {11032 for (case_vals) |err| {
11034 const err_val = sema.resolveConstValue(block, .unneeded, err, undefined) catch unreachable;11033 const err_val = sema.resolveConstDefinedValue(block, .unneeded, err, undefined) catch unreachable;
11035 names.putAssumeCapacityNoClobber(err_val.getErrorName(mod).unwrap().?, {});11034 names.putAssumeCapacityNoClobber(err_val.getErrorName(mod).unwrap().?, {});
11036 }11035 }
11037 const error_ty = try mod.errorSetFromUnsortedNames(names.keys());11036 const error_ty = try mod.errorSetFromUnsortedNames(names.keys());
...@@ -11805,7 +11804,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -11805,7 +11804,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
11805 extra_index += info.body_len;11804 extra_index += info.body_len;
1180611805
11807 const item = case_vals.items[scalar_i];11806 const item = case_vals.items[scalar_i];
11808 const item_val = sema.resolveConstValue(&child_block, .unneeded, item, undefined) catch unreachable;11807 const item_val = sema.resolveConstDefinedValue(&child_block, .unneeded, item, undefined) catch unreachable;
11809 if (operand_val.eql(item_val, operand_ty, sema.mod)) {11808 if (operand_val.eql(item_val, operand_ty, sema.mod)) {
11810 if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);11809 if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);
11811 return spa.resolveProngComptime(11810 return spa.resolveProngComptime(
...@@ -11839,7 +11838,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -11839,7 +11838,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1183911838
11840 for (items) |item| {11839 for (items) |item| {
11841 // Validation above ensured these will succeed.11840 // Validation above ensured these will succeed.
11842 const item_val = sema.resolveConstValue(&child_block, .unneeded, item, undefined) catch unreachable;11841 const item_val = sema.resolveConstDefinedValue(&child_block, .unneeded, item, undefined) catch unreachable;
11843 if (operand_val.eql(item_val, operand_ty, sema.mod)) {11842 if (operand_val.eql(item_val, operand_ty, sema.mod)) {
11844 if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);11843 if (err_set) try sema.maybeErrorUnwrapComptime(&child_block, body, operand);
11845 return spa.resolveProngComptime(11844 return spa.resolveProngComptime(
...@@ -11863,8 +11862,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -11863,8 +11862,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
11863 case_val_idx += 2;11862 case_val_idx += 2;
1186411863
11865 // Validation above ensured these will succeed.11864 // Validation above ensured these will succeed.
11866 const first_val = sema.resolveConstValue(&child_block, .unneeded, range_items[0], undefined) catch unreachable;11865 const first_val = sema.resolveConstDefinedValue(&child_block, .unneeded, range_items[0], undefined) catch unreachable;
11867 const last_val = sema.resolveConstValue(&child_block, .unneeded, range_items[1], undefined) catch unreachable;11866 const last_val = sema.resolveConstDefinedValue(&child_block, .unneeded, range_items[1], undefined) catch unreachable;
11868 if ((try sema.compareAll(resolved_operand_val, .gte, first_val, operand_ty)) and11867 if ((try sema.compareAll(resolved_operand_val, .gte, first_val, operand_ty)) and
11869 (try sema.compareAll(resolved_operand_val, .lte, last_val, operand_ty)))11868 (try sema.compareAll(resolved_operand_val, .lte, last_val, operand_ty)))
11870 {11869 {
...@@ -11936,7 +11935,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -11936,7 +11935,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
11936 }11935 }
1193711936
11938 if (child_block.is_comptime) {11937 if (child_block.is_comptime) {
11939 _ = try sema.resolveConstValue(&child_block, operand_src, operand, .{11938 _ = try sema.resolveConstDefinedValue(&child_block, operand_src, operand, .{
11940 .needed_comptime_reason = "condition in comptime switch must be comptime-known",11939 .needed_comptime_reason = "condition in comptime switch must be comptime-known",
11941 .block_comptime_reason = child_block.comptime_reason,11940 .block_comptime_reason = child_block.comptime_reason,
11942 });11941 });
...@@ -11971,7 +11970,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -11971,7 +11970,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
11971 // `item` is already guaranteed to be constant known.11970 // `item` is already guaranteed to be constant known.
1197211971
11973 const analyze_body = if (union_originally) blk: {11972 const analyze_body = if (union_originally) blk: {
11974 const unresolved_item_val = sema.resolveConstValue(block, .unneeded, item, undefined) catch unreachable;11973 const unresolved_item_val = sema.resolveConstDefinedValue(block, .unneeded, item, undefined) catch unreachable;
11975 const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable;11974 const item_val = sema.resolveLazyValue(unresolved_item_val) catch unreachable;
11976 const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;11975 const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
11977 break :blk field_ty.zigTypeTag(mod) != .NoReturn;11976 break :blk field_ty.zigTypeTag(mod) != .NoReturn;
...@@ -12040,8 +12039,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -12040,8 +12039,8 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
12040 const item_first_ref = range_items[0];12039 const item_first_ref = range_items[0];
12041 const item_last_ref = range_items[1];12040 const item_last_ref = range_items[1];
1204212041
12043 var item = sema.resolveConstValue(block, .unneeded, item_first_ref, undefined) catch unreachable;12042 var item = sema.resolveConstDefinedValue(block, .unneeded, item_first_ref, undefined) catch unreachable;
12044 const item_last = sema.resolveConstValue(block, .unneeded, item_last_ref, undefined) catch unreachable;12043 const item_last = sema.resolveConstDefinedValue(block, .unneeded, item_last_ref, undefined) catch unreachable;
1204512044
12046 while (item.compareScalar(.lte, item_last, operand_ty, mod)) : ({12045 while (item.compareScalar(.lte, item_last, operand_ty, mod)) : ({
12047 // Previous validation has resolved any possible lazy values.12046 // Previous validation has resolved any possible lazy values.
...@@ -12098,7 +12097,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -12098,7 +12097,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
12098 case_block.wip_capture_scope = child_block.wip_capture_scope;12097 case_block.wip_capture_scope = child_block.wip_capture_scope;
1209912098
12100 const analyze_body = if (union_originally) blk: {12099 const analyze_body = if (union_originally) blk: {
12101 const item_val = sema.resolveConstValue(block, .unneeded, item, undefined) catch unreachable;12100 const item_val = sema.resolveConstDefinedValue(block, .unneeded, item, undefined) catch unreachable;
12102 const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;12101 const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
12103 break :blk field_ty.zigTypeTag(mod) != .NoReturn;12102 break :blk field_ty.zigTypeTag(mod) != .NoReturn;
12104 } else true;12103 } else true;
...@@ -12152,7 +12151,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r...@@ -12152,7 +12151,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1215212151
12153 const analyze_body = if (union_originally)12152 const analyze_body = if (union_originally)
12154 for (items) |item| {12153 for (items) |item| {
12155 const item_val = sema.resolveConstValue(block, .unneeded, item, undefined) catch unreachable;12154 const item_val = sema.resolveConstDefinedValue(block, .unneeded, item, undefined) catch unreachable;
12156 const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;12155 const field_ty = maybe_union_ty.unionFieldType(item_val, mod).?;
12157 if (field_ty.zigTypeTag(mod) != .NoReturn) break true;12156 if (field_ty.zigTypeTag(mod) != .NoReturn) break true;
12158 } else false12157 } else false
...@@ -12642,10 +12641,10 @@ fn resolveSwitchItemVal(...@@ -12642,10 +12641,10 @@ fn resolveSwitchItemVal(
12642 else => |e| return e,12641 else => |e| return e,
12643 };12642 };
1264412643
12645 const maybe_lazy = sema.resolveConstValue(block, .unneeded, item, undefined) catch |err| switch (err) {12644 const maybe_lazy = sema.resolveConstDefinedValue(block, .unneeded, item, undefined) catch |err| switch (err) {
12646 error.NeededSourceLocation => {12645 error.NeededSourceLocation => {
12647 const src = switch_prong_src.resolve(mod, mod.declPtr(block.src_decl), switch_node_offset, range_expand);12646 const src = switch_prong_src.resolve(mod, mod.declPtr(block.src_decl), switch_node_offset, range_expand);
12648 _ = try sema.resolveConstValue(block, src, item, .{12647 _ = try sema.resolveConstDefinedValue(block, src, item, .{
12649 .needed_comptime_reason = "switch prong values must be comptime-known",12648 .needed_comptime_reason = "switch prong values must be comptime-known",
12650 });12649 });
12651 unreachable;12650 unreachable;
...@@ -13133,8 +13132,8 @@ fn zirShl(...@@ -13133,8 +13132,8 @@ fn zirShl(
13133 // TODO coerce rhs if air_tag is not shl_sat13132 // TODO coerce rhs if air_tag is not shl_sat
13134 const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);13133 const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
1313513134
13136 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs);13135 const maybe_lhs_val = try sema.resolveValueIntable(lhs);
13137 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs);13136 const maybe_rhs_val = try sema.resolveValueIntable(rhs);
1313813137
13139 if (maybe_rhs_val) |rhs_val| {13138 if (maybe_rhs_val) |rhs_val| {
13140 if (rhs_val.isUndef(mod)) {13139 if (rhs_val.isUndef(mod)) {
...@@ -13311,8 +13310,8 @@ fn zirShr(...@@ -13311,8 +13310,8 @@ fn zirShr(
13311 try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);13310 try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
13312 const scalar_ty = lhs_ty.scalarType(mod);13311 const scalar_ty = lhs_ty.scalarType(mod);
1331313312
13314 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(lhs);13313 const maybe_lhs_val = try sema.resolveValueIntable(lhs);
13315 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(rhs);13314 const maybe_rhs_val = try sema.resolveValueIntable(rhs);
1331613315
13317 const runtime_src = if (maybe_rhs_val) |rhs_val| rs: {13316 const runtime_src = if (maybe_rhs_val) |rhs_val| rs: {
13318 if (rhs_val.isUndef(mod)) {13317 if (rhs_val.isUndef(mod)) {
...@@ -13463,8 +13462,8 @@ fn zirBitwise(...@@ -13463,8 +13462,8 @@ fn zirBitwise(
13463 const runtime_src = runtime: {13462 const runtime_src = runtime: {
13464 // TODO: ask the linker what kind of relocations are available, and13463 // TODO: ask the linker what kind of relocations are available, and
13465 // in some cases emit a Value that means "this decl's address AND'd with this operand".13464 // in some cases emit a Value that means "this decl's address AND'd with this operand".
13466 if (try sema.resolveMaybeUndefValIntable(casted_lhs)) |lhs_val| {13465 if (try sema.resolveValueIntable(casted_lhs)) |lhs_val| {
13467 if (try sema.resolveMaybeUndefValIntable(casted_rhs)) |rhs_val| {13466 if (try sema.resolveValueIntable(casted_rhs)) |rhs_val| {
13468 const result_val = switch (air_tag) {13467 const result_val = switch (air_tag) {
13469 .bit_and => try lhs_val.bitwiseAnd(rhs_val, resolved_type, sema.arena, mod),13468 .bit_and => try lhs_val.bitwiseAnd(rhs_val, resolved_type, sema.arena, mod),
13470 .bit_or => try lhs_val.bitwiseOr(rhs_val, resolved_type, sema.arena, mod),13469 .bit_or => try lhs_val.bitwiseOr(rhs_val, resolved_type, sema.arena, mod),
...@@ -13503,7 +13502,7 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air....@@ -13503,7 +13502,7 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
13503 });13502 });
13504 }13503 }
1350513504
13506 if (try sema.resolveMaybeUndefVal(operand)) |val| {13505 if (try sema.resolveValue(operand)) |val| {
13507 if (val.isUndef(mod)) {13506 if (val.isUndef(mod)) {
13508 return mod.undefRef(operand_type);13507 return mod.undefRef(operand_type);
13509 } else if (operand_type.zigTypeTag(mod) == .Vector) {13508 } else if (operand_type.zigTypeTag(mod) == .Vector) {
...@@ -13673,10 +13672,10 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13673,10 +13672,10 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13673 const rhs_sent = Air.internedToRef(rhs_sent_val.toIntern());13672 const rhs_sent = Air.internedToRef(rhs_sent_val.toIntern());
13674 const lhs_sent_casted = try sema.coerce(block, resolved_elem_ty, lhs_sent, lhs_src);13673 const lhs_sent_casted = try sema.coerce(block, resolved_elem_ty, lhs_sent, lhs_src);
13675 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);13674 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);
13676 const lhs_sent_casted_val = try sema.resolveConstValue(block, lhs_src, lhs_sent_casted, .{13675 const lhs_sent_casted_val = try sema.resolveConstDefinedValue(block, lhs_src, lhs_sent_casted, .{
13677 .needed_comptime_reason = "array sentinel value must be comptime-known",13676 .needed_comptime_reason = "array sentinel value must be comptime-known",
13678 });13677 });
13679 const rhs_sent_casted_val = try sema.resolveConstValue(block, rhs_src, rhs_sent_casted, .{13678 const rhs_sent_casted_val = try sema.resolveConstDefinedValue(block, rhs_src, rhs_sent_casted, .{
13680 .needed_comptime_reason = "array sentinel value must be comptime-known",13679 .needed_comptime_reason = "array sentinel value must be comptime-known",
13681 });13680 });
13682 if (try sema.valuesEqual(lhs_sent_casted_val, rhs_sent_casted_val, resolved_elem_ty)) {13681 if (try sema.valuesEqual(lhs_sent_casted_val, rhs_sent_casted_val, resolved_elem_ty)) {
...@@ -13686,7 +13685,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13686,7 +13685,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13686 }13685 }
13687 } else {13686 } else {
13688 const lhs_sent_casted = try sema.coerce(block, resolved_elem_ty, lhs_sent, lhs_src);13687 const lhs_sent_casted = try sema.coerce(block, resolved_elem_ty, lhs_sent, lhs_src);
13689 const lhs_sent_casted_val = try sema.resolveConstValue(block, lhs_src, lhs_sent_casted, .{13688 const lhs_sent_casted_val = try sema.resolveConstDefinedValue(block, lhs_src, lhs_sent_casted, .{
13690 .needed_comptime_reason = "array sentinel value must be comptime-known",13689 .needed_comptime_reason = "array sentinel value must be comptime-known",
13691 });13690 });
13692 break :s lhs_sent_casted_val;13691 break :s lhs_sent_casted_val;
...@@ -13695,7 +13694,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13695,7 +13694,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13695 if (rhs_info.sentinel) |rhs_sent_val| {13694 if (rhs_info.sentinel) |rhs_sent_val| {
13696 const rhs_sent = Air.internedToRef(rhs_sent_val.toIntern());13695 const rhs_sent = Air.internedToRef(rhs_sent_val.toIntern());
13697 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);13696 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);
13698 const rhs_sent_casted_val = try sema.resolveConstValue(block, rhs_src, rhs_sent_casted, .{13697 const rhs_sent_casted_val = try sema.resolveConstDefinedValue(block, rhs_src, rhs_sent_casted, .{
13699 .needed_comptime_reason = "array sentinel value must be comptime-known",13698 .needed_comptime_reason = "array sentinel value must be comptime-known",
13700 });13699 });
13701 break :s rhs_sent_casted_val;13700 break :s rhs_sent_casted_val;
...@@ -13728,12 +13727,12 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13728,12 +13727,12 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13728 };13727 };
1372913728
13730 const runtime_src = if (switch (lhs_ty.zigTypeTag(mod)) {13729 const runtime_src = if (switch (lhs_ty.zigTypeTag(mod)) {
13731 .Array, .Struct => try sema.resolveMaybeUndefVal(lhs),13730 .Array, .Struct => try sema.resolveValue(lhs),
13732 .Pointer => try sema.resolveDefinedValue(block, lhs_src, lhs),13731 .Pointer => try sema.resolveDefinedValue(block, lhs_src, lhs),
13733 else => unreachable,13732 else => unreachable,
13734 }) |lhs_val| rs: {13733 }) |lhs_val| rs: {
13735 if (switch (rhs_ty.zigTypeTag(mod)) {13734 if (switch (rhs_ty.zigTypeTag(mod)) {
13736 .Array, .Struct => try sema.resolveMaybeUndefVal(rhs),13735 .Array, .Struct => try sema.resolveValue(rhs),
13737 .Pointer => try sema.resolveDefinedValue(block, rhs_src, rhs),13736 .Pointer => try sema.resolveDefinedValue(block, rhs_src, rhs),
13738 else => unreachable,13737 else => unreachable,
13739 }) |rhs_val| {13738 }) |rhs_val| {
...@@ -13755,7 +13754,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13755,7 +13754,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13755 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try lhs_sub_val.elemValue(mod, lhs_elem_i) else elem_default_val;13754 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try lhs_sub_val.elemValue(mod, lhs_elem_i) else elem_default_val;
13756 const elem_val_inst = Air.internedToRef(elem_val.toIntern());13755 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
13757 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);13756 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
13758 const coerced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, undefined);13757 const coerced_elem_val = try sema.resolveConstValue(block, .unneeded, coerced_elem_val_inst, undefined);
13759 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);13758 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);
13760 }13759 }
13761 while (elem_i < result_len) : (elem_i += 1) {13760 while (elem_i < result_len) : (elem_i += 1) {
...@@ -13764,7 +13763,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -13764,7 +13763,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
13764 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try rhs_sub_val.elemValue(mod, rhs_elem_i) else elem_default_val;13763 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try rhs_sub_val.elemValue(mod, rhs_elem_i) else elem_default_val;
13765 const elem_val_inst = Air.internedToRef(elem_val.toIntern());13764 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
13766 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);13765 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
13767 const coerced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, undefined);13766 const coerced_elem_val = try sema.resolveConstValue(block, .unneeded, coerced_elem_val_inst, undefined);
13768 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);13767 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);
13769 }13768 }
13770 return sema.addConstantMaybeRef(block, result_ty, (try mod.intern(.{ .aggregate = .{13769 return sema.addConstantMaybeRef(block, result_ty, (try mod.intern(.{ .aggregate = .{
...@@ -13841,7 +13840,7 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins...@@ -13841,7 +13840,7 @@ fn getArrayCatInfo(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air.Ins
13841 // has a sentinel, and this code should compute the length based13840 // has a sentinel, and this code should compute the length based
13842 // on the sentinel value.13841 // on the sentinel value.
13843 .Slice, .Many => {13842 .Slice, .Many => {
13844 const val = try sema.resolveConstValue(block, src, operand, .{13843 const val = try sema.resolveConstDefinedValue(block, src, operand, .{
13845 .needed_comptime_reason = "slice value being concatenated must be comptime-known",13844 .needed_comptime_reason = "slice value being concatenated must be comptime-known",
13846 });13845 });
13847 return Type.ArrayInfo{13846 return Type.ArrayInfo{
...@@ -14109,7 +14108,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air....@@ -14109,7 +14108,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1410914108
14110 if (rhs_scalar_ty.isAnyFloat()) {14109 if (rhs_scalar_ty.isAnyFloat()) {
14111 // We handle float negation here to ensure negative zero is represented in the bits.14110 // We handle float negation here to ensure negative zero is represented in the bits.
14112 if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| {14111 if (try sema.resolveValue(rhs)) |rhs_val| {
14113 if (rhs_val.isUndef(mod)) return mod.undefRef(rhs_ty);14112 if (rhs_val.isUndef(mod)) return mod.undefRef(rhs_ty);
14114 return Air.internedToRef((try rhs_val.floatNeg(rhs_ty, sema.arena, mod)).toIntern());14113 return Air.internedToRef((try rhs_val.floatNeg(rhs_ty, sema.arena, mod)).toIntern());
14115 }14114 }
...@@ -14195,8 +14194,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins...@@ -14195,8 +14194,8 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1419514194
14196 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div);14195 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div);
1419714196
14198 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);14197 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
14199 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);14198 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1420014199
14201 if ((lhs_ty.zigTypeTag(mod) == .ComptimeFloat and rhs_ty.zigTypeTag(mod) == .ComptimeInt) or14200 if ((lhs_ty.zigTypeTag(mod) == .ComptimeFloat and rhs_ty.zigTypeTag(mod) == .ComptimeInt) or
14202 (lhs_ty.zigTypeTag(mod) == .ComptimeInt and rhs_ty.zigTypeTag(mod) == .ComptimeFloat))14201 (lhs_ty.zigTypeTag(mod) == .ComptimeInt and rhs_ty.zigTypeTag(mod) == .ComptimeFloat))
...@@ -14360,8 +14359,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -14360,8 +14359,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1436014359
14361 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_exact);14360 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_exact);
1436214361
14363 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);14362 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
14364 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);14363 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1436514364
14366 const runtime_src = rs: {14365 const runtime_src = rs: {
14367 // For integers:14366 // For integers:
...@@ -14527,8 +14526,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -14527,8 +14526,8 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1452714526
14528 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_floor);14527 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_floor);
1452914528
14530 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);14529 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
14531 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);14530 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1453214531
14533 const runtime_src = rs: {14532 const runtime_src = rs: {
14534 // For integers:14533 // For integers:
...@@ -14638,8 +14637,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -14638,8 +14637,8 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1463814637
14639 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_trunc);14638 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_trunc);
1464014639
14641 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);14640 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
14642 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);14641 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1464314642
14644 const runtime_src = rs: {14643 const runtime_src = rs: {
14645 // For integers:14644 // For integers:
...@@ -14882,8 +14881,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air....@@ -14882,8 +14881,8 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1488214881
14883 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod_rem);14882 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod_rem);
1488414883
14885 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);14884 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
14886 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);14885 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1488714886
14888 const runtime_src = rs: {14887 const runtime_src = rs: {
14889 // For integers:14888 // For integers:
...@@ -15063,8 +15062,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins...@@ -15063,8 +15062,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1506315062
15064 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod);15063 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod);
1506515064
15066 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);15065 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
15067 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);15066 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1506815067
15069 const runtime_src = rs: {15068 const runtime_src = rs: {
15070 // For integers:15069 // For integers:
...@@ -15159,8 +15158,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins...@@ -15159,8 +15158,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1515915158
15160 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .rem);15159 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .rem);
1516115160
15162 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);15161 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
15163 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);15162 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
1516415163
15165 const runtime_src = rs: {15164 const runtime_src = rs: {
15166 // For integers:15165 // For integers:
...@@ -15269,8 +15268,8 @@ fn zirOverflowArithmetic(...@@ -15269,8 +15268,8 @@ fn zirOverflowArithmetic(
15269 return sema.fail(block, src, "expected vector of integers or integer tag type, found '{}'", .{dest_ty.fmt(mod)});15268 return sema.fail(block, src, "expected vector of integers or integer tag type, found '{}'", .{dest_ty.fmt(mod)});
15270 }15269 }
1527115270
15272 const maybe_lhs_val = try sema.resolveMaybeUndefVal(lhs);15271 const maybe_lhs_val = try sema.resolveValue(lhs);
15273 const maybe_rhs_val = try sema.resolveMaybeUndefVal(rhs);15272 const maybe_rhs_val = try sema.resolveValue(rhs);
1527415273
15275 const tuple_ty = try sema.overflowArithmeticTupleType(dest_ty);15274 const tuple_ty = try sema.overflowArithmeticTupleType(dest_ty);
15276 const overflow_ty = ip.indexToKey(tuple_ty.toIntern()).anon_struct_type.types.get(ip)[1].toType();15275 const overflow_ty = ip.indexToKey(tuple_ty.toIntern()).anon_struct_type.types.get(ip)[1].toType();
...@@ -15413,7 +15412,7 @@ fn zirOverflowArithmetic(...@@ -15413,7 +15412,7 @@ fn zirOverflowArithmetic(
15413 };15412 };
1541415413
15415 if (result.inst != .none) {15414 if (result.inst != .none) {
15416 if (try sema.resolveMaybeUndefVal(result.inst)) |some| {15415 if (try sema.resolveValue(result.inst)) |some| {
15417 result.wrapped = some;15416 result.wrapped = some;
15418 result.inst = .none;15417 result.inst = .none;
15419 }15418 }
...@@ -15509,8 +15508,8 @@ fn analyzeArithmetic(...@@ -15509,8 +15508,8 @@ fn analyzeArithmetic(
1550915508
15510 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, zir_tag);15509 try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, zir_tag);
1551115510
15512 const maybe_lhs_val = try sema.resolveMaybeUndefValIntable(casted_lhs);15511 const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
15513 const maybe_rhs_val = try sema.resolveMaybeUndefValIntable(casted_rhs);15512 const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
15514 const runtime_src: LazySrcLoc, const air_tag: Air.Inst.Tag, const air_tag_safe: Air.Inst.Tag = rs: {15513 const runtime_src: LazySrcLoc, const air_tag: Air.Inst.Tag, const air_tag_safe: Air.Inst.Tag = rs: {
15515 switch (zir_tag) {15514 switch (zir_tag) {
15516 .add, .add_unsafe => {15515 .add, .add_unsafe => {
...@@ -15959,7 +15958,7 @@ fn analyzePtrArithmetic(...@@ -15959,7 +15958,7 @@ fn analyzePtrArithmetic(
15959 // coerce to isize instead of usize.15958 // coerce to isize instead of usize.
15960 const offset = try sema.coerce(block, Type.usize, uncasted_offset, offset_src);15959 const offset = try sema.coerce(block, Type.usize, uncasted_offset, offset_src);
15961 const mod = sema.mod;15960 const mod = sema.mod;
15962 const opt_ptr_val = try sema.resolveMaybeUndefVal(ptr);15961 const opt_ptr_val = try sema.resolveValue(ptr);
15963 const opt_off_val = try sema.resolveDefinedValue(block, offset_src, offset);15962 const opt_off_val = try sema.resolveDefinedValue(block, offset_src, offset);
15964 const ptr_ty = sema.typeOf(ptr);15963 const ptr_ty = sema.typeOf(ptr);
15965 const ptr_info = ptr_ty.ptrInfo(mod);15964 const ptr_info = ptr_ty.ptrInfo(mod);
...@@ -16265,8 +16264,8 @@ fn zirCmpEq(...@@ -16265,8 +16264,8 @@ fn zirCmpEq(
1626516264
16266 if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) {16265 if (lhs_ty_tag == .ErrorSet and rhs_ty_tag == .ErrorSet) {
16267 const runtime_src: LazySrcLoc = src: {16266 const runtime_src: LazySrcLoc = src: {
16268 if (try sema.resolveMaybeUndefVal(lhs)) |lval| {16267 if (try sema.resolveValue(lhs)) |lval| {
16269 if (try sema.resolveMaybeUndefVal(rhs)) |rval| {16268 if (try sema.resolveValue(rhs)) |rval| {
16270 if (lval.isUndef(mod) or rval.isUndef(mod)) {16269 if (lval.isUndef(mod) or rval.isUndef(mod)) {
16271 return mod.undefRef(Type.bool);16270 return mod.undefRef(Type.bool);
16272 }16271 }
...@@ -16321,7 +16320,7 @@ fn analyzeCmpUnionTag(...@@ -16321,7 +16320,7 @@ fn analyzeCmpUnionTag(
16321 const coerced_tag = try sema.coerce(block, union_tag_ty, tag, tag_src);16320 const coerced_tag = try sema.coerce(block, union_tag_ty, tag, tag_src);
16322 const coerced_union = try sema.coerce(block, union_tag_ty, un, un_src);16321 const coerced_union = try sema.coerce(block, union_tag_ty, un, un_src);
1632316322
16324 if (try sema.resolveMaybeUndefVal(coerced_tag)) |enum_val| {16323 if (try sema.resolveValue(coerced_tag)) |enum_val| {
16325 if (enum_val.isUndef(mod)) return mod.undefRef(Type.bool);16324 if (enum_val.isUndef(mod)) return mod.undefRef(Type.bool);
16326 const field_ty = union_ty.unionFieldType(enum_val, mod).?;16325 const field_ty = union_ty.unionFieldType(enum_val, mod).?;
16327 if (field_ty.zigTypeTag(mod) == .NoReturn) {16326 if (field_ty.zigTypeTag(mod) == .NoReturn) {
...@@ -16423,9 +16422,9 @@ fn cmpSelf(...@@ -16423,9 +16422,9 @@ fn cmpSelf(
16423 const mod = sema.mod;16422 const mod = sema.mod;
16424 const resolved_type = sema.typeOf(casted_lhs);16423 const resolved_type = sema.typeOf(casted_lhs);
16425 const runtime_src: LazySrcLoc = src: {16424 const runtime_src: LazySrcLoc = src: {
16426 if (try sema.resolveMaybeUndefVal(casted_lhs)) |lhs_val| {16425 if (try sema.resolveValue(casted_lhs)) |lhs_val| {
16427 if (lhs_val.isUndef(mod)) return mod.undefRef(Type.bool);16426 if (lhs_val.isUndef(mod)) return mod.undefRef(Type.bool);
16428 if (try sema.resolveMaybeUndefVal(casted_rhs)) |rhs_val| {16427 if (try sema.resolveValue(casted_rhs)) |rhs_val| {
16429 if (rhs_val.isUndef(mod)) return mod.undefRef(Type.bool);16428 if (rhs_val.isUndef(mod)) return mod.undefRef(Type.bool);
1643016429
16431 if (resolved_type.zigTypeTag(mod) == .Vector) {16430 if (resolved_type.zigTypeTag(mod) == .Vector) {
...@@ -16448,7 +16447,7 @@ fn cmpSelf(...@@ -16448,7 +16447,7 @@ fn cmpSelf(
16448 // For bools, we still check the other operand, because we can lower16447 // For bools, we still check the other operand, because we can lower
16449 // bool eq/neq more efficiently.16448 // bool eq/neq more efficiently.
16450 if (resolved_type.zigTypeTag(mod) == .Bool) {16449 if (resolved_type.zigTypeTag(mod) == .Bool) {
16451 if (try sema.resolveMaybeUndefVal(casted_rhs)) |rhs_val| {16450 if (try sema.resolveValue(casted_rhs)) |rhs_val| {
16452 if (rhs_val.isUndef(mod)) return mod.undefRef(Type.bool);16451 if (rhs_val.isUndef(mod)) return mod.undefRef(Type.bool);
16453 return sema.runtimeBoolCmp(block, src, op, casted_lhs, rhs_val.toBool(), lhs_src);16452 return sema.runtimeBoolCmp(block, src, op, casted_lhs, rhs_val.toBool(), lhs_src);
16454 }16453 }
...@@ -16594,7 +16593,7 @@ fn zirClosureCapture(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr...@@ -16594,7 +16593,7 @@ fn zirClosureCapture(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
16594 .zir_index = inst,16593 .zir_index = inst,
16595 .index = block.wip_capture_scope,16594 .index = block.wip_capture_scope,
16596 };16595 };
16597 if (try sema.resolveMaybeUndefVal(operand)) |val| {16596 if (try sema.resolveValue(operand)) |val| {
16598 try mod.comptime_capture_scopes.put(gpa, key, try val.intern(ty, mod));16597 try mod.comptime_capture_scopes.put(gpa, key, try val.intern(ty, mod));
16599 } else {16598 } else {
16600 try mod.runtime_capture_scopes.put(gpa, key, ty.toIntern());16599 try mod.runtime_capture_scopes.put(gpa, key, ty.toIntern());
...@@ -18079,7 +18078,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air...@@ -18079,7 +18078,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
18079 const uncasted_operand = try sema.resolveInst(inst_data.operand);18078 const uncasted_operand = try sema.resolveInst(inst_data.operand);
1808018079
18081 const operand = try sema.coerce(block, Type.bool, uncasted_operand, operand_src);18080 const operand = try sema.coerce(block, Type.bool, uncasted_operand, operand_src);
18082 if (try sema.resolveMaybeUndefVal(operand)) |val| {18081 if (try sema.resolveValue(operand)) |val| {
18083 return if (val.isUndef(mod))18082 return if (val.isUndef(mod))
18084 mod.undefRef(Type.bool)18083 mod.undefRef(Type.bool)
18085 else if (val.toBool()) .bool_false else .bool_true;18084 else if (val.toBool()) .bool_false else .bool_true;
...@@ -18238,7 +18237,7 @@ fn zirIsNonNullPtr(...@@ -18238,7 +18237,7 @@ fn zirIsNonNullPtr(
18238 const src = inst_data.src();18237 const src = inst_data.src();
18239 const ptr = try sema.resolveInst(inst_data.operand);18238 const ptr = try sema.resolveInst(inst_data.operand);
18240 try sema.checkNullableType(block, src, sema.typeOf(ptr).elemType2(mod));18239 try sema.checkNullableType(block, src, sema.typeOf(ptr).elemType2(mod));
18241 if ((try sema.resolveMaybeUndefVal(ptr)) == null) {18240 if ((try sema.resolveValue(ptr)) == null) {
18242 return block.addUnOp(.is_non_null_ptr, ptr);18241 return block.addUnOp(.is_non_null_ptr, ptr);
18243 }18242 }
18244 const loaded = try sema.analyzeLoad(block, src, ptr, src);18243 const loaded = try sema.analyzeLoad(block, src, ptr, src);
...@@ -18833,7 +18832,7 @@ fn analyzeRet(...@@ -18833,7 +18832,7 @@ fn analyzeRet(
1883318832
18834 if (block.inlining) |inlining| {18833 if (block.inlining) |inlining| {
18835 if (block.is_comptime) {18834 if (block.is_comptime) {
18836 _ = try sema.resolveConstMaybeUndefVal(block, src, operand, .{18835 _ = try sema.resolveConstValue(block, src, operand, .{
18837 .needed_comptime_reason = "value being returned at comptime must be comptime-known",18836 .needed_comptime_reason = "value being returned at comptime must be comptime-known",
18838 });18837 });
18839 inlining.comptime_result = operand;18838 inlining.comptime_result = operand;
...@@ -18915,7 +18914,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air...@@ -18915,7 +18914,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
18915 const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);18914 const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
18916 extra_i += 1;18915 extra_i += 1;
18917 const coerced = try sema.coerce(block, elem_ty, try sema.resolveInst(ref), sentinel_src);18916 const coerced = try sema.coerce(block, elem_ty, try sema.resolveInst(ref), sentinel_src);
18918 const val = try sema.resolveConstValue(block, sentinel_src, coerced, .{18917 const val = try sema.resolveConstDefinedValue(block, sentinel_src, coerced, .{
18919 .needed_comptime_reason = "pointer sentinel value must be comptime-known",18918 .needed_comptime_reason = "pointer sentinel value must be comptime-known",
18920 });18919 });
18921 break :blk val.toIntern();18920 break :blk val.toIntern();
...@@ -18925,7 +18924,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air...@@ -18925,7 +18924,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
18925 const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);18924 const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]);
18926 extra_i += 1;18925 extra_i += 1;
18927 const coerced = try sema.coerce(block, Type.u32, try sema.resolveInst(ref), align_src);18926 const coerced = try sema.coerce(block, Type.u32, try sema.resolveInst(ref), align_src);
18928 const val = try sema.resolveConstValue(block, align_src, coerced, .{18927 const val = try sema.resolveConstDefinedValue(block, align_src, coerced, .{
18929 .needed_comptime_reason = "pointer alignment must be comptime-known",18928 .needed_comptime_reason = "pointer alignment must be comptime-known",
18930 });18929 });
18931 // Check if this happens to be the lazy alignment of our element type, in18930 // Check if this happens to be the lazy alignment of our element type, in
...@@ -19073,7 +19072,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is...@@ -19073,7 +19072,7 @@ fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is
19073 const init_ref = try sema.coerce(block, init_ty, empty_ref, src);19072 const init_ref = try sema.coerce(block, init_ty, empty_ref, src);
1907419073
19075 if (is_byref) {19074 if (is_byref) {
19076 const init_val = (try sema.resolveMaybeUndefVal(init_ref)).?;19075 const init_val = (try sema.resolveValue(init_ref)).?;
19077 var anon_decl = try block.startAnonDecl();19076 var anon_decl = try block.startAnonDecl();
19078 defer anon_decl.deinit();19077 defer anon_decl.deinit();
19079 const decl = try anon_decl.finish(init_ty, init_val, .none);19078 const decl = try anon_decl.finish(init_ty, init_val, .none);
...@@ -19158,7 +19157,7 @@ fn unionInit(...@@ -19158,7 +19157,7 @@ fn unionInit(
19158 const field_ty = mod.typeToUnion(union_ty).?.field_types.get(ip)[field_index].toType();19157 const field_ty = mod.typeToUnion(union_ty).?.field_types.get(ip)[field_index].toType();
19159 const init = try sema.coerce(block, field_ty, uncasted_init, init_src);19158 const init = try sema.coerce(block, field_ty, uncasted_init, init_src);
1916019159
19161 if (try sema.resolveMaybeUndefVal(init)) |init_val| {19160 if (try sema.resolveValue(init)) |init_val| {
19162 const tag_ty = union_ty.unionTagTypeHypothetical(mod);19161 const tag_ty = union_ty.unionTagTypeHypothetical(mod);
19163 const tag_val = try mod.enumValueFieldIndex(tag_ty, field_index);19162 const tag_val = try mod.enumValueFieldIndex(tag_ty, field_index);
19164 return Air.internedToRef((try mod.intern(.{ .un = .{19163 return Air.internedToRef((try mod.intern(.{ .un = .{
...@@ -19247,7 +19246,7 @@ fn zirStructInit(...@@ -19247,7 +19246,7 @@ fn zirStructInit(
19247 const field_ty = resolved_ty.structFieldType(field_index, mod);19246 const field_ty = resolved_ty.structFieldType(field_index, mod);
19248 field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);19247 field_inits[field_index] = try sema.coerce(block, field_ty, uncoerced_init, field_src);
19249 if (!is_packed) if (try resolved_ty.structFieldValueComptime(mod, field_index)) |default_value| {19248 if (!is_packed) if (try resolved_ty.structFieldValueComptime(mod, field_index)) |default_value| {
19250 const init_val = (try sema.resolveMaybeUndefVal(field_inits[field_index])) orelse {19249 const init_val = (try sema.resolveValue(field_inits[field_index])) orelse {
19251 return sema.failWithNeededComptime(block, field_src, .{19250 return sema.failWithNeededComptime(block, field_src, .{
19252 .needed_comptime_reason = "value stored in comptime field must be comptime-known",19251 .needed_comptime_reason = "value stored in comptime field must be comptime-known",
19253 });19252 });
...@@ -19292,14 +19291,14 @@ fn zirStructInit(...@@ -19292,14 +19291,14 @@ fn zirStructInit(
19292 const uncoerced_init_inst = try sema.resolveInst(item.data.init);19291 const uncoerced_init_inst = try sema.resolveInst(item.data.init);
19293 const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);19292 const init_inst = try sema.coerce(block, field_ty, uncoerced_init_inst, field_src);
1929419293
19295 if (try sema.resolveMaybeUndefVal(init_inst)) |val| {19294 if (try sema.resolveValue(init_inst)) |val| {
19296 const struct_val = (try mod.intern(.{ .un = .{19295 const struct_val = (try mod.intern(.{ .un = .{
19297 .ty = resolved_ty.toIntern(),19296 .ty = resolved_ty.toIntern(),
19298 .tag = try tag_val.intern(tag_ty, mod),19297 .tag = try tag_val.intern(tag_ty, mod),
19299 .val = try val.intern(field_ty, mod),19298 .val = try val.intern(field_ty, mod),
19300 } })).toValue();19299 } })).toValue();
19301 const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src);19300 const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val.toIntern()), src);
19302 const final_val = (try sema.resolveMaybeUndefVal(final_val_inst)).?;19301 const final_val = (try sema.resolveValue(final_val_inst)).?;
19303 return sema.addConstantMaybeRef(block, resolved_ty, final_val, is_ref);19302 return sema.addConstantMaybeRef(block, resolved_ty, final_val, is_ref);
19304 }19303 }
1930519304
...@@ -19452,14 +19451,14 @@ fn finishStructInit(...@@ -19452,14 +19451,14 @@ fn finishStructInit(
19452 const runtime_index = opt_runtime_index orelse {19451 const runtime_index = opt_runtime_index orelse {
19453 const elems = try sema.arena.alloc(InternPool.Index, field_inits.len);19452 const elems = try sema.arena.alloc(InternPool.Index, field_inits.len);
19454 for (elems, field_inits) |*elem, field_init| {19453 for (elems, field_inits) |*elem, field_init| {
19455 elem.* = (sema.resolveMaybeUndefVal(field_init) catch unreachable).?.toIntern();19454 elem.* = (sema.resolveValue(field_init) catch unreachable).?.toIntern();
19456 }19455 }
19457 const struct_val = try mod.intern(.{ .aggregate = .{19456 const struct_val = try mod.intern(.{ .aggregate = .{
19458 .ty = struct_ty.toIntern(),19457 .ty = struct_ty.toIntern(),
19459 .storage = .{ .elems = elems },19458 .storage = .{ .elems = elems },
19460 } });19459 } });
19461 const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val), init_src);19460 const final_val_inst = try sema.coerce(block, result_ty, Air.internedToRef(struct_val), init_src);
19462 const final_val = (try sema.resolveMaybeUndefVal(final_val_inst)).?;19461 const final_val = (try sema.resolveValue(final_val_inst)).?;
19463 return sema.addConstantMaybeRef(block, result_ty, final_val, is_ref);19462 return sema.addConstantMaybeRef(block, result_ty, final_val, is_ref);
19464 };19463 };
1946519464
...@@ -19592,7 +19591,7 @@ fn structInitAnon(...@@ -19592,7 +19591,7 @@ fn structInitAnon(
19592 };19591 };
19593 return sema.failWithOwnedErrorMsg(block, msg);19592 return sema.failWithOwnedErrorMsg(block, msg);
19594 }19593 }
19595 if (try sema.resolveMaybeUndefVal(init)) |init_val| {19594 if (try sema.resolveValue(init)) |init_val| {
19596 values[i] = try init_val.intern(field_ty.toType(), mod);19595 values[i] = try init_val.intern(field_ty.toType(), mod);
19597 } else {19596 } else {
19598 values[i] = .none;19597 values[i] = .none;
...@@ -19738,7 +19737,7 @@ fn zirArrayInit(...@@ -19738,7 +19737,7 @@ fn zirArrayInit(
19738 else => return err,19737 else => return err,
19739 };19738 };
19740 if (is_tuple) if (try array_ty.structFieldValueComptime(mod, i)) |field_val| {19739 if (is_tuple) if (try array_ty.structFieldValueComptime(mod, i)) |field_val| {
19741 const init_val = try sema.resolveMaybeUndefVal(dest.*) orelse {19740 const init_val = try sema.resolveValue(dest.*) orelse {
19742 const decl = mod.declPtr(block.src_decl);19741 const decl = mod.declPtr(block.src_decl);
19743 const elem_src = mod.initSrc(src.node_offset.x, decl, i);19742 const elem_src = mod.initSrc(src.node_offset.x, decl, i);
19744 return sema.failWithNeededComptime(block, elem_src, .{19743 return sema.failWithNeededComptime(block, elem_src, .{
...@@ -19772,14 +19771,14 @@ fn zirArrayInit(...@@ -19772,14 +19771,14 @@ fn zirArrayInit(
19772 else19771 else
19773 array_ty.elemType2(mod);19772 array_ty.elemType2(mod);
19774 // We checked that all args are comptime above.19773 // We checked that all args are comptime above.
19775 val.* = try ((sema.resolveMaybeUndefVal(arg) catch unreachable).?).intern(elem_ty, mod);19774 val.* = try ((sema.resolveValue(arg) catch unreachable).?).intern(elem_ty, mod);
19776 }19775 }
19777 const arr_val = try mod.intern(.{ .aggregate = .{19776 const arr_val = try mod.intern(.{ .aggregate = .{
19778 .ty = array_ty.toIntern(),19777 .ty = array_ty.toIntern(),
19779 .storage = .{ .elems = elem_vals },19778 .storage = .{ .elems = elem_vals },
19780 } });19779 } });
19781 const result_ref = try sema.coerce(block, result_ty, Air.internedToRef(arr_val), src);19780 const result_ref = try sema.coerce(block, result_ty, Air.internedToRef(arr_val), src);
19782 return sema.addConstantMaybeRef(block, result_ty, (try sema.resolveMaybeUndefVal(result_ref)).?, is_ref);19781 return sema.addConstantMaybeRef(block, result_ty, (try sema.resolveValue(result_ref)).?, is_ref);
19783 };19782 };
1978419783
19785 sema.requireRuntimeBlock(block, .unneeded, null) catch |err| switch (err) {19784 sema.requireRuntimeBlock(block, .unneeded, null) catch |err| switch (err) {
...@@ -19877,7 +19876,7 @@ fn arrayInitAnon(...@@ -19877,7 +19876,7 @@ fn arrayInitAnon(
19877 };19876 };
19878 return sema.failWithOwnedErrorMsg(block, msg);19877 return sema.failWithOwnedErrorMsg(block, msg);
19879 }19878 }
19880 if (try sema.resolveMaybeUndefVal(elem)) |val| {19879 if (try sema.resolveValue(elem)) |val| {
19881 values[i] = val.toIntern();19880 values[i] = val.toIntern();
19882 } else {19881 } else {
19883 values[i] = .none;19882 values[i] = .none;
...@@ -20100,7 +20099,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError...@@ -20100,7 +20099,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
20100 if (operand_scalar_ty.toIntern() != .bool_type) {20099 if (operand_scalar_ty.toIntern() != .bool_type) {
20101 return sema.fail(block, src, "expected 'bool', found '{}'", .{operand_scalar_ty.zigTypeTag(mod)});20100 return sema.fail(block, src, "expected 'bool', found '{}'", .{operand_scalar_ty.zigTypeTag(mod)});
20102 }20101 }
20103 if (try sema.resolveMaybeUndefVal(operand)) |val| {20102 if (try sema.resolveValue(operand)) |val| {
20104 if (!is_vector) {20103 if (!is_vector) {
20105 if (val.isUndef(mod)) return mod.undefRef(Type.u1);20104 if (val.isUndef(mod)) return mod.undefRef(Type.u1);
20106 if (val.toBool()) return Air.internedToRef((try mod.intValue(Type.u1, 1)).toIntern());20105 if (val.toBool()) return Air.internedToRef((try mod.intValue(Type.u1, 1)).toIntern());
...@@ -20191,7 +20190,7 @@ fn maybeConstantUnaryMath(...@@ -20191,7 +20190,7 @@ fn maybeConstantUnaryMath(
20191) CompileError!?Air.Inst.Ref {20190) CompileError!?Air.Inst.Ref {
20192 const mod = sema.mod;20191 const mod = sema.mod;
20193 switch (result_ty.zigTypeTag(mod)) {20192 switch (result_ty.zigTypeTag(mod)) {
20194 .Vector => if (try sema.resolveMaybeUndefVal(operand)) |val| {20193 .Vector => if (try sema.resolveValue(operand)) |val| {
20195 const scalar_ty = result_ty.scalarType(mod);20194 const scalar_ty = result_ty.scalarType(mod);
20196 const vec_len = result_ty.vectorLen(mod);20195 const vec_len = result_ty.vectorLen(mod);
20197 if (val.isUndef(mod))20196 if (val.isUndef(mod))
...@@ -20207,7 +20206,7 @@ fn maybeConstantUnaryMath(...@@ -20207,7 +20206,7 @@ fn maybeConstantUnaryMath(
20207 .storage = .{ .elems = elems },20206 .storage = .{ .elems = elems },
20208 } })));20207 } })));
20209 },20208 },
20210 else => if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {20209 else => if (try sema.resolveValue(operand)) |operand_val| {
20211 if (operand_val.isUndef(mod))20210 if (operand_val.isUndef(mod))
20212 return try mod.undefRef(result_ty);20211 return try mod.undefRef(result_ty);
20213 const result_val = try eval(operand_val, result_ty, sema.arena, sema.mod);20212 const result_val = try eval(operand_val, result_ty, sema.arena, sema.mod);
...@@ -20262,7 +20261,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air...@@ -20262,7 +20261,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
20262 try sema.resolveTypeLayout(operand_ty);20261 try sema.resolveTypeLayout(operand_ty);
20263 const enum_ty = switch (operand_ty.zigTypeTag(mod)) {20262 const enum_ty = switch (operand_ty.zigTypeTag(mod)) {
20264 .EnumLiteral => {20263 .EnumLiteral => {
20265 const val = try sema.resolveConstValue(block, .unneeded, operand, undefined);20264 const val = try sema.resolveConstDefinedValue(block, .unneeded, operand, undefined);
20266 const tag_name = ip.indexToKey(val.toIntern()).enum_literal;20265 const tag_name = ip.indexToKey(val.toIntern()).enum_literal;
20267 return sema.addStrLit(ip.stringToSlice(tag_name));20266 return sema.addStrLit(ip.stringToSlice(tag_name));
20268 },20267 },
...@@ -20335,7 +20334,7 @@ fn zirReify(...@@ -20335,7 +20334,7 @@ fn zirReify(
20335 const uncasted_operand = try sema.resolveInst(extra.operand);20334 const uncasted_operand = try sema.resolveInst(extra.operand);
20336 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };20335 const operand_src: LazySrcLoc = .{ .node_offset_builtin_call_arg0 = extra.node };
20337 const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src);20336 const type_info = try sema.coerce(block, type_info_ty, uncasted_operand, operand_src);
20338 const val = try sema.resolveConstValue(block, operand_src, type_info, .{20337 const val = try sema.resolveConstDefinedValue(block, operand_src, type_info, .{
20339 .needed_comptime_reason = "operand to @Type must be comptime-known",20338 .needed_comptime_reason = "operand to @Type must be comptime-known",
20340 });20339 });
20341 const union_val = ip.indexToKey(val.toIntern()).un;20340 const union_val = ip.indexToKey(val.toIntern()).un;
...@@ -21486,7 +21485,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro...@@ -21486,7 +21485,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
21486 _ = try sema.checkIntType(block, src, dest_scalar_ty);21485 _ = try sema.checkIntType(block, src, dest_scalar_ty);
21487 try sema.checkFloatType(block, operand_src, operand_scalar_ty);21486 try sema.checkFloatType(block, operand_src, operand_scalar_ty);
2148821487
21489 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {21488 if (try sema.resolveValue(operand)) |operand_val| {
21490 const result_val = try sema.intFromFloat(block, operand_src, operand_val, operand_ty, dest_ty, .truncate);21489 const result_val = try sema.intFromFloat(block, operand_src, operand_val, operand_ty, dest_ty, .truncate);
21491 return Air.internedToRef(result_val.toIntern());21490 return Air.internedToRef(result_val.toIntern());
21492 } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeInt) {21491 } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
...@@ -21568,7 +21567,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro...@@ -21568,7 +21567,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
21568 try sema.checkFloatType(block, src, dest_scalar_ty);21567 try sema.checkFloatType(block, src, dest_scalar_ty);
21569 _ = try sema.checkIntType(block, operand_src, operand_scalar_ty);21568 _ = try sema.checkIntType(block, operand_src, operand_scalar_ty);
2157021569
21571 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {21570 if (try sema.resolveValue(operand)) |operand_val| {
21572 const result_val = try operand_val.floatFromIntAdvanced(sema.arena, operand_ty, dest_ty, mod, sema);21571 const result_val = try operand_val.floatFromIntAdvanced(sema.arena, operand_ty, dest_ty, mod, sema);
21573 return Air.internedToRef(result_val.toIntern());21572 return Air.internedToRef(result_val.toIntern());
21574 } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeFloat) {21573 } else if (dest_scalar_ty.zigTypeTag(mod) == .ComptimeFloat) {
...@@ -22158,7 +22157,7 @@ fn ptrCastFull(...@@ -22158,7 +22157,7 @@ fn ptrCastFull(
2215822157
22159 // Cannot do @addrSpaceCast at comptime22158 // Cannot do @addrSpaceCast at comptime
22160 if (!flags.addrspace_cast) {22159 if (!flags.addrspace_cast) {
22161 if (try sema.resolveMaybeUndefVal(ptr)) |ptr_val| {22160 if (try sema.resolveValue(ptr)) |ptr_val| {
22162 if (!dest_ty.ptrAllowsZero(mod) and ptr_val.isUndef(mod)) {22161 if (!dest_ty.ptrAllowsZero(mod) and ptr_val.isUndef(mod)) {
22163 return sema.failWithUseOfUndef(block, operand_src);22162 return sema.failWithUseOfUndef(block, operand_src);
22164 }22163 }
...@@ -22286,7 +22285,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst...@@ -22286,7 +22285,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
22286 if (flags.volatile_cast) ptr_info.flags.is_volatile = false;22285 if (flags.volatile_cast) ptr_info.flags.is_volatile = false;
22287 const dest_ty = try sema.ptrType(ptr_info);22286 const dest_ty = try sema.ptrType(ptr_info);
2228822287
22289 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {22288 if (try sema.resolveValue(operand)) |operand_val| {
22290 return Air.internedToRef((try mod.getCoerced(operand_val, dest_ty)).toIntern());22289 return Air.internedToRef((try mod.getCoerced(operand_val, dest_ty)).toIntern());
22291 }22290 }
2229222291
...@@ -22356,7 +22355,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -22356,7 +22355,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
22356 }22355 }
22357 }22356 }
2235822357
22359 if (try sema.resolveMaybeUndefValIntable(operand)) |val| {22358 if (try sema.resolveValueIntable(operand)) |val| {
22360 if (val.isUndef(mod)) return mod.undefRef(dest_ty);22359 if (val.isUndef(mod)) return mod.undefRef(dest_ty);
22361 if (!dest_is_vector) {22360 if (!dest_is_vector) {
22362 return Air.internedToRef((try mod.getCoerced(22361 return Air.internedToRef((try mod.getCoerced(
...@@ -22407,7 +22406,7 @@ fn zirBitCount(...@@ -22407,7 +22406,7 @@ fn zirBitCount(
22407 .len = vec_len,22406 .len = vec_len,
22408 .child = result_scalar_ty.toIntern(),22407 .child = result_scalar_ty.toIntern(),
22409 });22408 });
22410 if (try sema.resolveMaybeUndefVal(operand)) |val| {22409 if (try sema.resolveValue(operand)) |val| {
22411 if (val.isUndef(mod)) return mod.undefRef(result_ty);22410 if (val.isUndef(mod)) return mod.undefRef(result_ty);
2241222411
22413 const elems = try sema.arena.alloc(InternPool.Index, vec_len);22412 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
...@@ -22427,7 +22426,7 @@ fn zirBitCount(...@@ -22427,7 +22426,7 @@ fn zirBitCount(
22427 }22426 }
22428 },22427 },
22429 .Int => {22428 .Int => {
22430 if (try sema.resolveMaybeUndefLazyVal(operand)) |val| {22429 if (try sema.resolveValueResolveLazy(operand)) |val| {
22431 if (val.isUndef(mod)) return mod.undefRef(result_scalar_ty);22430 if (val.isUndef(mod)) return mod.undefRef(result_scalar_ty);
22432 return mod.intRef(result_scalar_ty, comptimeOp(val, operand_ty, mod));22431 return mod.intRef(result_scalar_ty, comptimeOp(val, operand_ty, mod));
22433 } else {22432 } else {
...@@ -22463,7 +22462,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -22463,7 +22462,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2246322462
22464 switch (operand_ty.zigTypeTag(mod)) {22463 switch (operand_ty.zigTypeTag(mod)) {
22465 .Int => {22464 .Int => {
22466 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {22465 const runtime_src = if (try sema.resolveValue(operand)) |val| {
22467 if (val.isUndef(mod)) return mod.undefRef(operand_ty);22466 if (val.isUndef(mod)) return mod.undefRef(operand_ty);
22468 const result_val = try val.byteSwap(operand_ty, mod, sema.arena);22467 const result_val = try val.byteSwap(operand_ty, mod, sema.arena);
22469 return Air.internedToRef(result_val.toIntern());22468 return Air.internedToRef(result_val.toIntern());
...@@ -22473,7 +22472,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai...@@ -22473,7 +22472,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
22473 return block.addTyOp(.byte_swap, operand_ty, operand);22472 return block.addTyOp(.byte_swap, operand_ty, operand);
22474 },22473 },
22475 .Vector => {22474 .Vector => {
22476 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {22475 const runtime_src = if (try sema.resolveValue(operand)) |val| {
22477 if (val.isUndef(mod))22476 if (val.isUndef(mod))
22478 return mod.undefRef(operand_ty);22477 return mod.undefRef(operand_ty);
2247922478
...@@ -22511,7 +22510,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!...@@ -22511,7 +22510,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
22511 const mod = sema.mod;22510 const mod = sema.mod;
22512 switch (operand_ty.zigTypeTag(mod)) {22511 switch (operand_ty.zigTypeTag(mod)) {
22513 .Int => {22512 .Int => {
22514 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {22513 const runtime_src = if (try sema.resolveValue(operand)) |val| {
22515 if (val.isUndef(mod)) return mod.undefRef(operand_ty);22514 if (val.isUndef(mod)) return mod.undefRef(operand_ty);
22516 const result_val = try val.bitReverse(operand_ty, mod, sema.arena);22515 const result_val = try val.bitReverse(operand_ty, mod, sema.arena);
22517 return Air.internedToRef(result_val.toIntern());22516 return Air.internedToRef(result_val.toIntern());
...@@ -22521,7 +22520,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!...@@ -22521,7 +22520,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
22521 return block.addTyOp(.bit_reverse, operand_ty, operand);22520 return block.addTyOp(.bit_reverse, operand_ty, operand);
22522 },22521 },
22523 .Vector => {22522 .Vector => {
22524 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {22523 const runtime_src = if (try sema.resolveValue(operand)) |val| {
22525 if (val.isUndef(mod))22524 if (val.isUndef(mod))
22526 return mod.undefRef(operand_ty);22525 return mod.undefRef(operand_ty);
2252722526
...@@ -22967,8 +22966,8 @@ fn checkSimdBinOp(...@@ -22967,8 +22966,8 @@ fn checkSimdBinOp(
22967 .len = vec_len,22966 .len = vec_len,
22968 .lhs = lhs,22967 .lhs = lhs,
22969 .rhs = rhs,22968 .rhs = rhs,
22970 .lhs_val = try sema.resolveMaybeUndefVal(lhs),22969 .lhs_val = try sema.resolveValue(lhs),
22971 .rhs_val = try sema.resolveMaybeUndefVal(rhs),22970 .rhs_val = try sema.resolveValue(rhs),
22972 .result_ty = result_ty,22971 .result_ty = result_ty,
22973 .scalar_ty = result_ty.scalarType(mod),22972 .scalar_ty = result_ty.scalarType(mod),
22974 };22973 };
...@@ -23054,20 +23053,20 @@ fn resolveExportOptions(...@@ -23054,20 +23053,20 @@ fn resolveExportOptions(
23054 const visibility_src = sema.maybeOptionsSrc(block, src, "visibility");23053 const visibility_src = sema.maybeOptionsSrc(block, src, "visibility");
2305523054
23056 const name_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "name"), name_src);23055 const name_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "name"), name_src);
23057 const name_val = try sema.resolveConstValue(block, name_src, name_operand, .{23056 const name_val = try sema.resolveConstDefinedValue(block, name_src, name_operand, .{
23058 .needed_comptime_reason = "name of exported value must be comptime-known",23057 .needed_comptime_reason = "name of exported value must be comptime-known",
23059 });23058 });
23060 const name_ty = Type.slice_const_u8;23059 const name_ty = Type.slice_const_u8;
23061 const name = try name_val.toAllocatedBytes(name_ty, sema.arena, mod);23060 const name = try name_val.toAllocatedBytes(name_ty, sema.arena, mod);
2306223061
23063 const linkage_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "linkage"), linkage_src);23062 const linkage_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "linkage"), linkage_src);
23064 const linkage_val = try sema.resolveConstValue(block, linkage_src, linkage_operand, .{23063 const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_operand, .{
23065 .needed_comptime_reason = "linkage of exported value must be comptime-known",23064 .needed_comptime_reason = "linkage of exported value must be comptime-known",
23066 });23065 });
23067 const linkage = mod.toEnum(std.builtin.GlobalLinkage, linkage_val);23066 const linkage = mod.toEnum(std.builtin.GlobalLinkage, linkage_val);
2306823067
23069 const section_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "section"), section_src);23068 const section_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "section"), section_src);
23070 const section_opt_val = try sema.resolveConstValue(block, section_src, section_operand, .{23069 const section_opt_val = try sema.resolveConstDefinedValue(block, section_src, section_operand, .{
23071 .needed_comptime_reason = "linksection of exported value must be comptime-known",23070 .needed_comptime_reason = "linksection of exported value must be comptime-known",
23072 });23071 });
23073 const section_ty = Type.slice_const_u8;23072 const section_ty = Type.slice_const_u8;
...@@ -23077,7 +23076,7 @@ fn resolveExportOptions(...@@ -23077,7 +23076,7 @@ fn resolveExportOptions(
23077 null;23076 null;
2307823077
23079 const visibility_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "visibility"), visibility_src);23078 const visibility_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "visibility"), visibility_src);
23080 const visibility_val = try sema.resolveConstValue(block, visibility_src, visibility_operand, .{23079 const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_operand, .{
23081 .needed_comptime_reason = "visibility of exported value must be comptime-known",23080 .needed_comptime_reason = "visibility of exported value must be comptime-known",
23082 });23081 });
23083 const visibility = mod.toEnum(std.builtin.SymbolVisibility, visibility_val);23082 const visibility = mod.toEnum(std.builtin.SymbolVisibility, visibility_val);
...@@ -23112,7 +23111,7 @@ fn resolveBuiltinEnum(...@@ -23112,7 +23111,7 @@ fn resolveBuiltinEnum(
23112 const ty = try sema.getBuiltinType(name);23111 const ty = try sema.getBuiltinType(name);
23113 const air_ref = try sema.resolveInst(zir_ref);23112 const air_ref = try sema.resolveInst(zir_ref);
23114 const coerced = try sema.coerce(block, ty, air_ref, src);23113 const coerced = try sema.coerce(block, ty, air_ref, src);
23115 const val = try sema.resolveConstValue(block, src, coerced, reason);23114 const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
23116 return mod.toEnum(@field(std.builtin, name), val);23115 return mod.toEnum(@field(std.builtin, name), val);
23117}23116}
2311823117
...@@ -23202,8 +23201,8 @@ fn zirCmpxchg(...@@ -23202,8 +23201,8 @@ fn zirCmpxchg(
23202 }23201 }
2320323202
23204 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {23203 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
23205 if (try sema.resolveMaybeUndefVal(expected_value)) |expected_val| {23204 if (try sema.resolveValue(expected_value)) |expected_val| {
23206 if (try sema.resolveMaybeUndefVal(new_value)) |new_val| {23205 if (try sema.resolveValue(new_value)) |new_val| {
23207 if (expected_val.isUndef(mod) or new_val.isUndef(mod)) {23206 if (expected_val.isUndef(mod) or new_val.isUndef(mod)) {
23208 // TODO: this should probably cause the memory stored at the pointer23207 // TODO: this should probably cause the memory stored at the pointer
23209 // to become undef as well23208 // to become undef as well
...@@ -23254,7 +23253,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I...@@ -23254,7 +23253,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
23254 const operand = try sema.resolveInst(extra.rhs);23253 const operand = try sema.resolveInst(extra.rhs);
23255 const scalar_ty = dest_ty.childType(mod);23254 const scalar_ty = dest_ty.childType(mod);
23256 const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);23255 const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);
23257 if (try sema.resolveMaybeUndefVal(scalar)) |scalar_val| {23256 if (try sema.resolveValue(scalar)) |scalar_val| {
23258 if (scalar_val.isUndef(mod)) return mod.undefRef(dest_ty);23257 if (scalar_val.isUndef(mod)) return mod.undefRef(dest_ty);
23259 return Air.internedToRef((try sema.splat(dest_ty, scalar_val)).toIntern());23258 return Air.internedToRef((try sema.splat(dest_ty, scalar_val)).toIntern());
23260 }23259 }
...@@ -23304,7 +23303,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air....@@ -23304,7 +23303,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
23304 return sema.fail(block, operand_src, "@reduce operation requires a vector with nonzero length", .{});23303 return sema.fail(block, operand_src, "@reduce operation requires a vector with nonzero length", .{});
23305 }23304 }
2330623305
23307 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {23306 if (try sema.resolveValue(operand)) |operand_val| {
23308 if (operand_val.isUndef(mod)) return mod.undefRef(scalar_ty);23307 if (operand_val.isUndef(mod)) return mod.undefRef(scalar_ty);
2330923308
23310 var accum: Value = try operand_val.elemValue(mod, 0);23309 var accum: Value = try operand_val.elemValue(mod, 0);
...@@ -23357,7 +23356,7 @@ fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air...@@ -23357,7 +23356,7 @@ fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
23357 .child = .i32_type,23356 .child = .i32_type,
23358 });23357 });
23359 mask = try sema.coerce(block, mask_ty, mask, mask_src);23358 mask = try sema.coerce(block, mask_ty, mask, mask_src);
23360 const mask_val = try sema.resolveConstMaybeUndefVal(block, mask_src, mask, .{23359 const mask_val = try sema.resolveConstValue(block, mask_src, mask, .{
23361 .needed_comptime_reason = "shuffle mask must be comptime-known",23360 .needed_comptime_reason = "shuffle mask must be comptime-known",
23362 });23361 });
23363 return sema.analyzeShuffle(block, inst_data.src_node, elem_ty, a, b, mask_val, @intCast(mask_len));23362 return sema.analyzeShuffle(block, inst_data.src_node, elem_ty, a, b, mask_val, @intCast(mask_len));
...@@ -23457,8 +23456,8 @@ fn analyzeShuffle(...@@ -23457,8 +23456,8 @@ fn analyzeShuffle(
23457 }23456 }
23458 }23457 }
2345923458
23460 if (try sema.resolveMaybeUndefVal(a)) |a_val| {23459 if (try sema.resolveValue(a)) |a_val| {
23461 if (try sema.resolveMaybeUndefVal(b)) |b_val| {23460 if (try sema.resolveValue(b)) |b_val| {
23462 const values = try sema.arena.alloc(InternPool.Index, mask_len);23461 const values = try sema.arena.alloc(InternPool.Index, mask_len);
23463 for (values, 0..) |*value, i| {23462 for (values, 0..) |*value, i| {
23464 const mask_elem_val = try mask.elemValue(sema.mod, i);23463 const mask_elem_val = try mask.elemValue(sema.mod, i);
...@@ -23556,9 +23555,9 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C...@@ -23556,9 +23555,9 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
23556 const a = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.a), a_src);23555 const a = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.a), a_src);
23557 const b = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.b), b_src);23556 const b = try sema.coerce(block, vec_ty, try sema.resolveInst(extra.b), b_src);
2355823557
23559 const maybe_pred = try sema.resolveMaybeUndefVal(pred);23558 const maybe_pred = try sema.resolveValue(pred);
23560 const maybe_a = try sema.resolveMaybeUndefVal(a);23559 const maybe_a = try sema.resolveValue(a);
23561 const maybe_b = try sema.resolveMaybeUndefVal(b);23560 const maybe_b = try sema.resolveValue(b);
2356223561
23563 const runtime_src = if (maybe_pred) |pred_val| rs: {23562 const runtime_src = if (maybe_pred) |pred_val| rs: {
23564 if (pred_val.isUndef(mod)) return mod.undefRef(vec_ty);23563 if (pred_val.isUndef(mod)) return mod.undefRef(vec_ty);
...@@ -23704,7 +23703,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A...@@ -23704,7 +23703,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
23704 }23703 }
2370523704
23706 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {23705 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
23707 const maybe_operand_val = try sema.resolveMaybeUndefVal(operand);23706 const maybe_operand_val = try sema.resolveValue(operand);
23708 const operand_val = maybe_operand_val orelse {23707 const operand_val = maybe_operand_val orelse {
23709 try sema.checkPtrIsNotComptimeMutable(block, ptr_val, ptr_src, operand_src);23708 try sema.checkPtrIsNotComptimeMutable(block, ptr_val, ptr_src, operand_src);
23710 break :rs operand_src;23709 break :rs operand_src;
...@@ -23795,9 +23794,9 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air....@@ -23795,9 +23794,9 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
23795 const mulend1 = try sema.coerce(block, ty, try sema.resolveInst(extra.mulend1), mulend1_src);23794 const mulend1 = try sema.coerce(block, ty, try sema.resolveInst(extra.mulend1), mulend1_src);
23796 const mulend2 = try sema.coerce(block, ty, try sema.resolveInst(extra.mulend2), mulend2_src);23795 const mulend2 = try sema.coerce(block, ty, try sema.resolveInst(extra.mulend2), mulend2_src);
2379723796
23798 const maybe_mulend1 = try sema.resolveMaybeUndefVal(mulend1);23797 const maybe_mulend1 = try sema.resolveValue(mulend1);
23799 const maybe_mulend2 = try sema.resolveMaybeUndefVal(mulend2);23798 const maybe_mulend2 = try sema.resolveValue(mulend2);
23800 const maybe_addend = try sema.resolveMaybeUndefVal(addend);23799 const maybe_addend = try sema.resolveValue(addend);
23801 const mod = sema.mod;23800 const mod = sema.mod;
2380223801
23803 switch (ty.scalarType(mod).zigTypeTag(mod)) {23802 switch (ty.scalarType(mod).zigTypeTag(mod)) {
...@@ -23862,7 +23861,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError...@@ -23862,7 +23861,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
23862 const modifier_ty = try sema.getBuiltinType("CallModifier");23861 const modifier_ty = try sema.getBuiltinType("CallModifier");
23863 const air_ref = try sema.resolveInst(extra.modifier);23862 const air_ref = try sema.resolveInst(extra.modifier);
23864 const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);23863 const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);
23865 const modifier_val = try sema.resolveConstValue(block, modifier_src, modifier_ref, .{23864 const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{
23866 .needed_comptime_reason = "call modifier must be comptime-known",23865 .needed_comptime_reason = "call modifier must be comptime-known",
23867 });23866 });
23868 var modifier = mod.toEnum(std.builtin.CallModifier, modifier_val);23867 var modifier = mod.toEnum(std.builtin.CallModifier, modifier_val);
...@@ -24146,7 +24145,7 @@ fn analyzeMinMax(...@@ -24146,7 +24145,7 @@ fn analyzeMinMax(
24146 for (operands, operand_srcs, 0..) |operand, operand_src, operand_idx| {24145 for (operands, operand_srcs, 0..) |operand, operand_src, operand_idx| {
24147 // Resolve the value now to avoid redundant calls to `checkSimdBinOp` - we'll have to call24146 // Resolve the value now to avoid redundant calls to `checkSimdBinOp` - we'll have to call
24148 // it in the runtime path anyway since the result type may have been refined24147 // it in the runtime path anyway since the result type may have been refined
24149 const unresolved_uncoerced_val = try sema.resolveMaybeUndefVal(operand) orelse continue;24148 const unresolved_uncoerced_val = try sema.resolveValue(operand) orelse continue;
24150 const uncoerced_val = try sema.resolveLazyValue(unresolved_uncoerced_val);24149 const uncoerced_val = try sema.resolveLazyValue(unresolved_uncoerced_val);
2415124150
24152 runtime_known.unset(operand_idx);24151 runtime_known.unset(operand_idx);
...@@ -24222,7 +24221,7 @@ fn analyzeMinMax(...@@ -24222,7 +24221,7 @@ fn analyzeMinMax(
24222 // as possible will allow us to emit more optimal AIR (if all the runtime operands have24221 // as possible will allow us to emit more optimal AIR (if all the runtime operands have
24223 // smaller types than the non-refined comptime type).24222 // smaller types than the non-refined comptime type).
2422424223
24225 const val = (try sema.resolveMaybeUndefVal(ct_minmax_ref)).?;24224 const val = (try sema.resolveValue(ct_minmax_ref)).?;
24226 const orig_ty = sema.typeOf(ct_minmax_ref);24225 const orig_ty = sema.typeOf(ct_minmax_ref);
2422724226
24228 if (opt_runtime_idx == null and orig_ty.scalarType(mod).eql(Type.comptime_int, mod)) {24227 if (opt_runtime_idx == null and orig_ty.scalarType(mod).eql(Type.comptime_int, mod)) {
...@@ -24257,7 +24256,7 @@ fn analyzeMinMax(...@@ -24257,7 +24256,7 @@ fn analyzeMinMax(
2425724256
24258 // If the comptime-known part is undef we can avoid emitting actual instructions later24257 // If the comptime-known part is undef we can avoid emitting actual instructions later
24259 const known_undef = if (cur_minmax) |operand| blk: {24258 const known_undef = if (cur_minmax) |operand| blk: {
24260 const val = (try sema.resolveMaybeUndefVal(operand)).?;24259 const val = (try sema.resolveValue(operand)).?;
24261 break :blk val.isUndef(mod);24260 break :blk val.isUndef(mod);
24262 } else false;24261 } else false;
2426324262
...@@ -24631,7 +24630,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void...@@ -24631,7 +24630,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
24631 }24630 }
2463224631
24633 if (!ptr_val.isComptimeMutablePtr(mod)) break :rs dest_src;24632 if (!ptr_val.isComptimeMutablePtr(mod)) break :rs dest_src;
24634 const elem_val = try sema.resolveMaybeUndefVal(elem) orelse break :rs value_src;24633 const elem_val = try sema.resolveValue(elem) orelse break :rs value_src;
24635 const array_ty = try mod.arrayType(.{24634 const array_ty = try mod.arrayType(.{
24636 .child = dest_elem_ty.toIntern(),24635 .child = dest_elem_ty.toIntern(),
24637 .len = len_u64,24636 .len = len_u64,
...@@ -24736,7 +24735,7 @@ fn zirVarExtended(...@@ -24736,7 +24735,7 @@ fn zirVarExtended(
24736 else24735 else
24737 uncasted_init;24736 uncasted_init;
2473824737
24739 break :blk ((try sema.resolveMaybeUndefVal(init)) orelse {24738 break :blk ((try sema.resolveValue(init)) orelse {
24740 return sema.failWithNeededComptime(block, init_src, .{24739 return sema.failWithNeededComptime(block, init_src, .{
24741 .needed_comptime_reason = "container level variable initializers must be comptime-known",24740 .needed_comptime_reason = "container level variable initializers must be comptime-known",
24742 });24741 });
...@@ -25097,17 +25096,17 @@ fn resolvePrefetchOptions(...@@ -25097,17 +25096,17 @@ fn resolvePrefetchOptions(
25097 const cache_src = sema.maybeOptionsSrc(block, src, "cache");25096 const cache_src = sema.maybeOptionsSrc(block, src, "cache");
2509825097
25099 const rw = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "rw"), rw_src);25098 const rw = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "rw"), rw_src);
25100 const rw_val = try sema.resolveConstValue(block, rw_src, rw, .{25099 const rw_val = try sema.resolveConstDefinedValue(block, rw_src, rw, .{
25101 .needed_comptime_reason = "prefetch read/write must be comptime-known",25100 .needed_comptime_reason = "prefetch read/write must be comptime-known",
25102 });25101 });
2510325102
25104 const locality = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "locality"), locality_src);25103 const locality = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "locality"), locality_src);
25105 const locality_val = try sema.resolveConstValue(block, locality_src, locality, .{25104 const locality_val = try sema.resolveConstDefinedValue(block, locality_src, locality, .{
25106 .needed_comptime_reason = "prefetch locality must be comptime-known",25105 .needed_comptime_reason = "prefetch locality must be comptime-known",
25107 });25106 });
2510825107
25109 const cache = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "cache"), cache_src);25108 const cache = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "cache"), cache_src);
25110 const cache_val = try sema.resolveConstValue(block, cache_src, cache, .{25109 const cache_val = try sema.resolveConstDefinedValue(block, cache_src, cache, .{
25111 .needed_comptime_reason = "prefetch cache must be comptime-known",25110 .needed_comptime_reason = "prefetch cache must be comptime-known",
25112 });25111 });
2511325112
...@@ -25176,24 +25175,24 @@ fn resolveExternOptions(...@@ -25176,24 +25175,24 @@ fn resolveExternOptions(
25176 const thread_local_src = sema.maybeOptionsSrc(block, src, "thread_local");25175 const thread_local_src = sema.maybeOptionsSrc(block, src, "thread_local");
2517725176
25178 const name_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "name"), name_src);25177 const name_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "name"), name_src);
25179 const name_val = try sema.resolveConstValue(block, name_src, name_ref, .{25178 const name_val = try sema.resolveConstDefinedValue(block, name_src, name_ref, .{
25180 .needed_comptime_reason = "name of the extern symbol must be comptime-known",25179 .needed_comptime_reason = "name of the extern symbol must be comptime-known",
25181 });25180 });
25182 const name = try name_val.toAllocatedBytes(Type.slice_const_u8, sema.arena, mod);25181 const name = try name_val.toAllocatedBytes(Type.slice_const_u8, sema.arena, mod);
2518325182
25184 const library_name_inst = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "library_name"), library_src);25183 const library_name_inst = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "library_name"), library_src);
25185 const library_name_val = try sema.resolveConstValue(block, library_src, library_name_inst, .{25184 const library_name_val = try sema.resolveConstDefinedValue(block, library_src, library_name_inst, .{
25186 .needed_comptime_reason = "library in which extern symbol is must be comptime-known",25185 .needed_comptime_reason = "library in which extern symbol is must be comptime-known",
25187 });25186 });
2518825187
25189 const linkage_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "linkage"), linkage_src);25188 const linkage_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "linkage"), linkage_src);
25190 const linkage_val = try sema.resolveConstValue(block, linkage_src, linkage_ref, .{25189 const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_ref, .{
25191 .needed_comptime_reason = "linkage of the extern symbol must be comptime-known",25190 .needed_comptime_reason = "linkage of the extern symbol must be comptime-known",
25192 });25191 });
25193 const linkage = mod.toEnum(std.builtin.GlobalLinkage, linkage_val);25192 const linkage = mod.toEnum(std.builtin.GlobalLinkage, linkage_val);
2519425193
25195 const is_thread_local = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "is_thread_local"), thread_local_src);25194 const is_thread_local = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, "is_thread_local"), thread_local_src);
25196 const is_thread_local_val = try sema.resolveConstValue(block, thread_local_src, is_thread_local, .{25195 const is_thread_local_val = try sema.resolveConstDefinedValue(block, thread_local_src, is_thread_local, .{
25197 .needed_comptime_reason = "threadlocality of the extern symbol must be comptime-known",25196 .needed_comptime_reason = "threadlocality of the extern symbol must be comptime-known",
25198 });25197 });
2519925198
...@@ -26419,7 +26418,7 @@ fn fieldPtr(...@@ -26419,7 +26418,7 @@ fn fieldPtr(
26419 }26418 }
26420 },26419 },
26421 .Type => {26420 .Type => {
26422 _ = try sema.resolveConstValue(block, .unneeded, object_ptr, undefined);26421 _ = try sema.resolveConstDefinedValue(block, .unneeded, object_ptr, undefined);
26423 const result = try sema.analyzeLoad(block, src, object_ptr, object_ptr_src);26422 const result = try sema.analyzeLoad(block, src, object_ptr, object_ptr_src);
26424 const inner = if (is_pointer_to)26423 const inner = if (is_pointer_to)
26425 try sema.analyzeLoad(block, src, result, object_ptr_src)26424 try sema.analyzeLoad(block, src, result, object_ptr_src)
...@@ -26991,7 +26990,7 @@ fn structFieldVal(...@@ -26991,7 +26990,7 @@ fn structFieldVal(
2699126990
26992 const field_ty = struct_type.field_types.get(ip)[field_index].toType();26991 const field_ty = struct_type.field_types.get(ip)[field_index].toType();
2699326992
26994 if (try sema.resolveMaybeUndefVal(struct_byval)) |struct_val| {26993 if (try sema.resolveValue(struct_byval)) |struct_val| {
26995 if (struct_val.isUndef(mod)) return mod.undefRef(field_ty);26994 if (struct_val.isUndef(mod)) return mod.undefRef(field_ty);
26996 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {26995 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
26997 return Air.internedToRef(opv.toIntern());26996 return Air.internedToRef(opv.toIntern());
...@@ -27069,7 +27068,7 @@ fn tupleFieldValByIndex(...@@ -27069,7 +27068,7 @@ fn tupleFieldValByIndex(
27069 return Air.internedToRef(default_value.toIntern());27068 return Air.internedToRef(default_value.toIntern());
27070 }27069 }
2707127070
27072 if (try sema.resolveMaybeUndefVal(tuple_byval)) |tuple_val| {27071 if (try sema.resolveValue(tuple_byval)) |tuple_val| {
27073 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {27072 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
27074 return Air.internedToRef(opv.toIntern());27073 return Air.internedToRef(opv.toIntern());
27075 }27074 }
...@@ -27221,7 +27220,7 @@ fn unionFieldVal(...@@ -27221,7 +27220,7 @@ fn unionFieldVal(
27221 const field_ty = union_obj.field_types.get(ip)[field_index].toType();27220 const field_ty = union_obj.field_types.get(ip)[field_index].toType();
27222 const enum_field_index: u32 = @intCast(union_obj.enum_tag_ty.toType().enumFieldIndex(field_name, mod).?);27221 const enum_field_index: u32 = @intCast(union_obj.enum_tag_ty.toType().enumFieldIndex(field_name, mod).?);
2722327222
27224 if (try sema.resolveMaybeUndefVal(union_byval)) |union_val| {27223 if (try sema.resolveValue(union_byval)) |union_val| {
27225 if (union_val.isUndef(mod)) return mod.undefRef(field_ty);27224 if (union_val.isUndef(mod)) return mod.undefRef(field_ty);
2722627225
27227 const un = ip.indexToKey(union_val.toIntern()).un;27226 const un = ip.indexToKey(union_val.toIntern()).un;
...@@ -27303,7 +27302,7 @@ fn elemPtr(...@@ -27303,7 +27302,7 @@ fn elemPtr(
27303 .Array, .Vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),27302 .Array, .Vector => try sema.elemPtrArray(block, src, indexable_ptr_src, indexable_ptr, elem_index_src, elem_index, init, oob_safety),
27304 .Struct => blk: {27303 .Struct => blk: {
27305 // Tuple field access.27304 // Tuple field access.
27306 const index_val = try sema.resolveConstValue(block, elem_index_src, elem_index, .{27305 const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{
27307 .needed_comptime_reason = "tuple field access index must be comptime-known",27306 .needed_comptime_reason = "tuple field access index must be comptime-known",
27308 });27307 });
27309 const index: u32 = @intCast(index_val.toUnsignedInt(mod));27308 const index: u32 = @intCast(index_val.toUnsignedInt(mod));
...@@ -27360,7 +27359,7 @@ fn elemPtrOneLayerOnly(...@@ -27360,7 +27359,7 @@ fn elemPtrOneLayerOnly(
27360 .Array, .Vector => try sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety),27359 .Array, .Vector => try sema.elemPtrArray(block, src, indexable_src, indexable, elem_index_src, elem_index, init, oob_safety),
27361 .Struct => blk: {27360 .Struct => blk: {
27362 assert(child_ty.isTuple(mod));27361 assert(child_ty.isTuple(mod));
27363 const index_val = try sema.resolveConstValue(block, elem_index_src, elem_index, .{27362 const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{
27364 .needed_comptime_reason = "tuple field access index must be comptime-known",27363 .needed_comptime_reason = "tuple field access index must be comptime-known",
27365 });27364 });
27366 const index: u32 = @intCast(index_val.toUnsignedInt(mod));27365 const index: u32 = @intCast(index_val.toUnsignedInt(mod));
...@@ -27439,7 +27438,7 @@ fn elemVal(...@@ -27439,7 +27438,7 @@ fn elemVal(
27439 },27438 },
27440 .Struct => {27439 .Struct => {
27441 // Tuple field access.27440 // Tuple field access.
27442 const index_val = try sema.resolveConstValue(block, elem_index_src, elem_index, .{27441 const index_val = try sema.resolveConstDefinedValue(block, elem_index_src, elem_index, .{
27443 .needed_comptime_reason = "tuple field access index must be comptime-known",27442 .needed_comptime_reason = "tuple field access index must be comptime-known",
27444 });27443 });
27445 const index: u32 = @intCast(index_val.toUnsignedInt(mod));27444 const index: u32 = @intCast(index_val.toUnsignedInt(mod));
...@@ -27519,7 +27518,7 @@ fn tupleFieldPtr(...@@ -27519,7 +27518,7 @@ fn tupleFieldPtr(
27519 } })));27518 } })));
27520 }27519 }
2752127520
27522 if (try sema.resolveMaybeUndefVal(tuple_ptr)) |tuple_ptr_val| {27521 if (try sema.resolveValue(tuple_ptr)) |tuple_ptr_val| {
27523 return Air.internedToRef((try mod.intern(.{ .ptr = .{27522 return Air.internedToRef((try mod.intern(.{ .ptr = .{
27524 .ty = ptr_field_ty.toIntern(),27523 .ty = ptr_field_ty.toIntern(),
27525 .addr = .{ .field = .{27524 .addr = .{ .field = .{
...@@ -27566,7 +27565,7 @@ fn tupleField(...@@ -27566,7 +27565,7 @@ fn tupleField(
27566 return Air.internedToRef(default_value.toIntern()); // comptime field27565 return Air.internedToRef(default_value.toIntern()); // comptime field
27567 }27566 }
2756827567
27569 if (try sema.resolveMaybeUndefVal(tuple)) |tuple_val| {27568 if (try sema.resolveValue(tuple)) |tuple_val| {
27570 if (tuple_val.isUndef(mod)) return mod.undefRef(field_ty);27569 if (tuple_val.isUndef(mod)) return mod.undefRef(field_ty);
27571 return Air.internedToRef((try tuple_val.fieldValue(mod, field_index)).toIntern());27570 return Air.internedToRef((try tuple_val.fieldValue(mod, field_index)).toIntern());
27572 }27571 }
...@@ -27599,7 +27598,7 @@ fn elemValArray(...@@ -27599,7 +27598,7 @@ fn elemValArray(
27599 return sema.fail(block, array_src, "indexing into empty array is not allowed", .{});27598 return sema.fail(block, array_src, "indexing into empty array is not allowed", .{});
27600 }27599 }
2760127600
27602 const maybe_undef_array_val = try sema.resolveMaybeUndefVal(array);27601 const maybe_undef_array_val = try sema.resolveValue(array);
27603 // index must be defined since it can access out of bounds27602 // index must be defined since it can access out of bounds
27604 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);27603 const maybe_index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index);
2760527604
...@@ -27664,7 +27663,7 @@ fn elemPtrArray(...@@ -27664,7 +27663,7 @@ fn elemPtrArray(
27664 return sema.fail(block, array_ptr_src, "indexing into empty array is not allowed", .{});27663 return sema.fail(block, array_ptr_src, "indexing into empty array is not allowed", .{});
27665 }27664 }
2766627665
27667 const maybe_undef_array_ptr_val = try sema.resolveMaybeUndefVal(array_ptr);27666 const maybe_undef_array_ptr_val = try sema.resolveValue(array_ptr);
27668 // The index must not be undefined since it can be out of bounds.27667 // The index must not be undefined since it can be out of bounds.
27669 const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {27668 const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
27670 const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(mod));27669 const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(mod));
...@@ -27776,7 +27775,7 @@ fn elemPtrSlice(...@@ -27776,7 +27775,7 @@ fn elemPtrSlice(
27776 const slice_ty = sema.typeOf(slice);27775 const slice_ty = sema.typeOf(slice);
27777 const slice_sent = slice_ty.sentinel(mod) != null;27776 const slice_sent = slice_ty.sentinel(mod) != null;
2777827777
27779 const maybe_undef_slice_val = try sema.resolveMaybeUndefVal(slice);27778 const maybe_undef_slice_val = try sema.resolveValue(slice);
27780 // The index must not be undefined since it can be out of bounds.27779 // The index must not be undefined since it can be out of bounds.
27781 const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {27780 const offset: ?usize = if (try sema.resolveDefinedValue(block, elem_index_src, elem_index)) |index_val| o: {
27782 const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(mod));27781 const index = try sema.usizeCast(block, elem_index_src, index_val.toUnsignedInt(mod));
...@@ -27888,7 +27887,7 @@ fn coerceExtra(...@@ -27888,7 +27887,7 @@ fn coerceExtra(
27888 if (dest_ty.eql(inst_ty, mod))27887 if (dest_ty.eql(inst_ty, mod))
27889 return inst;27888 return inst;
2789027889
27891 const maybe_inst_val = try sema.resolveMaybeUndefVal(inst);27890 const maybe_inst_val = try sema.resolveValue(inst);
2789227891
27893 var in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src);27892 var in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src);
27894 if (in_memory_result == .ok) {27893 if (in_memory_result == .ok) {
...@@ -27958,7 +27957,7 @@ fn coerceExtra(...@@ -27958,7 +27957,7 @@ fn coerceExtra(
2795827957
27959 // Function body to function pointer.27958 // Function body to function pointer.
27960 if (inst_ty.zigTypeTag(mod) == .Fn) {27959 if (inst_ty.zigTypeTag(mod) == .Fn) {
27961 const fn_val = try sema.resolveConstValue(block, .unneeded, inst, undefined);27960 const fn_val = try sema.resolveConstDefinedValue(block, .unneeded, inst, undefined);
27962 const fn_decl = fn_val.pointerDecl(mod).?;27961 const fn_decl = fn_val.pointerDecl(mod).?;
27963 const inst_as_ptr = try sema.analyzeDeclRef(fn_decl);27962 const inst_as_ptr = try sema.analyzeDeclRef(fn_decl);
27964 return sema.coerce(block, dest_ty, inst_as_ptr, inst_src);27963 return sema.coerce(block, dest_ty, inst_as_ptr, inst_src);
...@@ -28303,7 +28302,7 @@ fn coerceExtra(...@@ -28303,7 +28302,7 @@ fn coerceExtra(
28303 },28302 },
28304 .Float, .ComptimeFloat => switch (inst_ty.zigTypeTag(mod)) {28303 .Float, .ComptimeFloat => switch (inst_ty.zigTypeTag(mod)) {
28305 .ComptimeFloat => {28304 .ComptimeFloat => {
28306 const val = try sema.resolveConstValue(block, .unneeded, inst, undefined);28305 const val = try sema.resolveConstDefinedValue(block, .unneeded, inst, undefined);
28307 const result_val = try val.floatCast(dest_ty, mod);28306 const result_val = try val.floatCast(dest_ty, mod);
28308 return Air.internedToRef(result_val.toIntern());28307 return Air.internedToRef(result_val.toIntern());
28309 },28308 },
...@@ -28362,7 +28361,7 @@ fn coerceExtra(...@@ -28362,7 +28361,7 @@ fn coerceExtra(
28362 .Enum => switch (inst_ty.zigTypeTag(mod)) {28361 .Enum => switch (inst_ty.zigTypeTag(mod)) {
28363 .EnumLiteral => {28362 .EnumLiteral => {
28364 // enum literal to enum28363 // enum literal to enum
28365 const val = try sema.resolveConstValue(block, .unneeded, inst, undefined);28364 const val = try sema.resolveConstDefinedValue(block, .unneeded, inst, undefined);
28366 const string = mod.intern_pool.indexToKey(val.toIntern()).enum_literal;28365 const string = mod.intern_pool.indexToKey(val.toIntern()).enum_literal;
28367 const field_index = dest_ty.enumFieldIndex(string, mod) orelse {28366 const field_index = dest_ty.enumFieldIndex(string, mod) orelse {
28368 const msg = msg: {28367 const msg = msg: {
...@@ -29490,7 +29489,7 @@ fn coerceVarArgParam(...@@ -29490,7 +29489,7 @@ fn coerceVarArgParam(
29490 .{},29489 .{},
29491 ),29490 ),
29492 .Fn => blk: {29491 .Fn => blk: {
29493 const fn_val = try sema.resolveConstValue(block, .unneeded, inst, undefined);29492 const fn_val = try sema.resolveConstDefinedValue(block, .unneeded, inst, undefined);
29494 const fn_decl = fn_val.pointerDecl(mod).?;29493 const fn_decl = fn_val.pointerDecl(mod).?;
29495 break :blk try sema.analyzeDeclRef(fn_decl);29494 break :blk try sema.analyzeDeclRef(fn_decl);
29496 },29495 },
...@@ -29602,7 +29601,7 @@ fn storePtr2(...@@ -29602,7 +29601,7 @@ fn storePtr2(
29602 error.NotCoercible => unreachable,29601 error.NotCoercible => unreachable,
29603 else => |e| return e,29602 else => |e| return e,
29604 };29603 };
29605 const maybe_operand_val = try sema.resolveMaybeUndefVal(operand);29604 const maybe_operand_val = try sema.resolveValue(operand);
2960629605
29607 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {29606 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
29608 const operand_val = maybe_operand_val orelse {29607 const operand_val = maybe_operand_val orelse {
...@@ -29670,7 +29669,7 @@ fn checkComptimeKnownStore(sema: *Sema, block: *Block, store_inst_ref: Air.Inst....@@ -29670,7 +29669,7 @@ fn checkComptimeKnownStore(sema: *Sema, block: *Block, store_inst_ref: Air.Inst.
29670 const maybe_comptime_alloc = sema.maybe_comptime_allocs.getPtr(maybe_base_alloc) orelse return;29669 const maybe_comptime_alloc = sema.maybe_comptime_allocs.getPtr(maybe_base_alloc) orelse return;
2967129670
29672 ct: {29671 ct: {
29673 if (null == try sema.resolveMaybeUndefVal(operand)) break :ct;29672 if (null == try sema.resolveValue(operand)) break :ct;
29674 if (maybe_comptime_alloc.runtime_index != block.runtime_index) break :ct;29673 if (maybe_comptime_alloc.runtime_index != block.runtime_index) break :ct;
29675 return maybe_comptime_alloc.stores.append(sema.arena, store_inst);29674 return maybe_comptime_alloc.stores.append(sema.arena, store_inst);
29676 }29675 }
...@@ -29701,7 +29700,7 @@ fn checkKnownAllocPtr(sema: *Sema, base_ptr: Air.Inst.Ref, new_ptr: Air.Inst.Ref...@@ -29701,7 +29700,7 @@ fn checkKnownAllocPtr(sema: *Sema, base_ptr: Air.Inst.Ref, new_ptr: Air.Inst.Ref
2970129700
29702 // If the index value is runtime-known, this pointer is also runtime-known, so29701 // If the index value is runtime-known, this pointer is also runtime-known, so
29703 // we must in turn make the alloc value runtime-known.29702 // we must in turn make the alloc value runtime-known.
29704 if (null == try sema.resolveMaybeUndefVal(index_ref)) {29703 if (null == try sema.resolveValue(index_ref)) {
29705 _ = sema.maybe_comptime_allocs.remove(alloc_inst);29704 _ = sema.maybe_comptime_allocs.remove(alloc_inst);
29706 }29705 }
29707 },29706 },
...@@ -30711,7 +30710,7 @@ fn bitCast(...@@ -30711,7 +30710,7 @@ fn bitCast(
30711 });30710 });
30712 }30711 }
3071330712
30714 if (try sema.resolveMaybeUndefVal(inst)) |val| {30713 if (try sema.resolveValue(inst)) |val| {
30715 if (try sema.bitCastVal(block, inst_src, val, old_ty, dest_ty, 0)) |result_val| {30714 if (try sema.bitCastVal(block, inst_src, val, old_ty, dest_ty, 0)) |result_val| {
30716 return Air.internedToRef(result_val.toIntern());30715 return Air.internedToRef(result_val.toIntern());
30717 }30716 }
...@@ -30817,7 +30816,7 @@ fn coerceArrayPtrToSlice(...@@ -30817,7 +30816,7 @@ fn coerceArrayPtrToSlice(
30817 inst_src: LazySrcLoc,30816 inst_src: LazySrcLoc,
30818) CompileError!Air.Inst.Ref {30817) CompileError!Air.Inst.Ref {
30819 const mod = sema.mod;30818 const mod = sema.mod;
30820 if (try sema.resolveMaybeUndefVal(inst)) |val| {30819 if (try sema.resolveValue(inst)) |val| {
30821 const ptr_array_ty = sema.typeOf(inst);30820 const ptr_array_ty = sema.typeOf(inst);
30822 const array_ty = ptr_array_ty.childType(mod);30821 const array_ty = ptr_array_ty.childType(mod);
30823 const slice_val = try mod.intern(.{ .ptr = .{30822 const slice_val = try mod.intern(.{ .ptr = .{
...@@ -30895,7 +30894,7 @@ fn coerceCompatiblePtrs(...@@ -30895,7 +30894,7 @@ fn coerceCompatiblePtrs(
30895) !Air.Inst.Ref {30894) !Air.Inst.Ref {
30896 const mod = sema.mod;30895 const mod = sema.mod;
30897 const inst_ty = sema.typeOf(inst);30896 const inst_ty = sema.typeOf(inst);
30898 if (try sema.resolveMaybeUndefVal(inst)) |val| {30897 if (try sema.resolveValue(inst)) |val| {
30899 if (!val.isUndef(mod) and val.isNull(mod) and !dest_ty.isAllowzeroPtr(mod)) {30898 if (!val.isUndef(mod) and val.isNull(mod) and !dest_ty.isAllowzeroPtr(mod)) {
30900 return sema.fail(block, inst_src, "null pointer casted to type '{}'", .{dest_ty.fmt(sema.mod)});30899 return sema.fail(block, inst_src, "null pointer casted to type '{}'", .{dest_ty.fmt(sema.mod)});
30901 }30900 }
...@@ -31178,7 +31177,7 @@ fn coerceArrayLike(...@@ -31178,7 +31177,7 @@ fn coerceArrayLike(
31178 // try coercion of the whole array31177 // try coercion of the whole array
31179 const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src);31178 const in_memory_result = try sema.coerceInMemoryAllowed(block, dest_ty, inst_ty, false, target, dest_ty_src, inst_src);
31180 if (in_memory_result == .ok) {31179 if (in_memory_result == .ok) {
31181 if (try sema.resolveMaybeUndefVal(inst)) |inst_val| {31180 if (try sema.resolveValue(inst)) |inst_val| {
31182 // These types share the same comptime value representation.31181 // These types share the same comptime value representation.
31183 return sema.coerceInMemory(inst_val, dest_ty);31182 return sema.coerceInMemory(inst_val, dest_ty);
31184 }31183 }
...@@ -31215,7 +31214,7 @@ fn coerceArrayLike(...@@ -31215,7 +31214,7 @@ fn coerceArrayLike(
31215 const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);31214 const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);
31216 ref.* = coerced;31215 ref.* = coerced;
31217 if (runtime_src == null) {31216 if (runtime_src == null) {
31218 if (try sema.resolveMaybeUndefVal(coerced)) |elem_val| {31217 if (try sema.resolveValue(coerced)) |elem_val| {
31219 val.* = try elem_val.intern(dest_elem_ty, mod);31218 val.* = try elem_val.intern(dest_elem_ty, mod);
31220 } else {31219 } else {
31221 runtime_src = elem_src;31220 runtime_src = elem_src;
...@@ -31280,7 +31279,7 @@ fn coerceTupleToArray(...@@ -31280,7 +31279,7 @@ fn coerceTupleToArray(
31280 const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);31279 const coerced = try sema.coerce(block, dest_elem_ty, elem_ref, elem_src);
31281 ref.* = coerced;31280 ref.* = coerced;
31282 if (runtime_src == null) {31281 if (runtime_src == null) {
31283 if (try sema.resolveMaybeUndefVal(coerced)) |elem_val| {31282 if (try sema.resolveValue(coerced)) |elem_val| {
31284 val.* = try elem_val.intern(dest_elem_ty, mod);31283 val.* = try elem_val.intern(dest_elem_ty, mod);
31285 } else {31284 } else {
31286 runtime_src = elem_src;31285 runtime_src = elem_src;
...@@ -31393,7 +31392,7 @@ fn coerceTupleToStruct(...@@ -31393,7 +31392,7 @@ fn coerceTupleToStruct(
31393 const coerced = try sema.coerce(block, field_ty, elem_ref, field_src);31392 const coerced = try sema.coerce(block, field_ty, elem_ref, field_src);
31394 field_refs[field_index] = coerced;31393 field_refs[field_index] = coerced;
31395 if (struct_type.fieldIsComptime(ip, field_index)) {31394 if (struct_type.fieldIsComptime(ip, field_index)) {
31396 const init_val = (try sema.resolveMaybeUndefVal(coerced)) orelse {31395 const init_val = (try sema.resolveValue(coerced)) orelse {
31397 return sema.failWithNeededComptime(block, field_src, .{31396 return sema.failWithNeededComptime(block, field_src, .{
31398 .needed_comptime_reason = "value stored in comptime field must be comptime-known",31397 .needed_comptime_reason = "value stored in comptime field must be comptime-known",
31399 });31398 });
...@@ -31405,7 +31404,7 @@ fn coerceTupleToStruct(...@@ -31405,7 +31404,7 @@ fn coerceTupleToStruct(
31405 }31404 }
31406 }31405 }
31407 if (runtime_src == null) {31406 if (runtime_src == null) {
31408 if (try sema.resolveMaybeUndefVal(coerced)) |field_val| {31407 if (try sema.resolveValue(coerced)) |field_val| {
31409 field_vals[field_index] = field_val.toIntern();31408 field_vals[field_index] = field_val.toIntern();
31410 } else {31409 } else {
31411 runtime_src = field_src;31410 runtime_src = field_src;
...@@ -31521,7 +31520,7 @@ fn coerceTupleToTuple(...@@ -31521,7 +31520,7 @@ fn coerceTupleToTuple(
31521 const coerced = try sema.coerce(block, field_ty.toType(), elem_ref, field_src);31520 const coerced = try sema.coerce(block, field_ty.toType(), elem_ref, field_src);
31522 field_refs[field_index] = coerced;31521 field_refs[field_index] = coerced;
31523 if (default_val != .none) {31522 if (default_val != .none) {
31524 const init_val = (try sema.resolveMaybeUndefVal(coerced)) orelse {31523 const init_val = (try sema.resolveValue(coerced)) orelse {
31525 return sema.failWithNeededComptime(block, field_src, .{31524 return sema.failWithNeededComptime(block, field_src, .{
31526 .needed_comptime_reason = "value stored in comptime field must be comptime-known",31525 .needed_comptime_reason = "value stored in comptime field must be comptime-known",
31527 });31526 });
...@@ -31532,7 +31531,7 @@ fn coerceTupleToTuple(...@@ -31532,7 +31531,7 @@ fn coerceTupleToTuple(
31532 }31531 }
31533 }31532 }
31534 if (runtime_src == null) {31533 if (runtime_src == null) {
31535 if (try sema.resolveMaybeUndefVal(coerced)) |field_val| {31534 if (try sema.resolveValue(coerced)) |field_val| {
31536 field_vals[field_index] = field_val.toIntern();31535 field_vals[field_index] = field_val.toIntern();
31537 } else {31536 } else {
31538 runtime_src = field_src;31537 runtime_src = field_src;
...@@ -31753,7 +31752,7 @@ fn analyzeRef(...@@ -31753,7 +31752,7 @@ fn analyzeRef(
31753 const mod = sema.mod;31752 const mod = sema.mod;
31754 const operand_ty = sema.typeOf(operand);31753 const operand_ty = sema.typeOf(operand);
3175531754
31756 if (try sema.resolveMaybeUndefVal(operand)) |val| {31755 if (try sema.resolveValue(operand)) |val| {
31757 switch (mod.intern_pool.indexToKey(val.toIntern())) {31756 switch (mod.intern_pool.indexToKey(val.toIntern())) {
31758 .extern_func => |extern_func| return sema.analyzeDeclRef(extern_func.decl),31757 .extern_func => |extern_func| return sema.analyzeDeclRef(extern_func.decl),
31759 .func => |func| return sema.analyzeDeclRef(func.owner_decl),31758 .func => |func| return sema.analyzeDeclRef(func.owner_decl),
...@@ -31840,7 +31839,7 @@ fn analyzeSlicePtr(...@@ -31840,7 +31839,7 @@ fn analyzeSlicePtr(
31840) CompileError!Air.Inst.Ref {31839) CompileError!Air.Inst.Ref {
31841 const mod = sema.mod;31840 const mod = sema.mod;
31842 const result_ty = slice_ty.slicePtrFieldType(mod);31841 const result_ty = slice_ty.slicePtrFieldType(mod);
31843 if (try sema.resolveMaybeUndefVal(slice)) |val| {31842 if (try sema.resolveValue(slice)) |val| {
31844 if (val.isUndef(mod)) return mod.undefRef(result_ty);31843 if (val.isUndef(mod)) return mod.undefRef(result_ty);
31845 return Air.internedToRef(val.slicePtr(mod).toIntern());31844 return Air.internedToRef(val.slicePtr(mod).toIntern());
31846 }31845 }
...@@ -31855,7 +31854,7 @@ fn analyzeSliceLen(...@@ -31855,7 +31854,7 @@ fn analyzeSliceLen(
31855 slice_inst: Air.Inst.Ref,31854 slice_inst: Air.Inst.Ref,
31856) CompileError!Air.Inst.Ref {31855) CompileError!Air.Inst.Ref {
31857 const mod = sema.mod;31856 const mod = sema.mod;
31858 if (try sema.resolveMaybeUndefVal(slice_inst)) |slice_val| {31857 if (try sema.resolveValue(slice_inst)) |slice_val| {
31859 if (slice_val.isUndef(mod)) {31858 if (slice_val.isUndef(mod)) {
31860 return mod.undefRef(Type.usize);31859 return mod.undefRef(Type.usize);
31861 }31860 }
...@@ -31874,7 +31873,7 @@ fn analyzeIsNull(...@@ -31874,7 +31873,7 @@ fn analyzeIsNull(
31874) CompileError!Air.Inst.Ref {31873) CompileError!Air.Inst.Ref {
31875 const mod = sema.mod;31874 const mod = sema.mod;
31876 const result_ty = Type.bool;31875 const result_ty = Type.bool;
31877 if (try sema.resolveMaybeUndefVal(operand)) |opt_val| {31876 if (try sema.resolveValue(operand)) |opt_val| {
31878 if (opt_val.isUndef(mod)) {31877 if (opt_val.isUndef(mod)) {
31879 return mod.undefRef(result_ty);31878 return mod.undefRef(result_ty);
31880 }31879 }
...@@ -31950,7 +31949,7 @@ fn analyzeIsNonErrComptimeOnly(...@@ -31950,7 +31949,7 @@ fn analyzeIsNonErrComptimeOnly(
31950 return .bool_true;31949 return .bool_true;
31951 }31950 }
3195231951
31953 const maybe_operand_val = try sema.resolveMaybeUndefVal(operand);31952 const maybe_operand_val = try sema.resolveValue(operand);
3195431953
31955 // exception if the error union error set is known to be empty,31954 // exception if the error union error set is known to be empty,
31956 // we allow the comparison but always make it comptime-known.31955 // we allow the comparison but always make it comptime-known.
...@@ -32171,7 +32170,7 @@ fn analyzeSlice(...@@ -32171,7 +32170,7 @@ fn analyzeSlice(
32171 const uncasted_end = try sema.analyzeArithmetic(block, .add, start, len, src, start_src, end_src, false);32170 const uncasted_end = try sema.analyzeArithmetic(block, .add, start, len, src, start_src, end_src, false);
32172 break :end try sema.coerce(block, Type.usize, uncasted_end, end_src);32171 break :end try sema.coerce(block, Type.usize, uncasted_end, end_src);
32173 } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src);32172 } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src);
32174 if (try sema.resolveMaybeUndefVal(end)) |end_val| {32173 if (try sema.resolveValue(end)) |end_val| {
32175 const len_s_val = try mod.intValue(32174 const len_s_val = try mod.intValue(
32176 Type.usize,32175 Type.usize,
32177 array_ty.arrayLenIncludingSentinel(mod),32176 array_ty.arrayLenIncludingSentinel(mod),
...@@ -32213,7 +32212,7 @@ fn analyzeSlice(...@@ -32213,7 +32212,7 @@ fn analyzeSlice(
32213 break :end try sema.coerce(block, Type.usize, uncasted_end, end_src);32212 break :end try sema.coerce(block, Type.usize, uncasted_end, end_src);
32214 } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src);32213 } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src);
32215 if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| {32214 if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| {
32216 if (try sema.resolveMaybeUndefVal(ptr_or_slice)) |slice_val| {32215 if (try sema.resolveValue(ptr_or_slice)) |slice_val| {
32217 if (slice_val.isUndef(mod)) {32216 if (slice_val.isUndef(mod)) {
32218 return sema.fail(block, src, "slice of undefined", .{});32217 return sema.fail(block, src, "slice of undefined", .{});
32219 }32218 }
...@@ -32265,7 +32264,7 @@ fn analyzeSlice(...@@ -32265,7 +32264,7 @@ fn analyzeSlice(
32265 const sentinel = s: {32264 const sentinel = s: {
32266 if (sentinel_opt != .none) {32265 if (sentinel_opt != .none) {
32267 const casted = try sema.coerce(block, elem_ty, sentinel_opt, sentinel_src);32266 const casted = try sema.coerce(block, elem_ty, sentinel_opt, sentinel_src);
32268 break :s try sema.resolveConstValue(block, sentinel_src, casted, .{32267 break :s try sema.resolveConstDefinedValue(block, sentinel_src, casted, .{
32269 .needed_comptime_reason = "slice sentinel must be comptime-known",32268 .needed_comptime_reason = "slice sentinel must be comptime-known",
32270 });32269 });
32271 }32270 }
...@@ -32298,7 +32297,7 @@ fn analyzeSlice(...@@ -32298,7 +32297,7 @@ fn analyzeSlice(
32298 );32297 );
32299 }32298 }
32300 checked_start_lte_end = true;32299 checked_start_lte_end = true;
32301 if (try sema.resolveMaybeUndefVal(new_ptr)) |ptr_val| sentinel_check: {32300 if (try sema.resolveValue(new_ptr)) |ptr_val| sentinel_check: {
32302 const expected_sentinel = sentinel orelse break :sentinel_check;32301 const expected_sentinel = sentinel orelse break :sentinel_check;
32303 const start_int = start_val.getUnsignedInt(mod).?;32302 const start_int = start_val.getUnsignedInt(mod).?;
32304 const end_int = end_val.getUnsignedInt(mod).?;32303 const end_int = end_val.getUnsignedInt(mod).?;
...@@ -32387,7 +32386,7 @@ fn analyzeSlice(...@@ -32387,7 +32386,7 @@ fn analyzeSlice(
32387 },32386 },
32388 });32387 });
3238932388
32390 const opt_new_ptr_val = try sema.resolveMaybeUndefVal(new_ptr);32389 const opt_new_ptr_val = try sema.resolveValue(new_ptr);
32391 const new_ptr_val = opt_new_ptr_val orelse {32390 const new_ptr_val = opt_new_ptr_val orelse {
32392 const result = try block.addBitCast(return_ty, new_ptr);32391 const result = try block.addBitCast(return_ty, new_ptr);
32393 if (block.wantSafety()) {32392 if (block.wantSafety()) {
...@@ -32534,8 +32533,8 @@ fn cmpNumeric(...@@ -32534,8 +32533,8 @@ fn cmpNumeric(
32534 uncasted_rhs;32533 uncasted_rhs;
3253532534
32536 const runtime_src: LazySrcLoc = src: {32535 const runtime_src: LazySrcLoc = src: {
32537 if (try sema.resolveMaybeUndefVal(lhs)) |lhs_val| {32536 if (try sema.resolveValue(lhs)) |lhs_val| {
32538 if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| {32537 if (try sema.resolveValue(rhs)) |rhs_val| {
32539 // Compare ints: const vs. undefined (or vice versa)32538 // Compare ints: const vs. undefined (or vice versa)
32540 if (!lhs_val.isUndef(mod) and (lhs_ty.isInt(mod) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(mod) and rhs_val.isUndef(mod)) {32539 if (!lhs_val.isUndef(mod) and (lhs_ty.isInt(mod) or lhs_ty_tag == .ComptimeInt) and rhs_ty.isInt(mod) and rhs_val.isUndef(mod)) {
32541 if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(lhs_val), op, rhs_ty)) |res| {32540 if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(lhs_val), op, rhs_ty)) |res| {
...@@ -32567,7 +32566,7 @@ fn cmpNumeric(...@@ -32567,7 +32566,7 @@ fn cmpNumeric(
32567 break :src rhs_src;32566 break :src rhs_src;
32568 }32567 }
32569 } else {32568 } else {
32570 if (try sema.resolveMaybeUndefLazyVal(rhs)) |rhs_val| {32569 if (try sema.resolveValueResolveLazy(rhs)) |rhs_val| {
32571 if (!rhs_val.isUndef(mod) and (rhs_ty.isInt(mod) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(mod)) {32570 if (!rhs_val.isUndef(mod) and (rhs_ty.isInt(mod) or rhs_ty_tag == .ComptimeInt) and lhs_ty.isInt(mod)) {
32572 // Compare ints: var vs. const32571 // Compare ints: var vs. const
32573 if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(rhs_val), op.reverse(), lhs_ty)) |res| {32572 if (try sema.compareIntsOnlyPossibleResult(try sema.resolveLazyValue(rhs_val), op.reverse(), lhs_ty)) |res| {
...@@ -32634,7 +32633,7 @@ fn cmpNumeric(...@@ -32634,7 +32633,7 @@ fn cmpNumeric(
32634 var dest_float_type: ?Type = null;32633 var dest_float_type: ?Type = null;
3263532634
32636 var lhs_bits: usize = undefined;32635 var lhs_bits: usize = undefined;
32637 if (try sema.resolveMaybeUndefLazyVal(lhs)) |lhs_val| {32636 if (try sema.resolveValueResolveLazy(lhs)) |lhs_val| {
32638 if (lhs_val.isUndef(mod))32637 if (lhs_val.isUndef(mod))
32639 return mod.undefRef(Type.bool);32638 return mod.undefRef(Type.bool);
32640 if (lhs_val.isNan(mod)) switch (op) {32639 if (lhs_val.isNan(mod)) switch (op) {
...@@ -32692,7 +32691,7 @@ fn cmpNumeric(...@@ -32692,7 +32691,7 @@ fn cmpNumeric(
32692 }32691 }
3269332692
32694 var rhs_bits: usize = undefined;32693 var rhs_bits: usize = undefined;
32695 if (try sema.resolveMaybeUndefLazyVal(rhs)) |rhs_val| {32694 if (try sema.resolveValueResolveLazy(rhs)) |rhs_val| {
32696 if (rhs_val.isUndef(mod))32695 if (rhs_val.isUndef(mod))
32697 return mod.undefRef(Type.bool);32696 return mod.undefRef(Type.bool);
32698 if (rhs_val.isNan(mod)) switch (op) {32697 if (rhs_val.isNan(mod)) switch (op) {
...@@ -32884,8 +32883,8 @@ fn cmpVector(...@@ -32884,8 +32883,8 @@ fn cmpVector(
32884 });32883 });
3288532884
32886 const runtime_src: LazySrcLoc = src: {32885 const runtime_src: LazySrcLoc = src: {
32887 if (try sema.resolveMaybeUndefVal(casted_lhs)) |lhs_val| {32886 if (try sema.resolveValue(casted_lhs)) |lhs_val| {
32888 if (try sema.resolveMaybeUndefVal(casted_rhs)) |rhs_val| {32887 if (try sema.resolveValue(casted_rhs)) |rhs_val| {
32889 if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {32888 if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
32890 return mod.undefRef(result_ty);32889 return mod.undefRef(result_ty);
32891 }32890 }
...@@ -32910,7 +32909,7 @@ fn wrapOptional(...@@ -32910,7 +32909,7 @@ fn wrapOptional(
32910 inst: Air.Inst.Ref,32909 inst: Air.Inst.Ref,
32911 inst_src: LazySrcLoc,32910 inst_src: LazySrcLoc,
32912) !Air.Inst.Ref {32911) !Air.Inst.Ref {
32913 if (try sema.resolveMaybeUndefVal(inst)) |val| {32912 if (try sema.resolveValue(inst)) |val| {
32914 return Air.internedToRef((try sema.mod.intern(.{ .opt = .{32913 return Air.internedToRef((try sema.mod.intern(.{ .opt = .{
32915 .ty = dest_ty.toIntern(),32914 .ty = dest_ty.toIntern(),
32916 .val = val.toIntern(),32915 .val = val.toIntern(),
...@@ -32931,7 +32930,7 @@ fn wrapErrorUnionPayload(...@@ -32931,7 +32930,7 @@ fn wrapErrorUnionPayload(
32931 const mod = sema.mod;32930 const mod = sema.mod;
32932 const dest_payload_ty = dest_ty.errorUnionPayload(mod);32931 const dest_payload_ty = dest_ty.errorUnionPayload(mod);
32933 const coerced = try sema.coerceExtra(block, dest_payload_ty, inst, inst_src, .{ .report_err = false });32932 const coerced = try sema.coerceExtra(block, dest_payload_ty, inst, inst_src, .{ .report_err = false });
32934 if (try sema.resolveMaybeUndefVal(coerced)) |val| {32933 if (try sema.resolveValue(coerced)) |val| {
32935 return Air.internedToRef((try mod.intern(.{ .error_union = .{32934 return Air.internedToRef((try mod.intern(.{ .error_union = .{
32936 .ty = dest_ty.toIntern(),32935 .ty = dest_ty.toIntern(),
32937 .val = .{ .payload = try val.intern(dest_payload_ty, mod) },32936 .val = .{ .payload = try val.intern(dest_payload_ty, mod) },
...@@ -32953,7 +32952,7 @@ fn wrapErrorUnionSet(...@@ -32953,7 +32952,7 @@ fn wrapErrorUnionSet(
32953 const ip = &mod.intern_pool;32952 const ip = &mod.intern_pool;
32954 const inst_ty = sema.typeOf(inst);32953 const inst_ty = sema.typeOf(inst);
32955 const dest_err_set_ty = dest_ty.errorUnionSet(mod);32954 const dest_err_set_ty = dest_ty.errorUnionSet(mod);
32956 if (try sema.resolveMaybeUndefVal(inst)) |val| {32955 if (try sema.resolveValue(inst)) |val| {
32957 const expected_name = mod.intern_pool.indexToKey(val.toIntern()).err.name;32956 const expected_name = mod.intern_pool.indexToKey(val.toIntern()).err.name;
32958 switch (dest_err_set_ty.toIntern()) {32957 switch (dest_err_set_ty.toIntern()) {
32959 .anyerror_type => {},32958 .anyerror_type => {},
...@@ -33015,7 +33014,7 @@ fn unionToTag(...@@ -33015,7 +33014,7 @@ fn unionToTag(
33015 if ((try sema.typeHasOnePossibleValue(enum_ty))) |opv| {33014 if ((try sema.typeHasOnePossibleValue(enum_ty))) |opv| {
33016 return Air.internedToRef(opv.toIntern());33015 return Air.internedToRef(opv.toIntern());
33017 }33016 }
33018 if (try sema.resolveMaybeUndefVal(un)) |un_val| {33017 if (try sema.resolveValue(un)) |un_val| {
33019 return Air.internedToRef(un_val.unionTag(mod).?.toIntern());33018 return Air.internedToRef(un_val.unionTag(mod).?.toIntern());
33020 }33019 }
33021 try sema.requireRuntimeBlock(block, un_src, null);33020 try sema.requireRuntimeBlock(block, un_src, null);
...@@ -33324,7 +33323,7 @@ fn resolvePeerTypes(...@@ -33324,7 +33323,7 @@ fn resolvePeerTypes(
3332433323
33325 for (instructions, peer_tys, peer_vals) |inst, *ty, *val| {33324 for (instructions, peer_tys, peer_vals) |inst, *ty, *val| {
33326 ty.* = sema.typeOf(inst);33325 ty.* = sema.typeOf(inst);
33327 val.* = try sema.resolveMaybeUndefVal(inst);33326 val.* = try sema.resolveValue(inst);
33328 }33327 }
3332933328
33330 switch (try sema.resolvePeerTypesInner(block, src, peer_tys, peer_vals)) {33329 switch (try sema.resolvePeerTypesInner(block, src, peer_tys, peer_vals)) {
...@@ -34379,7 +34378,7 @@ fn resolvePeerTypesInner(...@@ -34379,7 +34378,7 @@ fn resolvePeerTypesInner(
34379 },34378 },
34380 else => |e| return e,34379 else => |e| return e,
34381 };34380 };
34382 const coerced_val = (try sema.resolveMaybeUndefVal(coerced_inst)) orelse continue;34381 const coerced_val = (try sema.resolveValue(coerced_inst)) orelse continue;
34383 const existing = comptime_val orelse {34382 const existing = comptime_val orelse {
34384 comptime_val = coerced_val;34383 comptime_val = coerced_val;
34385 continue;34384 continue;
...@@ -35827,7 +35826,7 @@ fn semaStructFields(...@@ -35827,7 +35826,7 @@ fn semaStructFields(
35827 },35826 },
35828 else => |e| return e,35827 else => |e| return e,
35829 };35828 };
35830 const default_val = (try sema.resolveMaybeUndefVal(coerced)) orelse {35829 const default_val = (try sema.resolveValue(coerced)) orelse {
35831 const init_src = mod.fieldSrcLoc(decl_index, .{35830 const init_src = mod.fieldSrcLoc(decl_index, .{
35832 .index = field_i,35831 .index = field_i,
35833 .range = .value,35832 .range = .value,
...@@ -36270,7 +36269,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Key.Un...@@ -36270,7 +36269,7 @@ fn semaUnionFields(mod: *Module, arena: Allocator, union_type: InternPool.Key.Un
3627036269
36271fn semaUnionFieldVal(sema: *Sema, block: *Block, src: LazySrcLoc, int_tag_ty: Type, tag_ref: Air.Inst.Ref) CompileError!Value {36270fn semaUnionFieldVal(sema: *Sema, block: *Block, src: LazySrcLoc, int_tag_ty: Type, tag_ref: Air.Inst.Ref) CompileError!Value {
36272 const coerced = try sema.coerce(block, int_tag_ty, tag_ref, src);36271 const coerced = try sema.coerce(block, int_tag_ty, tag_ref, src);
36273 return sema.resolveConstValue(block, src, coerced, .{36272 return sema.resolveConstDefinedValue(block, src, coerced, .{
36274 .needed_comptime_reason = "enum tag value must be comptime-known",36273 .needed_comptime_reason = "enum tag value must be comptime-known",
36275 });36274 });
36276}36275}
...@@ -36828,7 +36827,7 @@ fn isComptimeKnown(...@@ -36828,7 +36827,7 @@ fn isComptimeKnown(
36828 sema: *Sema,36827 sema: *Sema,
36829 inst: Air.Inst.Ref,36828 inst: Air.Inst.Ref,
36830) !bool {36829) !bool {
36831 return (try sema.resolveMaybeUndefVal(inst)) != null;36830 return (try sema.resolveValue(inst)) != null;
36832}36831}
3683336832
36834fn analyzeComptimeAlloc(36833fn analyzeComptimeAlloc(