authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-06-23 16:28:33-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-06-23 21:59:42-07:00
log5288929ffd91c1fdc2237bb2574e0e0afbbc60eb
treedd510e2915d4bc234f745e1a2467bcaef31da3d3
parent5fc5e4fbe04ccbe5ea37b07c1153a7c5bd2b4346

sema.addConstant: remove type parameter

Now that InternPool migration is finished, all values have types. So only the value parameter is required.

2 files changed, 269 insertions(+), 335 deletions(-)

src/Module.zig+2-2
......@@ -5503,7 +5503,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: Fn.Index, arena: Allocator) SemaE
55035503 else
55045504 break :t arg_tv.ty;
55055505
5506 const arg = try sema.addConstant(arg_tv.ty, arg_val);
5506 const arg = try sema.addConstant(arg_val);
55075507 sema.inst_map.putAssumeCapacityNoClobber(inst, arg);
55085508 total_param_index += 1;
55095509 continue;
......@@ -5517,7 +5517,7 @@ pub fn analyzeFnBody(mod: *Module, func_index: Fn.Index, arena: Allocator) SemaE
55175517 else => |e| return e,
55185518 };
55195519 if (opt_opv) |opv| {
5520 const arg = try sema.addConstant(param_ty, opv);
5520 const arg = try sema.addConstant(opv);
55215521 sema.inst_map.putAssumeCapacityNoClobber(inst, arg);
55225522 total_param_index += 1;
55235523 runtime_param_index += 1;
src/Sema.zig+267-333
......@@ -2568,7 +2568,7 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
25682568 });
25692569 try sema.maybeQueueFuncBodyAnalysis(decl_index);
25702570 try sema.comptime_mutable_decls.append(decl_index);
2571 return sema.addConstant(ptr_ty, (try mod.intern(.{ .ptr = .{
2571 return sema.addConstant((try mod.intern(.{ .ptr = .{
25722572 .ty = ptr_ty.toIntern(),
25732573 .addr = .{ .mut_decl = .{
25742574 .decl = decl_index,
......@@ -2642,11 +2642,10 @@ fn coerceResultPtr(
26422642
26432643 if (trash_block.instructions.items.len == prev_trash_len) {
26442644 if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
2645 return sema.addConstant(ptr_ty, ptr_val);
2645 return sema.addConstant(ptr_val);
26462646 }
26472647 if (pointee_ty.eql(Type.null, sema.mod)) {
2648 const opt_ty = sema.typeOf(new_ptr).childType(mod);
2649 const null_inst = try sema.addConstant(opt_ty, Value.null);
2648 const null_inst = try sema.addConstant(Value.null);
26502649 _ = try block.addBinOp(.store, new_ptr, null_inst);
26512650 return Air.Inst.Ref.void_value;
26522651 }
......@@ -2665,7 +2664,7 @@ fn coerceResultPtr(
26652664 });
26662665
26672666 if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
2668 return sema.addConstant(ptr_operand_ty, ptr_val);
2667 return sema.addConstant(ptr_val);
26692668 } else {
26702669 return sema.bitCast(block, ptr_operand_ty, new_ptr, src, null);
26712670 }
......@@ -2678,7 +2677,7 @@ fn coerceResultPtr(
26782677 .flags = .{ .address_space = addr_space },
26792678 });
26802679 if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
2681 new_ptr = try sema.addConstant(ptr_operand_ty, try mod.getCoerced(ptr_val, ptr_operand_ty));
2680 new_ptr = try sema.addConstant(try mod.getCoerced(ptr_val, ptr_operand_ty));
26822681 } else {
26832682 new_ptr = try sema.bitCast(block, ptr_operand_ty, new_ptr, src, null);
26842683 }
......@@ -3690,7 +3689,7 @@ fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Ai
36903689
36913690 // Detect if a comptime value simply needs to have its type changed.
36923691 if (try sema.resolveMaybeUndefVal(alloc)) |val| {
3693 return sema.addConstant(const_ptr_ty, try mod.getCoerced(val, const_ptr_ty));
3692 return sema.addConstant(try mod.getCoerced(val, const_ptr_ty));
36943693 }
36953694
36963695 return block.addBitCast(const_ptr_ty, alloc);
......@@ -4436,14 +4435,14 @@ fn validateUnionInit(
44364435 .ty = union_ty.toIntern(),
44374436 .val = union_val,
44384437 } });
4439 const union_init = try sema.addConstant(union_ty, union_val.toValue());
4438 const union_init = try sema.addConstant(union_val.toValue());
44404439 try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store);
44414440 return;
44424441 } else if (try sema.typeRequiresComptime(union_ty)) {
44434442 return sema.failWithNeededComptime(block, field_ptr_data.src(), "initializer of comptime only union must be comptime-known");
44444443 }
44454444
4446 const new_tag = try sema.addConstant(tag_ty, tag_val);
4445 const new_tag = try sema.addConstant(tag_val);
44474446 _ = try block.addBinOp(.set_union_tag, union_ptr, new_tag);
44484447}
44494448
......@@ -4534,8 +4533,7 @@ fn validateStructInit(
45344533 try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(u32, i), true)
45354534 else
45364535 try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(u32, i), field_src, struct_ty, true);
4537 const field_ty = sema.typeOf(default_field_ptr).childType(mod);
4538 const init = try sema.addConstant(field_ty, default_val);
4536 const init = try sema.addConstant(default_val);
45394537 try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
45404538 }
45414539
......@@ -4702,7 +4700,7 @@ fn validateStructInit(
47024700 .ty = struct_ty.toIntern(),
47034701 .val = struct_val,
47044702 } });
4705 const struct_init = try sema.addConstant(struct_ty, struct_val.toValue());
4703 const struct_init = try sema.addConstant(struct_val.toValue());
47064704 try sema.storePtr2(block, init_src, struct_ptr, init_src, struct_init, init_src, .store);
47074705 return;
47084706 }
......@@ -4717,8 +4715,7 @@ fn validateStructInit(
47174715 try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @intCast(u32, i), true)
47184716 else
47194717 try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @intCast(u32, i), field_src, struct_ty, true);
4720 const field_ty = sema.typeOf(default_field_ptr).childType(mod);
4721 const init = try sema.addConstant(field_ty, field_values[i].toValue());
4718 const init = try sema.addConstant(field_values[i].toValue());
47224719 try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
47234720 }
47244721}
......@@ -4785,7 +4782,7 @@ fn zirValidateArrayInit(
47854782 if (array_ty.sentinel(mod)) |sentinel_val| {
47864783 const array_len_ref = try sema.addIntUnsigned(Type.usize, array_len);
47874784 const sentinel_ptr = try sema.elemPtrArray(block, init_src, init_src, array_ptr, init_src, array_len_ref, true, true);
4788 const sentinel = try sema.addConstant(array_ty.childType(mod), sentinel_val);
4785 const sentinel = try sema.addConstant(sentinel_val);
47894786 try sema.storePtr2(block, init_src, sentinel_ptr, init_src, sentinel, init_src, .store);
47904787 }
47914788 return;
......@@ -4793,7 +4790,7 @@ fn zirValidateArrayInit(
47934790
47944791 // If the array has one possible value, the value is always comptime-known.
47954792 if (try sema.typeHasOnePossibleValue(array_ty)) |array_opv| {
4796 const array_init = try sema.addConstant(array_ty, array_opv);
4793 const array_init = try sema.addConstant(array_opv);
47974794 try sema.storePtr2(block, init_src, array_ptr, init_src, array_init, init_src, .store);
47984795 return;
47994796 }
......@@ -4910,7 +4907,7 @@ fn zirValidateArrayInit(
49104907 .ty = array_ty.toIntern(),
49114908 .val = array_val,
49124909 } });
4913 const array_init = try sema.addConstant(array_ty, array_val.toValue());
4910 const array_init = try sema.addConstant(array_val.toValue());
49144911 try sema.storePtr2(block, init_src, array_ptr, init_src, array_init, init_src, .store);
49154912 }
49164913}
......@@ -5266,7 +5263,6 @@ fn zirIntBig(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
52665263 @memcpy(mem.sliceAsBytes(limbs), limb_bytes);
52675264
52685265 return sema.addConstant(
5269 Type.comptime_int,
52705266 try mod.intValue_big(Type.comptime_int, .{
52715267 .limbs = limbs,
52725268 .positive = true,
......@@ -5278,7 +5274,6 @@ fn zirFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
52785274 _ = block;
52795275 const number = sema.code.instructions.items(.data)[inst].float;
52805276 return sema.addConstant(
5281 Type.comptime_float,
52825277 try sema.mod.floatValue(Type.comptime_float, number),
52835278 );
52845279}
......@@ -5289,7 +5284,6 @@ fn zirFloat128(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
52895284 const extra = sema.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data;
52905285 const number = extra.get();
52915286 return sema.addConstant(
5292 Type.comptime_float,
52935287 try sema.mod.floatValue(Type.comptime_float, number),
52945288 );
52955289}
......@@ -5553,7 +5547,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
55535547 const file_root_decl_index = result.file.root_decl.unwrap().?;
55545548 const file_root_decl = mod.declPtr(file_root_decl_index);
55555549 try mod.declareDeclDependency(sema.owner_decl_index, file_root_decl_index);
5556 return sema.addConstant(file_root_decl.ty, file_root_decl.val);
5550 return sema.addConstant(file_root_decl.val);
55575551}
55585552
55595553fn zirSuspendBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -6981,7 +6975,6 @@ fn analyzeCall(
69816975 } })) |memoized_call_index| {
69826976 const memoized_call = mod.intern_pool.indexToKey(memoized_call_index).memoized_call;
69836977 break :res2 try sema.addConstant(
6984 mod.intern_pool.typeOf(memoized_call.result).toType(),
69856978 memoized_call.result.toValue(),
69866979 );
69876980 }
......@@ -7746,7 +7739,7 @@ fn resolveGenericInstantiationType(
77467739 const arg = uncasted_args[arg_i];
77477740 if (is_comptime) {
77487741 const arg_val = (try sema.resolveMaybeUndefVal(arg)).?;
7749 const child_arg = try child_sema.addConstant(sema.typeOf(arg), arg_val);
7742 const child_arg = try child_sema.addConstant(arg_val);
77507743 child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
77517744 } else if (is_anytype) {
77527745 const arg_ty = sema.typeOf(arg);
......@@ -7760,7 +7753,7 @@ fn resolveGenericInstantiationType(
77607753 },
77617754 else => |e| return e,
77627755 };
7763 const child_arg = try child_sema.addConstant(arg_ty, arg_val);
7756 const child_arg = try child_sema.addConstant(arg_val);
77647757 child_sema.inst_map.putAssumeCapacityNoClobber(inst, child_arg);
77657758 } else {
77667759 // We insert into the map an instruction which is runtime-known
......@@ -8087,7 +8080,7 @@ fn zirErrorValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
80878080 _ = try mod.getErrorValue(name);
80888081 // Create an error set type with only this error value, and return the value.
80898082 const error_set_type = try mod.singleErrorSetType(name);
8090 return sema.addConstant(error_set_type, (try mod.intern(.{ .err = .{
8083 return sema.addConstant((try mod.intern(.{ .err = .{
80918084 .ty = error_set_type.toIntern(),
80928085 .name = name,
80938086 } })).toValue());
......@@ -8109,7 +8102,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
81098102 return sema.addConstUndef(Type.err_int);
81108103 }
81118104 const err_name = mod.intern_pool.indexToKey(val.toIntern()).err.name;
8112 return sema.addConstant(Type.err_int, try mod.intValue(
8105 return sema.addConstant(try mod.intValue(
81138106 Type.err_int,
81148107 try mod.getErrorValue(err_name),
81158108 ));
......@@ -8120,7 +8113,7 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
81208113 if (!op_ty.isAnyError(mod)) {
81218114 const names = op_ty.errorSetNames(mod);
81228115 switch (names.len) {
8123 0 => return sema.addConstant(Type.err_int, try mod.intValue(Type.err_int, 0)),
8116 0 => return sema.addConstant(try mod.intValue(Type.err_int, 0)),
81248117 1 => {
81258118 const int = @intCast(Module.ErrorInt, mod.global_error_set.getIndex(names[0]).?);
81268119 return sema.addIntUnsigned(Type.err_int, int);
......@@ -8148,7 +8141,7 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
81488141 const int = try sema.usizeCast(block, operand_src, value.toUnsignedInt(mod));
81498142 if (int > mod.global_error_set.count() or int == 0)
81508143 return sema.fail(block, operand_src, "integer value '{d}' represents no error", .{int});
8151 return sema.addConstant(Type.anyerror, (try mod.intern(.{ .err = .{
8144 return sema.addConstant((try mod.intern(.{ .err = .{
81528145 .ty = .anyerror_type,
81538146 .name = mod.global_error_set.keys()[int],
81548147 } })).toValue());
......@@ -8156,7 +8149,7 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
81568149 try sema.requireRuntimeBlock(block, src, operand_src);
81578150 if (block.wantSafety()) {
81588151 const is_lt_len = try block.addUnOp(.cmp_lt_errors_len, operand);
8159 const zero_val = try sema.addConstant(Type.err_int, try mod.intValue(Type.err_int, 0));
8152 const zero_val = try sema.addConstant(try mod.intValue(Type.err_int, 0));
81608153 const is_non_zero = try block.addBinOp(.cmp_neq, operand, zero_val);
81618154 const ok = try block.addBinOp(.bit_and, is_lt_len, is_non_zero);
81628155 try sema.addSafetyCheck(block, ok, .invalid_error_code);
......@@ -8230,7 +8223,7 @@ fn zirEnumLiteral(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
82308223 const mod = sema.mod;
82318224 const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
82328225 const name = inst_data.get(sema.code);
8233 return sema.addConstant(.{ .ip_index = .enum_literal_type }, (try mod.intern(.{
8226 return sema.addConstant((try mod.intern(.{
82348227 .enum_literal = try mod.intern_pool.getOrPutString(sema.gpa, name),
82358228 })).toValue());
82368229}
......@@ -8268,12 +8261,12 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
82688261 const int_tag_ty = enum_tag_ty.intTagType(mod);
82698262
82708263 if (try sema.typeHasOnePossibleValue(enum_tag_ty)) |opv| {
8271 return sema.addConstant(int_tag_ty, try mod.getCoerced(opv, int_tag_ty));
8264 return sema.addConstant(try mod.getCoerced(opv, int_tag_ty));
82728265 }
82738266
82748267 if (try sema.resolveMaybeUndefVal(enum_tag)) |enum_tag_val| {
82758268 const val = try enum_tag_val.intFromEnum(enum_tag_ty, mod);
8276 return sema.addConstant(int_tag_ty, val);
8269 return sema.addConstant(val);
82778270 }
82788271
82798272 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -8299,7 +8292,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
82998292 if (dest_ty.isNonexhaustiveEnum(mod)) {
83008293 const int_tag_ty = dest_ty.intTagType(mod);
83018294 if (try sema.intFitsInType(int_val, int_tag_ty, null)) {
8302 return sema.addConstant(dest_ty, try mod.getCoerced(int_val, dest_ty));
8295 return sema.addConstant(try mod.getCoerced(int_val, dest_ty));
83038296 }
83048297 const msg = msg: {
83058298 const msg = try sema.errMsg(
......@@ -8331,11 +8324,11 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
83318324 };
83328325 return sema.failWithOwnedErrorMsg(msg);
83338326 }
8334 return sema.addConstant(dest_ty, try mod.getCoerced(int_val, dest_ty));
8327 return sema.addConstant(try mod.getCoerced(int_val, dest_ty));
83358328 }
83368329
83378330 if (try sema.typeHasOnePossibleValue(dest_ty)) |opv| {
8338 const result = try sema.addConstant(dest_ty, opv);
8331 const result = try sema.addConstant(opv);
83398332 // The operand is runtime-known but the result is comptime-known. In
83408333 // this case we still need a safety check.
83418334 // TODO add a safety check here. we can't use is_named_enum_value -
......@@ -8405,7 +8398,7 @@ fn analyzeOptionalPayloadPtr(
84058398 // we need to emit a runtime instruction to do it.
84068399 _ = try block.addTyOp(.optional_payload_ptr_set, child_pointer, optional_ptr);
84078400 }
8408 return sema.addConstant(child_pointer, (try mod.intern(.{ .ptr = .{
8401 return sema.addConstant((try mod.intern(.{ .ptr = .{
84098402 .ty = child_pointer.toIntern(),
84108403 .addr = .{ .opt_payload = ptr_val.toIntern() },
84118404 } })).toValue());
......@@ -8415,7 +8408,7 @@ fn analyzeOptionalPayloadPtr(
84158408 return sema.fail(block, src, "unable to unwrap null", .{});
84168409 }
84178410 // The same Value represents the pointer to the optional and the payload.
8418 return sema.addConstant(child_pointer, (try mod.intern(.{ .ptr = .{
8411 return sema.addConstant((try mod.intern(.{ .ptr = .{
84198412 .ty = child_pointer.toIntern(),
84208413 .addr = .{ .opt_payload = ptr_val.toIntern() },
84218414 } })).toValue());
......@@ -8474,7 +8467,7 @@ fn zirOptionalPayload(
84748467
84758468 if (try sema.resolveDefinedValue(block, src, operand)) |val| {
84768469 return if (val.optionalValue(mod)) |payload|
8477 sema.addConstant(result_ty, payload)
8470 sema.addConstant(payload)
84788471 else
84798472 sema.fail(block, src, "unable to unwrap null", .{});
84808473 }
......@@ -8526,7 +8519,6 @@ fn analyzeErrUnionPayload(
85268519 return sema.fail(block, src, "caught unexpected error '{}'", .{name.fmt(&mod.intern_pool)});
85278520 }
85288521 return sema.addConstant(
8529 payload_ty,
85308522 mod.intern_pool.indexToKey(val.toIntern()).error_union.val.payload.toValue(),
85318523 );
85328524 }
......@@ -8596,7 +8588,7 @@ fn analyzeErrUnionPayloadPtr(
85968588 try sema.requireRuntimeBlock(block, src, null);
85978589 _ = try block.addTyOp(.errunion_payload_ptr_set, operand_pointer_ty, operand);
85988590 }
8599 return sema.addConstant(operand_pointer_ty, (try mod.intern(.{ .ptr = .{
8591 return sema.addConstant((try mod.intern(.{ .ptr = .{
86008592 .ty = operand_pointer_ty.toIntern(),
86018593 .addr = .{ .eu_payload = ptr_val.toIntern() },
86028594 } })).toValue());
......@@ -8605,7 +8597,7 @@ fn analyzeErrUnionPayloadPtr(
86058597 if (val.getErrorName(mod).unwrap()) |name| {
86068598 return sema.fail(block, src, "caught unexpected error '{}'", .{name.fmt(&mod.intern_pool)});
86078599 }
8608 return sema.addConstant(operand_pointer_ty, (try mod.intern(.{ .ptr = .{
8600 return sema.addConstant((try mod.intern(.{ .ptr = .{
86098601 .ty = operand_pointer_ty.toIntern(),
86108602 .addr = .{ .eu_payload = ptr_val.toIntern() },
86118603 } })).toValue());
......@@ -8651,7 +8643,7 @@ fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air
86518643 const result_ty = operand_ty.errorUnionSet(mod);
86528644
86538645 if (try sema.resolveDefinedValue(block, src, operand)) |val| {
8654 return sema.addConstant(result_ty, (try mod.intern(.{ .err = .{
8646 return sema.addConstant((try mod.intern(.{ .err = .{
86558647 .ty = result_ty.toIntern(),
86568648 .name = mod.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name,
86578649 } })).toValue());
......@@ -8684,7 +8676,7 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
86848676 if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
86858677 if (try sema.pointerDeref(block, src, pointer_val, operand_ty)) |val| {
86868678 assert(val.getErrorName(mod) != .none);
8687 return sema.addConstant(result_ty, val);
8679 return sema.addConstant(val);
86888680 }
86898681 }
86908682
......@@ -9148,7 +9140,7 @@ fn funcCommon(
91489140 sema.owner_decl.@"addrspace" = address_space orelse .generic;
91499141
91509142 if (is_extern) {
9151 return sema.addConstant(fn_ty, (try mod.intern(.{ .extern_func = .{
9143 return sema.addConstant((try mod.intern(.{ .extern_func = .{
91529144 .ty = fn_ty.toIntern(),
91539145 .decl = sema.owner_decl_index,
91549146 .lib_name = if (opt_lib_name) |lib_name| (try mod.intern_pool.getOrPutString(
......@@ -9188,7 +9180,7 @@ fn funcCommon(
91889180 .branch_quota = default_branch_quota,
91899181 .is_noinline = is_noinline,
91909182 };
9191 return sema.addConstant(fn_ty, (try mod.intern(.{ .func = .{
9183 return sema.addConstant((try mod.intern(.{ .func = .{
91929184 .ty = fn_ty.toIntern(),
91939185 .index = new_func_index,
91949186 } })).toValue());
......@@ -9376,7 +9368,7 @@ fn zirParam(
93769368 // In this case we are instantiating a generic function call with a non-comptime
93779369 // non-anytype parameter that ended up being a one-possible-type.
93789370 // We don't want the parameter to be part of the instantiated function type.
9379 const result = try sema.addConstant(param_ty, opv);
9371 const result = try sema.addConstant(opv);
93809372 sema.inst_map.putAssumeCapacity(inst, result);
93819373 return;
93829374 }
......@@ -9391,7 +9383,7 @@ fn zirParam(
93919383 if (is_comptime) {
93929384 // If this is a comptime parameter we can add a constant generic_poison
93939385 // since this is also a generic parameter.
9394 const result = try sema.addConstant(Type.generic_poison, Value.generic_poison);
9386 const result = try sema.addConstant(Value.generic_poison);
93959387 sema.inst_map.putAssumeCapacityNoClobber(inst, result);
93969388 } else {
93979389 // Otherwise we need a dummy runtime instruction.
......@@ -9514,7 +9506,6 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
95149506 }
95159507 if (try sema.resolveMaybeUndefValIntable(ptr)) |ptr_val| {
95169508 return sema.addConstant(
9517 Type.usize,
95189509 try mod.intValue(Type.usize, (try ptr_val.getUnsignedIntAdvanced(mod, sema)).?),
95199510 );
95209511 }
......@@ -9625,7 +9616,7 @@ fn intCast(
96259616 if (wanted_bits == 0) {
96269617 const ok = if (is_vector) ok: {
96279618 const zeros = try sema.splat(operand_ty, try mod.intValue(operand_scalar_ty, 0));
9628 const zero_inst = try sema.addConstant(operand_ty, zeros);
9619 const zero_inst = try sema.addConstant(zeros);
96299620 const is_in_range = try block.addCmpVector(operand, zero_inst, .eq);
96309621 const all_in_range = try block.addInst(.{
96319622 .tag = .reduce,
......@@ -9633,7 +9624,7 @@ fn intCast(
96339624 });
96349625 break :ok all_in_range;
96359626 } else ok: {
9636 const zero_inst = try sema.addConstant(operand_ty, try mod.intValue(operand_ty, 0));
9627 const zero_inst = try sema.addConstant(try mod.intValue(operand_ty, 0));
96379628 const is_in_range = try block.addBinOp(.cmp_lte, operand, zero_inst);
96389629 break :ok is_in_range;
96399630 };
......@@ -9641,7 +9632,7 @@ fn intCast(
96419632 }
96429633 }
96439634
9644 return sema.addConstant(dest_ty, opv);
9635 return sema.addConstant(opv);
96459636 }
96469637
96479638 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -9658,7 +9649,7 @@ fn intCast(
96589649 if (wanted_value_bits < actual_value_bits) {
96599650 const dest_max_val_scalar = try dest_scalar_ty.maxIntScalar(mod, operand_scalar_ty);
96609651 const dest_max_val = try sema.splat(operand_ty, dest_max_val_scalar);
9661 const dest_max = try sema.addConstant(operand_ty, dest_max_val);
9652 const dest_max = try sema.addConstant(dest_max_val);
96629653 const diff = try block.addBinOp(.subwrap, dest_max, operand);
96639654
96649655 if (actual_info.signedness == .signed) {
......@@ -9674,7 +9665,7 @@ fn intCast(
96749665 const range_minus_one = try dest_max_val.shl(one, unsigned_operand_ty, sema.arena, mod);
96759666 break :range_val try sema.intAdd(range_minus_one, one, unsigned_operand_ty, undefined);
96769667 } else try mod.getCoerced(dest_max_val, unsigned_operand_ty);
9677 const dest_range = try sema.addConstant(unsigned_operand_ty, dest_range_val);
9668 const dest_range = try sema.addConstant(dest_range_val);
96789669
96799670 const ok = if (is_vector) ok: {
96809671 const is_in_range = try block.addCmpVector(diff_unsigned, dest_range, .lte);
......@@ -9715,7 +9706,7 @@ fn intCast(
97159706 const ok = if (is_vector) ok: {
97169707 const scalar_zero = try mod.intValue(operand_scalar_ty, 0);
97179708 const zero_val = try sema.splat(operand_ty, scalar_zero);
9718 const zero_inst = try sema.addConstant(operand_ty, zero_val);
9709 const zero_inst = try sema.addConstant(zero_val);
97199710 const is_in_range = try block.addCmpVector(operand, zero_inst, .gte);
97209711 const all_in_range = try block.addInst(.{
97219712 .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
......@@ -9726,7 +9717,7 @@ fn intCast(
97269717 });
97279718 break :ok all_in_range;
97289719 } else ok: {
9729 const zero_inst = try sema.addConstant(operand_ty, try mod.intValue(operand_ty, 0));
9720 const zero_inst = try sema.addConstant(try mod.intValue(operand_ty, 0));
97309721 const is_in_range = try block.addBinOp(.cmp_gte, operand, zero_inst);
97319722 break :ok is_in_range;
97329723 };
......@@ -9916,7 +9907,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
99169907 }
99179908
99189909 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
9919 return sema.addConstant(dest_ty, try operand_val.floatCast(dest_ty, mod));
9910 return sema.addConstant(try operand_val.floatCast(dest_ty, mod));
99209911 }
99219912 if (dest_is_comptime_float) {
99229913 return sema.fail(block, operand_src, "unable to cast runtime value to 'comptime_float'", .{});
......@@ -10286,7 +10277,6 @@ const SwitchProngAnalysis = struct {
1028610277 });
1028710278 if (try sema.resolveDefinedValue(block, sema.src, spa.operand_ptr)) |union_ptr| {
1028810279 return sema.addConstant(
10289 ptr_field_ty,
1029010280 (try mod.intern(.{ .ptr = .{
1029110281 .ty = ptr_field_ty.toIntern(),
1029210282 .addr = .{ .field = .{
......@@ -10300,7 +10290,7 @@ const SwitchProngAnalysis = struct {
1030010290 } else {
1030110291 if (try sema.resolveDefinedValue(block, sema.src, spa.operand)) |union_val| {
1030210292 const tag_and_val = mod.intern_pool.indexToKey(union_val.toIntern()).un;
10303 return sema.addConstant(field_ty, tag_and_val.val.toValue());
10293 return sema.addConstant(tag_and_val.val.toValue());
1030410294 }
1030510295 return block.addStructFieldVal(spa.operand, field_index, field_ty);
1030610296 }
......@@ -10432,7 +10422,6 @@ const SwitchProngAnalysis = struct {
1043210422 if (try sema.resolveDefinedValue(block, operand_src, spa.operand_ptr)) |op_ptr_val| {
1043310423 if (op_ptr_val.isUndef(mod)) return sema.addConstUndef(capture_ptr_ty);
1043410424 return sema.addConstant(
10435 capture_ptr_ty,
1043610425 (try mod.intern(.{ .ptr = .{
1043710426 .ty = capture_ptr_ty.toIntern(),
1043810427 .addr = .{ .field = .{
......@@ -10451,9 +10440,7 @@ const SwitchProngAnalysis = struct {
1045110440 if (operand_val.isUndef(mod)) return sema.addConstUndef(capture_ty);
1045210441 const union_val = mod.intern_pool.indexToKey(operand_val.toIntern()).un;
1045310442 if (union_val.tag.toValue().isUndef(mod)) return sema.addConstUndef(capture_ty);
10454 const active_field_idx = @intCast(u32, operand_ty.unionTagFieldIndex(union_val.tag.toValue(), sema.mod).?);
10455 const field_ty = union_obj.fields.values()[active_field_idx].ty;
10456 const uncoerced = try sema.addConstant(field_ty, union_val.val.toValue());
10443 const uncoerced = try sema.addConstant(union_val.val.toValue());
1045710444 return sema.coerce(block, capture_ty, uncoerced, operand_src);
1045810445 }
1045910446
......@@ -10644,7 +10631,7 @@ fn switchCond(
1064410631 return sema.fail(block, src, "switch on type '{}'", .{operand_ty.fmt(mod)});
1064510632 }
1064610633 if ((try sema.typeHasOnePossibleValue(operand_ty))) |opv| {
10647 return sema.addConstant(operand_ty, opv);
10634 return sema.addConstant(opv);
1064810635 }
1064910636 return operand;
1065010637 },
......@@ -11614,7 +11601,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1161411601 }) {
1161511602 cases_len += 1;
1161611603
11617 const item_ref = try sema.addConstant(operand_ty, item);
11604 const item_ref = try sema.addConstant(item);
1161811605
1161911606 case_block.instructions.shrinkRetainingCapacity(0);
1162011607 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -11862,7 +11849,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1186211849 cases_len += 1;
1186311850
1186411851 const item_val = try mod.enumValueFieldIndex(operand_ty, @intCast(u32, i));
11865 const item_ref = try sema.addConstant(operand_ty, item_val);
11852 const item_ref = try sema.addConstant(item_val);
1186611853
1186711854 case_block.instructions.shrinkRetainingCapacity(0);
1186811855 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -11912,7 +11899,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1191211899 .ty = operand_ty.toIntern(),
1191311900 .name = error_name,
1191411901 } });
11915 const item_ref = try sema.addConstant(operand_ty, item_val.toValue());
11902 const item_ref = try sema.addConstant(item_val.toValue());
1191611903
1191711904 case_block.instructions.shrinkRetainingCapacity(0);
1191811905 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -11943,7 +11930,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1194311930 while (try it.next()) |cur| {
1194411931 cases_len += 1;
1194511932
11946 const item_ref = try sema.addConstant(operand_ty, cur.toValue());
11933 const item_ref = try sema.addConstant(cur.toValue());
1194711934
1194811935 case_block.instructions.shrinkRetainingCapacity(0);
1194911936 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -12221,7 +12208,7 @@ fn resolveSwitchItemVal(
1222112208
1222212209 const val = try sema.resolveLazyValue(maybe_lazy);
1222312210 const new_item = if (val.toIntern() != maybe_lazy.toIntern()) blk: {
12224 break :blk try sema.addConstant(coerce_ty, val);
12211 break :blk try sema.addConstant(val);
1222512212 } else item;
1222612213
1222712214 return .{ .ref = new_item, .val = val.toIntern() };
......@@ -12631,7 +12618,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1263112618 const file_root_decl_index = result.file.root_decl.unwrap().?;
1263212619 const file_root_decl = mod.declPtr(file_root_decl_index);
1263312620 try mod.declareDeclDependency(sema.owner_decl_index, file_root_decl_index);
12634 return sema.addConstant(file_root_decl.ty, file_root_decl.val);
12621 return sema.addConstant(file_root_decl.val);
1263512622}
1263612623
1263712624fn zirEmbedFile(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -12686,7 +12673,7 @@ fn zirRetErrValueCode(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.R
1268612673 const name = try mod.intern_pool.getOrPutString(sema.gpa, inst_data.get(sema.code));
1268712674 _ = try mod.getErrorValue(name);
1268812675 const error_set_type = try mod.singleErrorSetType(name);
12689 return sema.addConstant(error_set_type, (try mod.intern(.{ .err = .{
12676 return sema.addConstant((try mod.intern(.{ .err = .{
1269012677 .ty = error_set_type.toIntern(),
1269112678 .name = name,
1269212679 } })).toValue());
......@@ -12804,7 +12791,7 @@ fn zirShl(
1280412791 else => unreachable,
1280512792 };
1280612793
12807 return sema.addConstant(lhs_ty, val);
12794 return sema.addConstant(val);
1280812795 } else lhs_src;
1280912796
1281012797 const new_rhs = if (air_tag == .shl_sat) rhs: {
......@@ -12813,7 +12800,6 @@ fn zirShl(
1281312800 scalar_rhs_ty.intInfo(mod).bits > scalar_ty.intInfo(mod).bits)
1281412801 {
1281512802 const max_int = try sema.addConstant(
12816 lhs_ty,
1281712803 try lhs_ty.maxInt(mod, lhs_ty),
1281812804 );
1281912805 const rhs_limited = try sema.analyzeMinMax(block, rhs_src, .min, &.{ rhs, max_int }, &.{ rhs_src, rhs_src });
......@@ -12829,7 +12815,7 @@ fn zirShl(
1282912815 if (!std.math.isPowerOfTwo(bit_count)) {
1283012816 const bit_count_val = try mod.intValue(scalar_rhs_ty, bit_count);
1283112817 const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
12832 const bit_count_inst = try sema.addConstant(rhs_ty, try sema.splat(rhs_ty, bit_count_val));
12818 const bit_count_inst = try sema.addConstant(try sema.splat(rhs_ty, bit_count_val));
1283312819 const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
1283412820 break :ok try block.addInst(.{
1283512821 .tag = .reduce,
......@@ -12839,7 +12825,7 @@ fn zirShl(
1283912825 } },
1284012826 });
1284112827 } else ok: {
12842 const bit_count_inst = try sema.addConstant(rhs_ty, bit_count_val);
12828 const bit_count_inst = try sema.addConstant(bit_count_val);
1284312829 break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst);
1284412830 };
1284512831 try sema.addSafetyCheck(block, ok, .shift_rhs_too_big);
......@@ -12868,7 +12854,7 @@ fn zirShl(
1286812854 })
1286912855 else
1287012856 ov_bit;
12871 const zero_ov = try sema.addConstant(Type.u1, try mod.intValue(Type.u1, 0));
12857 const zero_ov = try sema.addConstant(try mod.intValue(Type.u1, 0));
1287212858 const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
1287312859
1287412860 try sema.addSafetyCheck(block, no_ov, .shl_overflow);
......@@ -12961,7 +12947,7 @@ fn zirShr(
1296112947 }
1296212948 }
1296312949 const val = try lhs_val.shr(rhs_val, lhs_ty, sema.arena, mod);
12964 return sema.addConstant(lhs_ty, val);
12950 return sema.addConstant(val);
1296512951 } else {
1296612952 break :rs lhs_src;
1296712953 }
......@@ -12979,7 +12965,7 @@ fn zirShr(
1297912965 const bit_count_val = try mod.intValue(rhs_ty.scalarType(mod), bit_count);
1298012966
1298112967 const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
12982 const bit_count_inst = try sema.addConstant(rhs_ty, try sema.splat(rhs_ty, bit_count_val));
12968 const bit_count_inst = try sema.addConstant(try sema.splat(rhs_ty, bit_count_val));
1298312969 const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
1298412970 break :ok try block.addInst(.{
1298512971 .tag = .reduce,
......@@ -12989,7 +12975,7 @@ fn zirShr(
1298912975 } },
1299012976 });
1299112977 } else ok: {
12992 const bit_count_inst = try sema.addConstant(rhs_ty, bit_count_val);
12978 const bit_count_inst = try sema.addConstant(bit_count_val);
1299312979 break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst);
1299412980 };
1299512981 try sema.addSafetyCheck(block, ok, .shift_rhs_too_big);
......@@ -13061,7 +13047,7 @@ fn zirBitwise(
1306113047 .xor => try lhs_val.bitwiseXor(rhs_val, resolved_type, sema.arena, mod),
1306213048 else => unreachable,
1306313049 };
13064 return sema.addConstant(resolved_type, result_val);
13050 return sema.addConstant(result_val);
1306513051 } else {
1306613052 break :runtime rhs_src;
1306713053 }
......@@ -13103,13 +13089,13 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1310313089 const elem_val = try val.elemValue(mod, i);
1310413090 elem.* = try (try elem_val.bitwiseNot(scalar_type, sema.arena, mod)).intern(scalar_type, mod);
1310513091 }
13106 return sema.addConstant(operand_type, (try mod.intern(.{ .aggregate = .{
13092 return sema.addConstant((try mod.intern(.{ .aggregate = .{
1310713093 .ty = operand_type.toIntern(),
1310813094 .storage = .{ .elems = elems },
1310913095 } })).toValue());
1311013096 } else {
1311113097 const result_val = try val.bitwiseNot(operand_type, sema.arena, mod);
13112 return sema.addConstant(operand_type, result_val);
13098 return sema.addConstant(result_val);
1311313099 }
1311413100 }
1311513101
......@@ -13136,7 +13122,7 @@ fn analyzeTupleCat(
1313613122 const dest_fields = lhs_len + rhs_len;
1313713123
1313813124 if (dest_fields == 0) {
13139 return sema.addConstant(Type.empty_struct_literal, Value.empty_struct);
13125 return sema.addConstant(Value.empty_struct);
1314013126 }
1314113127 if (lhs_len == 0) {
1314213128 return rhs;
......@@ -13187,7 +13173,7 @@ fn analyzeTupleCat(
1318713173 .ty = tuple_ty,
1318813174 .storage = .{ .elems = values },
1318913175 } });
13190 return sema.addConstant(tuple_ty.toType(), tuple_val.toValue());
13176 return sema.addConstant(tuple_val.toValue());
1319113177 };
1319213178
1319313179 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -13258,9 +13244,9 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1325813244 // coercing it to the peer-resolved element type.
1325913245 const res_sent_val: ?Value = s: {
1326013246 if (lhs_info.sentinel) |lhs_sent_val| {
13261 const lhs_sent = try sema.addConstant(lhs_info.elem_type, lhs_sent_val);
13247 const lhs_sent = try sema.addConstant(lhs_sent_val);
1326213248 if (rhs_info.sentinel) |rhs_sent_val| {
13263 const rhs_sent = try sema.addConstant(rhs_info.elem_type, rhs_sent_val);
13249 const rhs_sent = try sema.addConstant(rhs_sent_val);
1326413250 const lhs_sent_casted = try sema.coerce(block, resolved_elem_ty, lhs_sent, lhs_src);
1326513251 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);
1326613252 const lhs_sent_casted_val = try sema.resolveConstValue(block, lhs_src, lhs_sent_casted, "array sentinel value must be comptime-known");
......@@ -13277,7 +13263,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1327713263 }
1327813264 } else {
1327913265 if (rhs_info.sentinel) |rhs_sent_val| {
13280 const rhs_sent = try sema.addConstant(rhs_info.elem_type, rhs_sent_val);
13266 const rhs_sent = try sema.addConstant(rhs_sent_val);
1328113267 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);
1328213268 const rhs_sent_casted_val = try sema.resolveConstValue(block, rhs_src, rhs_sent_casted, "array sentinel value must be comptime-known");
1328313269 break :s rhs_sent_casted_val;
......@@ -13333,20 +13319,18 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1333313319 var elem_i: usize = 0;
1333413320 while (elem_i < lhs_len) : (elem_i += 1) {
1333513321 const lhs_elem_i = elem_i;
13336 const elem_ty = if (lhs_is_tuple) lhs_ty.structFieldType(lhs_elem_i, mod) else lhs_info.elem_type;
1333713322 const elem_default_val = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, mod) else Value.@"unreachable";
1333813323 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try lhs_sub_val.elemValue(mod, lhs_elem_i) else elem_default_val;
13339 const elem_val_inst = try sema.addConstant(elem_ty, elem_val);
13324 const elem_val_inst = try sema.addConstant(elem_val);
1334013325 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
1334113326 const coerced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, "");
1334213327 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);
1334313328 }
1334413329 while (elem_i < result_len) : (elem_i += 1) {
1334513330 const rhs_elem_i = elem_i - lhs_len;
13346 const elem_ty = if (rhs_is_tuple) rhs_ty.structFieldType(rhs_elem_i, mod) else rhs_info.elem_type;
1334713331 const elem_default_val = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, mod) else Value.@"unreachable";
1334813332 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try rhs_sub_val.elemValue(mod, rhs_elem_i) else elem_default_val;
13349 const elem_val_inst = try sema.addConstant(elem_ty, elem_val);
13333 const elem_val_inst = try sema.addConstant(elem_val);
1335013334 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
1335113335 const coerced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, "");
1335213336 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);
......@@ -13388,7 +13372,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1338813372 if (res_sent_val) |sent_val| {
1338913373 const elem_index = try sema.addIntUnsigned(Type.usize, result_len);
1339013374 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
13391 const init = try sema.addConstant(lhs_info.elem_type, try mod.getCoerced(sent_val, lhs_info.elem_type));
13375 const init = try sema.addConstant(try mod.getCoerced(sent_val, lhs_info.elem_type));
1339213376 try sema.storePtr2(block, src, elem_ptr, src, init, lhs_src, .store);
1339313377 }
1339413378
......@@ -13476,7 +13460,7 @@ fn analyzeTupleMul(
1347613460 return sema.fail(block, rhs_src, "operation results in overflow", .{});
1347713461
1347813462 if (final_len == 0) {
13479 return sema.addConstant(Type.empty_struct_literal, Value.empty_struct);
13463 return sema.addConstant(Value.empty_struct);
1348013464 }
1348113465 const types = try sema.arena.alloc(InternPool.Index, final_len);
1348213466 const values = try sema.arena.alloc(InternPool.Index, final_len);
......@@ -13510,7 +13494,7 @@ fn analyzeTupleMul(
1351013494 .ty = tuple_ty,
1351113495 .storage = .{ .elems = values },
1351213496 } });
13513 return sema.addConstant(tuple_ty.toType(), tuple_val.toValue());
13497 return sema.addConstant(tuple_val.toValue());
1351413498 };
1351513499
1351613500 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -13645,7 +13629,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1364513629 if (lhs_info.sentinel) |sent_val| {
1364613630 const elem_index = try sema.addIntUnsigned(Type.usize, result_len);
1364713631 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
13648 const init = try sema.addConstant(lhs_info.elem_type, sent_val);
13632 const init = try sema.addConstant(sent_val);
1364913633 try sema.storePtr2(block, src, elem_ptr, src, init, lhs_src, .store);
1365013634 }
1365113635
......@@ -13689,13 +13673,13 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1368913673 // We handle float negation here to ensure negative zero is represented in the bits.
1369013674 if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| {
1369113675 if (rhs_val.isUndef(mod)) return sema.addConstUndef(rhs_ty);
13692 return sema.addConstant(rhs_ty, try rhs_val.floatNeg(rhs_ty, sema.arena, mod));
13676 return sema.addConstant(try rhs_val.floatNeg(rhs_ty, sema.arena, mod));
1369313677 }
1369413678 try sema.requireRuntimeBlock(block, src, null);
1369513679 return block.addUnOp(if (block.float_mode == .Optimized) .neg_optimized else .neg, rhs);
1369613680 }
1369713681
13698 const lhs = try sema.addConstant(rhs_ty, try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0)));
13682 const lhs = try sema.addConstant(try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0)));
1369913683 return sema.analyzeArithmetic(block, .sub, lhs, rhs, src, lhs_src, rhs_src, true);
1370013684}
1370113685
......@@ -13715,7 +13699,7 @@ fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1371513699 else => return sema.fail(block, src, "negation of type '{}'", .{rhs_ty.fmt(mod)}),
1371613700 }
1371713701
13718 const lhs = try sema.addConstant(rhs_ty, try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0)));
13702 const lhs = try sema.addConstant(try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0)));
1371913703 return sema.analyzeArithmetic(block, .subwrap, lhs, rhs, src, lhs_src, rhs_src, true);
1372013704}
1372113705
......@@ -13832,7 +13816,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1383213816 else => unreachable,
1383313817 };
1383413818 const zero_val = try sema.splat(resolved_type, scalar_zero);
13835 return sema.addConstant(resolved_type, zero_val);
13819 return sema.addConstant(zero_val);
1383613820 }
1383713821 }
1383813822 }
......@@ -13870,10 +13854,9 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1387013854 if (overflow_idx) |vec_idx| {
1387113855 return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
1387213856 }
13873 return sema.addConstant(resolved_type, res);
13857 return sema.addConstant(res);
1387413858 } else {
1387513859 return sema.addConstant(
13876 resolved_type,
1387713860 try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, mod),
1387813861 );
1387913862 }
......@@ -13972,7 +13955,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1397213955 else => unreachable,
1397313956 };
1397413957 const zero_val = try sema.splat(resolved_type, scalar_zero);
13975 return sema.addConstant(resolved_type, zero_val);
13958 return sema.addConstant(zero_val);
1397613959 }
1397713960 }
1397813961 }
......@@ -13997,14 +13980,13 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1399713980 if (overflow_idx) |vec_idx| {
1399813981 return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
1399913982 }
14000 return sema.addConstant(resolved_type, res);
13983 return sema.addConstant(res);
1400113984 } else {
1400213985 const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod);
1400313986 if (!(modulus_val.compareAllWithZero(.eq, mod))) {
1400413987 return sema.fail(block, src, "exact division produced remainder", .{});
1400513988 }
1400613989 return sema.addConstant(
14007 resolved_type,
1400813990 try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, mod),
1400913991 );
1401013992 }
......@@ -14056,7 +14038,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1405614038 };
1405714039 if (resolved_type.zigTypeTag(mod) == .Vector) {
1405814040 const zero_val = try sema.splat(resolved_type, scalar_zero);
14059 const zero = try sema.addConstant(resolved_type, zero_val);
14041 const zero = try sema.addConstant(zero_val);
1406014042 const eql = try block.addCmpVector(remainder, zero, .eq);
1406114043 break :ok try block.addInst(.{
1406214044 .tag = .reduce,
......@@ -14066,7 +14048,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1406614048 } },
1406714049 });
1406814050 } else {
14069 const zero = try sema.addConstant(resolved_type, scalar_zero);
14051 const zero = try sema.addConstant(scalar_zero);
1407014052 const is_in_range = try block.addBinOp(.cmp_eq, remainder, zero);
1407114053 break :ok is_in_range;
1407214054 }
......@@ -14143,7 +14125,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1414314125 else => unreachable,
1414414126 };
1414514127 const zero_val = try sema.splat(resolved_type, scalar_zero);
14146 return sema.addConstant(resolved_type, zero_val);
14128 return sema.addConstant(zero_val);
1414714129 }
1414814130 }
1414914131 }
......@@ -14172,12 +14154,10 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1417214154 if (maybe_rhs_val) |rhs_val| {
1417314155 if (is_int) {
1417414156 return sema.addConstant(
14175 resolved_type,
1417614157 try lhs_val.intDivFloor(rhs_val, resolved_type, sema.arena, mod),
1417714158 );
1417814159 } else {
1417914160 return sema.addConstant(
14180 resolved_type,
1418114161 try lhs_val.floatDivFloor(rhs_val, resolved_type, sema.arena, mod),
1418214162 );
1418314163 }
......@@ -14260,7 +14240,7 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1426014240 else => unreachable,
1426114241 };
1426214242 const zero_val = try sema.splat(resolved_type, scalar_zero);
14263 return sema.addConstant(resolved_type, zero_val);
14243 return sema.addConstant(zero_val);
1426414244 }
1426514245 }
1426614246 }
......@@ -14292,10 +14272,9 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1429214272 if (overflow_idx) |vec_idx| {
1429314273 return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
1429414274 }
14295 return sema.addConstant(resolved_type, res);
14275 return sema.addConstant(res);
1429614276 } else {
1429714277 return sema.addConstant(
14298 resolved_type,
1429914278 try lhs_val.floatDivTrunc(rhs_val, resolved_type, sema.arena, mod),
1430014279 );
1430114280 }
......@@ -14353,11 +14332,11 @@ fn addDivIntOverflowSafety(
1435314332 var ok: Air.Inst.Ref = .none;
1435414333 if (resolved_type.zigTypeTag(mod) == .Vector) {
1435514334 if (maybe_lhs_val == null) {
14356 const min_int_ref = try sema.addConstant(resolved_type, min_int);
14335 const min_int_ref = try sema.addConstant(min_int);
1435714336 ok = try block.addCmpVector(casted_lhs, min_int_ref, .neq);
1435814337 }
1435914338 if (maybe_rhs_val == null) {
14360 const neg_one_ref = try sema.addConstant(resolved_type, neg_one);
14339 const neg_one_ref = try sema.addConstant(neg_one);
1436114340 const rhs_ok = try block.addCmpVector(casted_rhs, neg_one_ref, .neq);
1436214341 if (ok == .none) {
1436314342 ok = rhs_ok;
......@@ -14375,11 +14354,11 @@ fn addDivIntOverflowSafety(
1437514354 });
1437614355 } else {
1437714356 if (maybe_lhs_val == null) {
14378 const min_int_ref = try sema.addConstant(resolved_type, min_int);
14357 const min_int_ref = try sema.addConstant(min_int);
1437914358 ok = try block.addBinOp(.cmp_neq, casted_lhs, min_int_ref);
1438014359 }
1438114360 if (maybe_rhs_val == null) {
14382 const neg_one_ref = try sema.addConstant(resolved_type, neg_one);
14361 const neg_one_ref = try sema.addConstant(neg_one);
1438314362 const rhs_ok = try block.addBinOp(.cmp_neq, casted_rhs, neg_one_ref);
1438414363 if (ok == .none) {
1438514364 ok = rhs_ok;
......@@ -14414,7 +14393,7 @@ fn addDivByZeroSafety(
1441414393 try mod.floatValue(resolved_type.scalarType(mod), 0.0);
1441514394 const ok = if (resolved_type.zigTypeTag(mod) == .Vector) ok: {
1441614395 const zero_val = try sema.splat(resolved_type, scalar_zero);
14417 const zero = try sema.addConstant(resolved_type, zero_val);
14396 const zero = try sema.addConstant(zero_val);
1441814397 const ok = try block.addCmpVector(casted_rhs, zero, .neq);
1441914398 break :ok try block.addInst(.{
1442014399 .tag = if (is_int) .reduce else .reduce_optimized,
......@@ -14424,7 +14403,7 @@ fn addDivByZeroSafety(
1442414403 } },
1442514404 });
1442614405 } else ok: {
14427 const zero = try sema.addConstant(resolved_type, scalar_zero);
14406 const zero = try sema.addConstant(scalar_zero);
1442814407 break :ok try block.addBinOp(if (is_int) .cmp_neq else .cmp_neq_optimized, casted_rhs, zero);
1442914408 };
1443014409 try sema.addSafetyCheck(block, ok, .divide_by_zero);
......@@ -14505,7 +14484,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1450514484 .ty = resolved_type.toIntern(),
1450614485 .storage = .{ .repeated_elem = scalar_zero.toIntern() },
1450714486 } })).toValue() else scalar_zero;
14508 return sema.addConstant(resolved_type, zero_val);
14487 return sema.addConstant(zero_val);
1450914488 }
1451014489 } else if (lhs_scalar_ty.isSignedInt(mod)) {
1451114490 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
......@@ -14529,7 +14508,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1452914508 {
1453014509 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
1453114510 }
14532 return sema.addConstant(resolved_type, rem_result);
14511 return sema.addConstant(rem_result);
1453314512 }
1453414513 break :rs lhs_src;
1453514514 } else if (rhs_scalar_ty.isSignedInt(mod)) {
......@@ -14554,7 +14533,6 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1455414533 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
1455514534 }
1455614535 return sema.addConstant(
14557 resolved_type,
1455814536 try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod),
1455914537 );
1456014538 } else {
......@@ -14687,7 +14665,6 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1468714665 }
1468814666 if (maybe_lhs_val) |lhs_val| {
1468914667 return sema.addConstant(
14690 resolved_type,
1469114668 try lhs_val.intMod(rhs_val, resolved_type, sema.arena, mod),
1469214669 );
1469314670 }
......@@ -14711,7 +14688,6 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1471114688 }
1471214689 if (maybe_rhs_val) |rhs_val| {
1471314690 return sema.addConstant(
14714 resolved_type,
1471514691 try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod),
1471614692 );
1471714693 } else break :rs rhs_src;
......@@ -14789,7 +14765,6 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1478914765 }
1479014766 if (maybe_lhs_val) |lhs_val| {
1479114767 return sema.addConstant(
14792 resolved_type,
1479314768 try sema.intRem(resolved_type, lhs_val, rhs_val),
1479414769 );
1479514770 }
......@@ -14813,7 +14788,6 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1481314788 }
1481414789 if (maybe_rhs_val) |rhs_val| {
1481514790 return sema.addConstant(
14816 resolved_type,
1481714791 try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod),
1481814792 );
1481914793 } else break :rs rhs_src;
......@@ -15025,7 +14999,7 @@ fn zirOverflowArithmetic(
1502514999 }
1502615000
1502715001 if (result.inst == .none) {
15028 return sema.addConstant(tuple_ty, (try mod.intern(.{ .aggregate = .{
15002 return sema.addConstant((try mod.intern(.{ .aggregate = .{
1502915003 .ty = tuple_ty.toIntern(),
1503015004 .storage = .{ .elems = &.{
1503115005 result.wrapped.toIntern(),
......@@ -15036,7 +15010,7 @@ fn zirOverflowArithmetic(
1503615010
1503715011 const element_refs = try sema.arena.alloc(Air.Inst.Ref, 2);
1503815012 element_refs[0] = result.inst;
15039 element_refs[1] = try sema.addConstant(tuple_ty.structFieldType(1, mod), result.overflow_bit);
15013 element_refs[1] = try sema.addConstant(result.overflow_bit);
1504015014 return block.addAggregateInit(tuple_ty, element_refs);
1504115015}
1504215016
......@@ -15158,10 +15132,9 @@ fn analyzeArithmetic(
1515815132 if (overflow_idx) |vec_idx| {
1515915133 return sema.failWithIntegerOverflow(block, src, resolved_type, sum, vec_idx);
1516015134 }
15161 return sema.addConstant(resolved_type, sum);
15135 return sema.addConstant(sum);
1516215136 } else {
1516315137 return sema.addConstant(
15164 resolved_type,
1516515138 try Value.floatAdd(lhs_val, rhs_val, resolved_type, sema.arena, mod),
1516615139 );
1516715140 }
......@@ -15187,7 +15160,6 @@ fn analyzeArithmetic(
1518715160 }
1518815161 if (maybe_lhs_val) |lhs_val| {
1518915162 return sema.addConstant(
15190 resolved_type,
1519115163 try sema.numberAddWrapScalar(lhs_val, rhs_val, resolved_type),
1519215164 );
1519315165 } else break :rs .{ .src = lhs_src, .air_tag = air_tag };
......@@ -15215,7 +15187,7 @@ fn analyzeArithmetic(
1521515187 else
1521615188 try lhs_val.intAddSat(rhs_val, resolved_type, sema.arena, mod);
1521715189
15218 return sema.addConstant(resolved_type, val);
15190 return sema.addConstant(val);
1521915191 } else break :rs .{ .src = lhs_src, .air_tag = .add_sat };
1522015192 } else break :rs .{ .src = rhs_src, .air_tag = .add_sat };
1522115193 },
......@@ -15255,10 +15227,9 @@ fn analyzeArithmetic(
1525515227 if (overflow_idx) |vec_idx| {
1525615228 return sema.failWithIntegerOverflow(block, src, resolved_type, diff, vec_idx);
1525715229 }
15258 return sema.addConstant(resolved_type, diff);
15230 return sema.addConstant(diff);
1525915231 } else {
1526015232 return sema.addConstant(
15261 resolved_type,
1526215233 try Value.floatSub(lhs_val, rhs_val, resolved_type, sema.arena, mod),
1526315234 );
1526415235 }
......@@ -15284,7 +15255,6 @@ fn analyzeArithmetic(
1528415255 }
1528515256 if (maybe_rhs_val) |rhs_val| {
1528615257 return sema.addConstant(
15287 resolved_type,
1528815258 try sema.numberSubWrapScalar(lhs_val, rhs_val, resolved_type),
1528915259 );
1529015260 } else break :rs .{ .src = rhs_src, .air_tag = air_tag };
......@@ -15312,7 +15282,7 @@ fn analyzeArithmetic(
1531215282 else
1531315283 try lhs_val.intSubSat(rhs_val, resolved_type, sema.arena, mod);
1531415284
15315 return sema.addConstant(resolved_type, val);
15285 return sema.addConstant(val);
1531615286 } else break :rs .{ .src = rhs_src, .air_tag = .sub_sat };
1531715287 } else break :rs .{ .src = lhs_src, .air_tag = .sub_sat };
1531815288 },
......@@ -15341,16 +15311,15 @@ fn analyzeArithmetic(
1534115311 if (maybe_lhs_val) |lhs_val| {
1534215312 if (!lhs_val.isUndef(mod)) {
1534315313 if (lhs_val.isNan(mod)) {
15344 return sema.addConstant(resolved_type, lhs_val);
15314 return sema.addConstant(lhs_val);
1534515315 }
1534615316 if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) lz: {
1534715317 if (maybe_rhs_val) |rhs_val| {
1534815318 if (rhs_val.isNan(mod)) {
15349 return sema.addConstant(resolved_type, rhs_val);
15319 return sema.addConstant(rhs_val);
1535015320 }
1535115321 if (rhs_val.isInf(mod)) {
1535215322 return sema.addConstant(
15353 resolved_type,
1535415323 try mod.floatValue(resolved_type, std.math.nan_f128),
1535515324 );
1535615325 }
......@@ -15358,7 +15327,7 @@ fn analyzeArithmetic(
1535815327 break :lz;
1535915328 }
1536015329 const zero_val = try sema.splat(resolved_type, scalar_zero);
15361 return sema.addConstant(resolved_type, zero_val);
15330 return sema.addConstant(zero_val);
1536215331 }
1536315332 if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1536415333 return casted_rhs;
......@@ -15375,13 +15344,12 @@ fn analyzeArithmetic(
1537515344 }
1537615345 }
1537715346 if (rhs_val.isNan(mod)) {
15378 return sema.addConstant(resolved_type, rhs_val);
15347 return sema.addConstant(rhs_val);
1537915348 }
1538015349 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) rz: {
1538115350 if (maybe_lhs_val) |lhs_val| {
1538215351 if (lhs_val.isInf(mod)) {
1538315352 return sema.addConstant(
15384 resolved_type,
1538515353 try mod.floatValue(resolved_type, std.math.nan_f128),
1538615354 );
1538715355 }
......@@ -15389,7 +15357,7 @@ fn analyzeArithmetic(
1538915357 break :rz;
1539015358 }
1539115359 const zero_val = try sema.splat(resolved_type, scalar_zero);
15392 return sema.addConstant(resolved_type, zero_val);
15360 return sema.addConstant(zero_val);
1539315361 }
1539415362 if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1539515363 return casted_lhs;
......@@ -15408,10 +15376,9 @@ fn analyzeArithmetic(
1540815376 if (overflow_idx) |vec_idx| {
1540915377 return sema.failWithIntegerOverflow(block, src, resolved_type, product, vec_idx);
1541015378 }
15411 return sema.addConstant(resolved_type, product);
15379 return sema.addConstant(product);
1541215380 } else {
1541315381 return sema.addConstant(
15414 resolved_type,
1541515382 try lhs_val.floatMul(rhs_val, resolved_type, sema.arena, mod),
1541615383 );
1541715384 }
......@@ -15437,7 +15404,7 @@ fn analyzeArithmetic(
1543715404 if (!lhs_val.isUndef(mod)) {
1543815405 if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1543915406 const zero_val = try sema.splat(resolved_type, scalar_zero);
15440 return sema.addConstant(resolved_type, zero_val);
15407 return sema.addConstant(zero_val);
1544115408 }
1544215409 if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1544315410 return casted_rhs;
......@@ -15451,7 +15418,7 @@ fn analyzeArithmetic(
1545115418 }
1545215419 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1545315420 const zero_val = try sema.splat(resolved_type, scalar_zero);
15454 return sema.addConstant(resolved_type, zero_val);
15421 return sema.addConstant(zero_val);
1545515422 }
1545615423 if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1545715424 return casted_lhs;
......@@ -15461,7 +15428,6 @@ fn analyzeArithmetic(
1546115428 return sema.addConstUndef(resolved_type);
1546215429 }
1546315430 return sema.addConstant(
15464 resolved_type,
1546515431 try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, mod),
1546615432 );
1546715433 } else break :rs .{ .src = lhs_src, .air_tag = air_tag };
......@@ -15486,7 +15452,7 @@ fn analyzeArithmetic(
1548615452 if (!lhs_val.isUndef(mod)) {
1548715453 if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1548815454 const zero_val = try sema.splat(resolved_type, scalar_zero);
15489 return sema.addConstant(resolved_type, zero_val);
15455 return sema.addConstant(zero_val);
1549015456 }
1549115457 if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1549215458 return casted_rhs;
......@@ -15499,7 +15465,7 @@ fn analyzeArithmetic(
1549915465 }
1550015466 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1550115467 const zero_val = try sema.splat(resolved_type, scalar_zero);
15502 return sema.addConstant(resolved_type, zero_val);
15468 return sema.addConstant(zero_val);
1550315469 }
1550415470 if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1550515471 return casted_lhs;
......@@ -15514,7 +15480,7 @@ fn analyzeArithmetic(
1551415480 else
1551515481 try lhs_val.intMulSat(rhs_val, resolved_type, sema.arena, mod);
1551615482
15517 return sema.addConstant(resolved_type, val);
15483 return sema.addConstant(val);
1551815484 } else break :rs .{ .src = lhs_src, .air_tag = .mul_sat };
1551915485 } else break :rs .{ .src = rhs_src, .air_tag = .mul_sat };
1552015486 },
......@@ -15554,7 +15520,7 @@ fn analyzeArithmetic(
1555415520 })
1555515521 else
1555615522 ov_bit;
15557 const zero_ov = try sema.addConstant(Type.u1, try mod.intValue(Type.u1, 0));
15523 const zero_ov = try sema.addConstant(try mod.intValue(Type.u1, 0));
1555815524 const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
1555915525
1556015526 try sema.addSafetyCheck(block, no_ov, .integer_overflow);
......@@ -15638,13 +15604,13 @@ fn analyzePtrArithmetic(
1563815604 else => unreachable,
1563915605 };
1564015606 const new_ptr_val = try mod.ptrIntValue(new_ptr_ty, new_addr);
15641 return sema.addConstant(new_ptr_ty, new_ptr_val);
15607 return sema.addConstant(new_ptr_val);
1564215608 }
1564315609 if (air_tag == .ptr_sub) {
1564415610 return sema.fail(block, op_src, "TODO implement Sema comptime pointer subtraction", .{});
1564515611 }
1564615612 const new_ptr_val = try ptr_val.elemPtr(new_ptr_ty, offset_int, mod);
15647 return sema.addConstant(new_ptr_ty, new_ptr_val);
15613 return sema.addConstant(new_ptr_val);
1564815614 } else break :rs offset_src;
1564915615 } else break :rs ptr_src;
1565015616 };
......@@ -16055,12 +16021,8 @@ fn cmpSelf(
1605516021 if (rhs_val.isUndef(mod)) return sema.addConstUndef(Type.bool);
1605616022
1605716023 if (resolved_type.zigTypeTag(mod) == .Vector) {
16058 const result_ty = try mod.vectorType(.{
16059 .len = resolved_type.vectorLen(mod),
16060 .child = .bool_type,
16061 });
1606216024 const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_type);
16063 return sema.addConstant(result_ty, cmp_val);
16025 return sema.addConstant(cmp_val);
1606416026 }
1606516027
1606616028 if (try sema.compareAll(lhs_val, op, rhs_val, resolved_type)) {
......@@ -16156,7 +16118,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1615616118 if (val.isLazySize(mod)) {
1615716119 try sema.queueFullTypeResolution(ty);
1615816120 }
16159 return sema.addConstant(Type.comptime_int, val);
16121 return sema.addConstant(val);
1616016122}
1616116123
1616216124fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -16319,8 +16281,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1631916281 return block.addTy(.alloc, ty_ip_index.toType());
1632016282 },
1632116283 .comptime_val => |val_ip_index| {
16322 const ty = mod.intern_pool.typeOf(val_ip_index).toType();
16323 return sema.addConstant(ty, val_ip_index.toValue());
16284 return sema.addConstant(val_ip_index.toValue());
1632416285 },
1632516286 }
1632616287}
......@@ -16427,7 +16388,7 @@ fn zirBuiltinSrc(
1642716388 // column: u32,
1642816389 (try mod.intValue(Type.u32, extra.column + 1)).toIntern(),
1642916390 };
16430 return sema.addConstant(src_loc_ty, (try mod.intern(.{ .aggregate = .{
16391 return sema.addConstant((try mod.intern(.{ .aggregate = .{
1643116392 .ty = src_loc_ty.toIntern(),
1643216393 .storage = .{ .elems = &fields },
1643316394 } })).toValue());
......@@ -16453,7 +16414,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1645316414 .Undefined,
1645416415 .Null,
1645516416 .EnumLiteral,
16456 => |type_info_tag| return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16417 => |type_info_tag| return sema.addConstant((try mod.intern(.{ .un = .{
1645716418 .ty = type_info_ty.toIntern(),
1645816419 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(type_info_tag))).toIntern(),
1645916420 .val = .void_value,
......@@ -16562,7 +16523,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1656216523 // args: []const Fn.Param,
1656316524 args_val,
1656416525 };
16565 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16526 return sema.addConstant((try mod.intern(.{ .un = .{
1656616527 .ty = type_info_ty.toIntern(),
1656716528 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Fn))).toIntern(),
1656816529 .val = try mod.intern(.{ .aggregate = .{
......@@ -16591,7 +16552,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1659116552 // bits: u16,
1659216553 (try mod.intValue(Type.u16, info.bits)).toIntern(),
1659316554 };
16594 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16555 return sema.addConstant((try mod.intern(.{ .un = .{
1659516556 .ty = type_info_ty.toIntern(),
1659616557 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Int))).toIntern(),
1659716558 .val = try mod.intern(.{ .aggregate = .{
......@@ -16616,7 +16577,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1661616577 // bits: u16,
1661716578 (try mod.intValue(Type.u16, ty.bitSize(mod))).toIntern(),
1661816579 };
16619 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16580 return sema.addConstant((try mod.intern(.{ .un = .{
1662016581 .ty = type_info_ty.toIntern(),
1662116582 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Float))).toIntern(),
1662216583 .val = try mod.intern(.{ .aggregate = .{
......@@ -16679,7 +16640,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1667916640 else => info.sentinel.toValue(),
1668016641 })).toIntern(),
1668116642 };
16682 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16643 return sema.addConstant((try mod.intern(.{ .un = .{
1668316644 .ty = type_info_ty.toIntern(),
1668416645 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Pointer))).toIntern(),
1668516646 .val = try mod.intern(.{ .aggregate = .{
......@@ -16711,7 +16672,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1671116672 // sentinel: ?*const anyopaque,
1671216673 (try sema.optRefValue(block, info.elem_type, info.sentinel)).toIntern(),
1671316674 };
16714 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16675 return sema.addConstant((try mod.intern(.{ .un = .{
1671516676 .ty = type_info_ty.toIntern(),
1671616677 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Array))).toIntern(),
1671716678 .val = try mod.intern(.{ .aggregate = .{
......@@ -16741,7 +16702,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1674116702 // child: type,
1674216703 info.elem_type.toIntern(),
1674316704 };
16744 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16705 return sema.addConstant((try mod.intern(.{ .un = .{
1674516706 .ty = type_info_ty.toIntern(),
1674616707 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Vector))).toIntern(),
1674716708 .val = try mod.intern(.{ .aggregate = .{
......@@ -16768,7 +16729,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1676816729 // child: type,
1676916730 ty.optionalChild(mod).toIntern(),
1677016731 };
16771 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16732 return sema.addConstant((try mod.intern(.{ .un = .{
1677216733 .ty = type_info_ty.toIntern(),
1677316734 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Optional))).toIntern(),
1677416735 .val = try mod.intern(.{ .aggregate = .{
......@@ -16877,7 +16838,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1687716838 } });
1687816839
1687916840 // Construct Type{ .ErrorSet = errors_val }
16880 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16841 return sema.addConstant((try mod.intern(.{ .un = .{
1688116842 .ty = type_info_ty.toIntern(),
1688216843 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.ErrorSet))).toIntern(),
1688316844 .val = errors_val,
......@@ -16903,7 +16864,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1690316864 // payload: type,
1690416865 ty.errorUnionPayload(mod).toIntern(),
1690516866 };
16906 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16867 return sema.addConstant((try mod.intern(.{ .un = .{
1690716868 .ty = type_info_ty.toIntern(),
1690816869 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.ErrorUnion))).toIntern(),
1690916870 .val = try mod.intern(.{ .aggregate = .{
......@@ -17029,7 +16990,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1702916990 // is_exhaustive: bool,
1703016991 is_exhaustive.toIntern(),
1703116992 };
17032 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
16993 return sema.addConstant((try mod.intern(.{ .un = .{
1703316994 .ty = type_info_ty.toIntern(),
1703416995 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Enum))).toIntern(),
1703516996 .val = try mod.intern(.{ .aggregate = .{
......@@ -17180,7 +17141,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1718017141 // decls: []const Declaration,
1718117142 decls_val,
1718217143 };
17183 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
17144 return sema.addConstant((try mod.intern(.{ .un = .{
1718417145 .ty = type_info_ty.toIntern(),
1718517146 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Union))).toIntern(),
1718617147 .val = try mod.intern(.{ .aggregate = .{
......@@ -17409,7 +17370,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1740917370 // is_tuple: bool,
1741017371 Value.makeBool(struct_ty.isTuple(mod)).toIntern(),
1741117372 };
17412 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
17373 return sema.addConstant((try mod.intern(.{ .un = .{
1741317374 .ty = type_info_ty.toIntern(),
1741417375 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Struct))).toIntern(),
1741517376 .val = try mod.intern(.{ .aggregate = .{
......@@ -17441,7 +17402,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1744117402 // decls: []const Declaration,
1744217403 decls_val,
1744317404 };
17444 return sema.addConstant(type_info_ty, (try mod.intern(.{ .un = .{
17405 return sema.addConstant((try mod.intern(.{ .un = .{
1744517406 .ty = type_info_ty.toIntern(),
1744617407 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Opaque))).toIntern(),
1744717408 .val = try mod.intern(.{ .aggregate = .{
......@@ -18187,7 +18148,7 @@ fn zirRetErrValue(
1818718148 const src = inst_data.src();
1818818149 // Return the error code from the function.
1818918150 const error_set_type = try mod.singleErrorSetType(err_name);
18190 const result_inst = try sema.addConstant(error_set_type, (try mod.intern(.{ .err = .{
18151 const result_inst = try sema.addConstant((try mod.intern(.{ .err = .{
1819118152 .ty = error_set_type.toIntern(),
1819218153 .name = err_name,
1819318154 } })).toValue());
......@@ -18613,7 +18574,7 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
1861318574 switch (obj_ty.zigTypeTag(mod)) {
1861418575 .Struct => return sema.structInitEmpty(block, obj_ty, src, src),
1861518576 .Array, .Vector => return sema.arrayInitEmpty(block, src, obj_ty),
18616 .Void => return sema.addConstant(obj_ty, Value.void),
18577 .Void => return sema.addConstant(Value.void),
1861718578 .Union => return sema.fail(block, src, "union initializer must initialize one field", .{}),
1861818579 else => return sema.failWithArrayInitNotSupported(block, src, obj_ty),
1861918580 }
......@@ -18649,7 +18610,7 @@ fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) Com
1864918610 return sema.fail(block, src, "expected {d} vector elements; found 0", .{arr_len});
1865018611 }
1865118612 }
18652 return sema.addConstant(obj_ty, (try mod.intern(.{ .aggregate = .{
18613 return sema.addConstant((try mod.intern(.{ .aggregate = .{
1865318614 .ty = obj_ty.toIntern(),
1865418615 .storage = .{ .elems = &.{} },
1865518616 } })).toValue());
......@@ -18686,7 +18647,7 @@ fn unionInit(
1868618647 const tag_ty = union_ty.unionTagTypeHypothetical(mod);
1868718648 const enum_field_index = @intCast(u32, tag_ty.enumFieldIndex(field_name, mod).?);
1868818649 const tag_val = try mod.enumValueFieldIndex(tag_ty, enum_field_index);
18689 return sema.addConstant(union_ty, (try mod.intern(.{ .un = .{
18650 return sema.addConstant((try mod.intern(.{ .un = .{
1869018651 .ty = union_ty.toIntern(),
1869118652 .tag = try tag_val.intern(tag_ty, mod),
1869218653 .val = try init_val.intern(field.ty, mod),
......@@ -18808,7 +18769,7 @@ fn zirStructInit(
1880818769 const alloc = try block.addTy(.alloc, alloc_ty);
1880918770 const field_ptr = try sema.unionFieldPtr(block, field_src, alloc, field_name, field_src, resolved_ty, true);
1881018771 try sema.storePtr(block, src, field_ptr, init_inst);
18811 const new_tag = try sema.addConstant(resolved_ty.unionTagTypeHypothetical(mod), tag_val);
18772 const new_tag = try sema.addConstant(tag_val);
1881218773 _ = try block.addBinOp(.set_union_tag, alloc, new_tag);
1881318774 return sema.makePtrConst(block, alloc);
1881418775 }
......@@ -18839,7 +18800,7 @@ fn finishStructInit(
1883918800
1884018801 switch (ip.indexToKey(struct_ty.toIntern())) {
1884118802 .anon_struct_type => |anon_struct| {
18842 for (anon_struct.types, anon_struct.values, 0..) |field_ty, default_val, i| {
18803 for (anon_struct.values, 0..) |default_val, i| {
1884318804 if (field_inits[i] != .none) continue;
1884418805
1884518806 if (default_val == .none) {
......@@ -18861,7 +18822,7 @@ fn finishStructInit(
1886118822 }
1886218823 }
1886318824 } else {
18864 field_inits[i] = try sema.addConstant(field_ty.toType(), default_val.toValue());
18825 field_inits[i] = try sema.addConstant(default_val.toValue());
1886518826 }
1886618827 }
1886718828 },
......@@ -18880,7 +18841,7 @@ fn finishStructInit(
1888018841 root_msg = try sema.errMsg(block, init_src, template, args);
1888118842 }
1888218843 } else {
18883 field_inits[i] = try sema.addConstant(field.ty, field.default_val.toValue());
18844 field_inits[i] = try sema.addConstant(field.default_val.toValue());
1888418845 }
1888518846 }
1888618847 },
......@@ -19119,7 +19080,7 @@ fn zirArrayInit(
1911919080 }
1912019081
1912119082 if (sentinel_val) |some| {
19122 resolved_args[resolved_args.len - 1] = try sema.addConstant(array_ty.elemType2(mod), some);
19083 resolved_args[resolved_args.len - 1] = try sema.addConstant(some);
1912319084 }
1912419085
1912519086 const opt_runtime_index: ?u32 = for (resolved_args, 0..) |arg, i| {
......@@ -19288,7 +19249,7 @@ fn addConstantMaybeRef(
1928819249 val: Value,
1928919250 is_ref: bool,
1929019251) !Air.Inst.Ref {
19291 if (!is_ref) return sema.addConstant(ty, val);
19252 if (!is_ref) return sema.addConstant(val);
1929219253
1929319254 var anon_decl = try block.startAnonDecl();
1929419255 defer anon_decl.deinit();
......@@ -19399,7 +19360,7 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
1939919360 {
1940019361 return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
1940119362 }
19402 return sema.addConstant(opt_ptr_stack_trace_ty, (try mod.intern(.{ .opt = .{
19363 return sema.addConstant((try mod.intern(.{ .opt = .{
1940319364 .ty = opt_ptr_stack_trace_ty.toIntern(),
1940419365 .val = .none,
1940519366 } })).toValue());
......@@ -19426,7 +19387,7 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
1942619387 if (val.isLazyAlign(mod)) {
1942719388 try sema.queueFullTypeResolution(ty);
1942819389 }
19429 return sema.addConstant(Type.comptime_int, val);
19390 return sema.addConstant(val);
1943019391}
1943119392
1943219393fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -19435,8 +19396,8 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
1943519396 const operand = try sema.resolveInst(inst_data.operand);
1943619397 if (try sema.resolveMaybeUndefVal(operand)) |val| {
1943719398 if (val.isUndef(mod)) return sema.addConstUndef(Type.u1);
19438 if (val.toBool()) return sema.addConstant(Type.u1, try mod.intValue(Type.u1, 1));
19439 return sema.addConstant(Type.u1, try mod.intValue(Type.u1, 0));
19399 if (val.toBool()) return sema.addConstant(try mod.intValue(Type.u1, 1));
19400 return sema.addConstant(try mod.intValue(Type.u1, 0));
1944019401 }
1944119402 return block.addUnOp(.int_from_bool, operand);
1944219403}
......@@ -19501,7 +19462,7 @@ fn zirUnaryMath(
1950119462 const elem_val = try val.elemValue(sema.mod, i);
1950219463 elem.* = try (try eval(elem_val, scalar_ty, sema.arena, sema.mod)).intern(scalar_ty, mod);
1950319464 }
19504 return sema.addConstant(result_ty, (try mod.intern(.{ .aggregate = .{
19465 return sema.addConstant((try mod.intern(.{ .aggregate = .{
1950519466 .ty = result_ty.toIntern(),
1950619467 .storage = .{ .elems = elems },
1950719468 } })).toValue());
......@@ -19515,7 +19476,7 @@ fn zirUnaryMath(
1951519476 if (operand_val.isUndef(mod))
1951619477 return sema.addConstUndef(operand_ty);
1951719478 const result_val = try eval(operand_val, operand_ty, sema.arena, sema.mod);
19518 return sema.addConstant(operand_ty, result_val);
19479 return sema.addConstant(result_val);
1951919480 }
1952019481
1952119482 try sema.requireRuntimeBlock(block, operand_src, null);
......@@ -20762,7 +20723,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
2076220723
2076320724 if (try sema.resolveMaybeUndefVal(operand)) |val| {
2076420725 const result_val = try sema.intFromFloat(block, operand_src, val, operand_ty, dest_ty);
20765 return sema.addConstant(dest_ty, result_val);
20726 return sema.addConstant(result_val);
2076620727 } else if (dest_ty.zigTypeTag(mod) == .ComptimeInt) {
2076720728 return sema.failWithNeededComptime(block, operand_src, "value being casted to 'comptime_int' must be comptime-known");
2076820729 }
......@@ -20770,17 +20731,17 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
2077020731 try sema.requireRuntimeBlock(block, inst_data.src(), operand_src);
2077120732 if (dest_ty.intInfo(mod).bits == 0) {
2077220733 if (block.wantSafety()) {
20773 const ok = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, try sema.addConstant(operand_ty, try mod.floatValue(operand_ty, 0.0)));
20734 const ok = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, try sema.addConstant(try mod.floatValue(operand_ty, 0.0)));
2077420735 try sema.addSafetyCheck(block, ok, .integer_part_out_of_bounds);
2077520736 }
20776 return sema.addConstant(dest_ty, try mod.intValue(dest_ty, 0));
20737 return sema.addConstant(try mod.intValue(dest_ty, 0));
2077720738 }
2077820739 const result = try block.addTyOp(if (block.float_mode == .Optimized) .int_from_float_optimized else .int_from_float, dest_ty, operand);
2077920740 if (block.wantSafety()) {
2078020741 const back = try block.addTyOp(.float_from_int, operand_ty, result);
2078120742 const diff = try block.addBinOp(.sub, operand, back);
20782 const ok_pos = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_lt_optimized else .cmp_lt, diff, try sema.addConstant(operand_ty, try mod.floatValue(operand_ty, 1.0)));
20783 const ok_neg = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_gt_optimized else .cmp_gt, diff, try sema.addConstant(operand_ty, try mod.floatValue(operand_ty, -1.0)));
20743 const ok_pos = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_lt_optimized else .cmp_lt, diff, try sema.addConstant(try mod.floatValue(operand_ty, 1.0)));
20744 const ok_neg = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_gt_optimized else .cmp_gt, diff, try sema.addConstant(try mod.floatValue(operand_ty, -1.0)));
2078420745 const ok = try block.addBinOp(.bool_and, ok_pos, ok_neg);
2078520746 try sema.addSafetyCheck(block, ok, .integer_part_out_of_bounds);
2078620747 }
......@@ -20802,7 +20763,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
2080220763
2080320764 if (try sema.resolveMaybeUndefVal(operand)) |val| {
2080420765 const result_val = try val.floatFromIntAdvanced(sema.arena, operand_ty, dest_ty, sema.mod, sema);
20805 return sema.addConstant(dest_ty, result_val);
20766 return sema.addConstant(result_val);
2080620767 } else if (dest_ty.zigTypeTag(mod) == .ComptimeFloat) {
2080720768 return sema.failWithNeededComptime(block, operand_src, "value being casted to 'comptime_float' must be comptime-known");
2080820769 }
......@@ -20853,7 +20814,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2085320814 .Pointer => try mod.ptrIntValue(ptr_ty, addr),
2085420815 else => unreachable,
2085520816 };
20856 return sema.addConstant(ptr_ty, ptr_val);
20817 return sema.addConstant(ptr_val);
2085720818 }
2085820819
2085920820 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -20865,7 +20826,6 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2086520826
2086620827 if (ptr_align > 1) {
2086720828 const align_minus_1 = try sema.addConstant(
20868 Type.usize,
2086920829 try mod.intValue(Type.usize, ptr_align - 1),
2087020830 );
2087120831 const remainder = try block.addBinOp(.bit_and, operand_coerced, align_minus_1);
......@@ -20952,7 +20912,7 @@ fn zirErrSetCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
2095220912 }
2095320913 }
2095420914
20955 return sema.addConstant(dest_ty, try mod.getCoerced(val, dest_ty));
20915 return sema.addConstant(try mod.getCoerced(val, dest_ty));
2095620916 }
2095720917
2095820918 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -21074,7 +21034,7 @@ fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
2107421034 if (!dest_ty.ptrAllowsZero(mod) and operand_val.isNull(mod)) {
2107521035 return sema.fail(block, operand_src, "null pointer casted to type '{}'", .{dest_ty.fmt(mod)});
2107621036 }
21077 return sema.addConstant(aligned_dest_ty, try mod.getCoerced(operand_val, aligned_dest_ty));
21037 return sema.addConstant(try mod.getCoerced(operand_val, aligned_dest_ty));
2107821038 }
2107921039
2108021040 try sema.requireRuntimeBlock(block, src, null);
......@@ -21108,7 +21068,7 @@ fn zirConstCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData
2110821068 const dest_ty = try mod.ptrType(ptr_info);
2110921069
2111021070 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
21111 return sema.addConstant(dest_ty, try mod.getCoerced(operand_val, dest_ty));
21071 return sema.addConstant(try mod.getCoerced(operand_val, dest_ty));
2111221072 }
2111321073
2111421074 try sema.requireRuntimeBlock(block, src, null);
......@@ -21129,7 +21089,7 @@ fn zirVolatileCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
2112921089 const dest_ty = try mod.ptrType(ptr_info);
2113021090
2113121091 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
21132 return sema.addConstant(dest_ty, operand_val);
21092 return sema.addConstant(operand_val);
2113321093 }
2113421094
2113521095 try sema.requireRuntimeBlock(block, src, null);
......@@ -21164,13 +21124,13 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2116421124 const dest_info = dest_scalar_ty.intInfo(mod);
2116521125
2116621126 if (try sema.typeHasOnePossibleValue(dest_ty)) |val| {
21167 return sema.addConstant(dest_ty, val);
21127 return sema.addConstant(val);
2116821128 }
2116921129
2117021130 if (operand_scalar_ty.zigTypeTag(mod) != .ComptimeInt) {
2117121131 const operand_info = operand_ty.intInfo(mod);
2117221132 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21173 return sema.addConstant(operand_ty, val);
21133 return sema.addConstant(val);
2117421134 }
2117521135
2117621136 if (operand_info.signedness != dest_info.signedness) {
......@@ -21202,7 +21162,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2120221162 if (try sema.resolveMaybeUndefValIntable(operand)) |val| {
2120321163 if (val.isUndef(mod)) return sema.addConstUndef(dest_ty);
2120421164 if (!is_vector) {
21205 return sema.addConstant(dest_ty, try mod.getCoerced(
21165 return sema.addConstant(try mod.getCoerced(
2120621166 try val.intTrunc(operand_ty, sema.arena, dest_info.signedness, dest_info.bits, mod),
2120721167 dest_ty,
2120821168 ));
......@@ -21212,7 +21172,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2121221172 const elem_val = try val.elemValue(mod, i);
2121321173 elem.* = try (try elem_val.intTrunc(operand_scalar_ty, sema.arena, dest_info.signedness, dest_info.bits, mod)).intern(dest_scalar_ty, mod);
2121421174 }
21215 return sema.addConstant(dest_ty, (try mod.intern(.{ .aggregate = .{
21175 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2121621176 .ty = dest_ty.toIntern(),
2121721177 .storage = .{ .elems = elems },
2121821178 } })).toValue());
......@@ -21248,7 +21208,7 @@ fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2124821208 return sema.fail(block, ptr_src, "pointer address 0x{X} is not aligned to {d} bytes", .{ addr, dest_align_bytes });
2124921209 }
2125021210 }
21251 return sema.addConstant(dest_ty, try mod.getCoerced(val, dest_ty));
21211 return sema.addConstant(try mod.getCoerced(val, dest_ty));
2125221212 }
2125321213
2125421214 try sema.requireRuntimeBlock(block, inst_data.src(), ptr_src);
......@@ -21256,7 +21216,6 @@ fn zirAlignCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2125621216 try sema.typeHasRuntimeBits(ptr_info.child.toType()))
2125721217 {
2125821218 const align_minus_1 = try sema.addConstant(
21259 Type.usize,
2126021219 try mod.intValue(Type.usize, dest_align.toByteUnitsOptional().? - 1),
2126121220 );
2126221221 const actual_ptr = if (ptr_ty.isSlice(mod))
......@@ -21293,7 +21252,7 @@ fn zirBitCount(
2129321252 const bits = operand_ty.intInfo(mod).bits;
2129421253
2129521254 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21296 return sema.addConstant(operand_ty, val);
21255 return sema.addConstant(val);
2129721256 }
2129821257
2129921258 const result_scalar_ty = try mod.smallestUnsignedInt(bits);
......@@ -21314,7 +21273,7 @@ fn zirBitCount(
2131421273 const count = comptimeOp(elem_val, scalar_ty, mod);
2131521274 elem.* = (try mod.intValue(result_scalar_ty, count)).toIntern();
2131621275 }
21317 return sema.addConstant(result_ty, (try mod.intern(.{ .aggregate = .{
21276 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2131821277 .ty = result_ty.toIntern(),
2131921278 .storage = .{ .elems = elems },
2132021279 } })).toValue());
......@@ -21355,7 +21314,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2135521314 }
2135621315
2135721316 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21358 return sema.addConstant(operand_ty, val);
21317 return sema.addConstant(val);
2135921318 }
2136021319
2136121320 switch (operand_ty.zigTypeTag(mod)) {
......@@ -21363,7 +21322,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2136321322 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
2136421323 if (val.isUndef(mod)) return sema.addConstUndef(operand_ty);
2136521324 const result_val = try val.byteSwap(operand_ty, mod, sema.arena);
21366 return sema.addConstant(operand_ty, result_val);
21325 return sema.addConstant(result_val);
2136721326 } else operand_src;
2136821327
2136921328 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -21380,7 +21339,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2138021339 const elem_val = try val.elemValue(mod, i);
2138121340 elem.* = try (try elem_val.byteSwap(scalar_ty, mod, sema.arena)).intern(scalar_ty, mod);
2138221341 }
21383 return sema.addConstant(operand_ty, (try mod.intern(.{ .aggregate = .{
21342 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2138421343 .ty = operand_ty.toIntern(),
2138521344 .storage = .{ .elems = elems },
2138621345 } })).toValue());
......@@ -21402,7 +21361,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2140221361 const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src);
2140321362
2140421363 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21405 return sema.addConstant(operand_ty, val);
21364 return sema.addConstant(val);
2140621365 }
2140721366
2140821367 const mod = sema.mod;
......@@ -21411,7 +21370,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2141121370 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
2141221371 if (val.isUndef(mod)) return sema.addConstUndef(operand_ty);
2141321372 const result_val = try val.bitReverse(operand_ty, mod, sema.arena);
21414 return sema.addConstant(operand_ty, result_val);
21373 return sema.addConstant(result_val);
2141521374 } else operand_src;
2141621375
2141721376 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -21428,7 +21387,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2142821387 const elem_val = try val.elemValue(mod, i);
2142921388 elem.* = try (try elem_val.bitReverse(scalar_ty, mod, sema.arena)).intern(scalar_ty, mod);
2143021389 }
21431 return sema.addConstant(operand_ty, (try mod.intern(.{ .aggregate = .{
21390 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2143221391 .ty = operand_ty.toIntern(),
2143321392 .storage = .{ .elems = elems },
2143421393 } })).toValue());
......@@ -22081,7 +22040,7 @@ fn zirCmpxchg(
2208122040
2208222041 // special case zero bit types
2208322042 if ((try sema.typeHasOnePossibleValue(elem_ty)) != null) {
22084 return sema.addConstant(result_ty, (try mod.intern(.{ .opt = .{
22043 return sema.addConstant((try mod.intern(.{ .opt = .{
2208522044 .ty = result_ty.toIntern(),
2208622045 .val = .none,
2208722046 } })).toValue());
......@@ -22104,7 +22063,7 @@ fn zirCmpxchg(
2210422063 break :blk .none;
2210522064 } else stored_val.toIntern(),
2210622065 } });
22107 return sema.addConstant(result_ty, result_val.toValue());
22066 return sema.addConstant(result_val.toValue());
2210822067 } else break :rs new_value_src;
2210922068 } else break :rs expected_src;
2211022069 } else ptr_src;
......@@ -22143,7 +22102,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
2214322102 });
2214422103 if (try sema.resolveMaybeUndefVal(scalar)) |scalar_val| {
2214522104 if (scalar_val.isUndef(mod)) return sema.addConstUndef(vector_ty);
22146 return sema.addConstant(vector_ty, try sema.splat(vector_ty, scalar_val));
22105 return sema.addConstant(try sema.splat(vector_ty, scalar_val));
2214722106 }
2214822107
2214922108 try sema.requireRuntimeBlock(block, inst_data.src(), scalar_src);
......@@ -22206,7 +22165,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
2220622165 .Mul => accum = try accum.numberMulWrap(elem_val, scalar_ty, sema.arena, mod),
2220722166 }
2220822167 }
22209 return sema.addConstant(scalar_ty, accum);
22168 return sema.addConstant(accum);
2221022169 }
2221122170
2221222171 try sema.requireRuntimeBlock(block, inst_data.src(), operand_src);
......@@ -22353,7 +22312,7 @@ fn analyzeShuffle(
2235322312 const unsigned = if (int >= 0) @intCast(u32, int) else @intCast(u32, ~int);
2235422313 values[i] = try (try (if (int >= 0) a_val else b_val).elemValue(mod, unsigned)).intern(elem_ty, mod);
2235522314 }
22356 return sema.addConstant(res_ty, (try mod.intern(.{ .aggregate = .{
22315 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2235722316 .ty = res_ty.toIntern(),
2235822317 .storage = .{ .elems = values },
2235922318 } })).toValue());
......@@ -22459,7 +22418,7 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
2245922418 elem.* = try (try (if (should_choose_a) a_val else b_val).elemValue(mod, i)).intern(elem_ty, mod);
2246022419 }
2246122420
22462 return sema.addConstant(vec_ty, (try mod.intern(.{ .aggregate = .{
22421 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2246322422 .ty = vec_ty.toIntern(),
2246422423 .storage = .{ .elems = elems },
2246522424 } })).toValue());
......@@ -22521,12 +22480,12 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2252122480 }
2252222481
2252322482 if (try sema.typeHasOnePossibleValue(elem_ty)) |val| {
22524 return sema.addConstant(elem_ty, val);
22483 return sema.addConstant(val);
2252522484 }
2252622485
2252722486 if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
2252822487 if (try sema.pointerDeref(block, ptr_src, ptr_val, sema.typeOf(ptr))) |elem_val| {
22529 return sema.addConstant(elem_ty, elem_val);
22488 return sema.addConstant(elem_val);
2253022489 }
2253122490 }
2253222491
......@@ -22579,7 +22538,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2257922538
2258022539 // special case zero bit types
2258122540 if (try sema.typeHasOnePossibleValue(elem_ty)) |val| {
22582 return sema.addConstant(elem_ty, val);
22541 return sema.addConstant(val);
2258322542 }
2258422543
2258522544 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
......@@ -22605,7 +22564,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2260522564 // zig fmt: on
2260622565 };
2260722566 try sema.storePtrVal(block, src, ptr_val, new_val, elem_ty);
22608 return sema.addConstant(elem_ty, stored_val);
22567 return sema.addConstant(stored_val);
2260922568 } else break :rs ptr_src;
2261022569 } else ptr_src;
2261122570
......@@ -22689,7 +22648,7 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
2268922648 if (maybe_addend) |addend_val| {
2269022649 if (addend_val.isUndef(mod)) return sema.addConstUndef(ty);
2269122650 const result_val = try Value.mulAdd(ty, mulend1_val, mulend2_val, addend_val, sema.arena, sema.mod);
22692 return sema.addConstant(ty, result_val);
22651 return sema.addConstant(result_val);
2269322652 } else {
2269422653 break :rs addend_src;
2269522654 }
......@@ -22899,7 +22858,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
2289922858 };
2290022859 return sema.failWithOwnedErrorMsg(msg);
2290122860 }
22902 return sema.addConstant(result_ptr, field.base.toValue());
22861 return sema.addConstant(field.base.toValue());
2290322862 }
2290422863
2290522864 try sema.requireRuntimeBlock(block, src, ptr_src);
......@@ -23057,7 +23016,7 @@ fn analyzeMinMax(
2305723016
2305823017 const vec_len = simd_op.len orelse {
2305923018 const result_val = opFunc(cur_val, operand_val, mod);
23060 cur_minmax = try sema.addConstant(simd_op.result_ty, result_val);
23019 cur_minmax = try sema.addConstant(result_val);
2306123020 continue;
2306223021 };
2306323022 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
......@@ -23067,7 +23026,7 @@ fn analyzeMinMax(
2306723026 const uncoerced_elem = opFunc(lhs_elem_val, rhs_elem_val, mod);
2306823027 elem.* = (try mod.getCoerced(uncoerced_elem, simd_op.scalar_ty)).toIntern();
2306923028 }
23070 cur_minmax = try sema.addConstant(simd_op.result_ty, (try mod.intern(.{ .aggregate = .{
23029 cur_minmax = try sema.addConstant((try mod.intern(.{ .aggregate = .{
2307123030 .ty = simd_op.result_ty.toIntern(),
2307223031 .storage = .{ .elems = elems },
2307323032 } })).toValue());
......@@ -23384,7 +23343,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2338423343 // Aliasing safety check.
2338523344 if (block.wantSafety()) {
2338623345 const len = if (len_val) |v|
23387 try sema.addConstant(Type.usize, v)
23346 try sema.addConstant(v)
2338823347 else if (dest_len != .none)
2338923348 dest_len
2339023349 else
......@@ -23584,7 +23543,7 @@ fn zirVarExtended(
2358423543
2358523544 try sema.validateVarType(block, ty_src, var_ty, small.is_extern);
2358623545
23587 return sema.addConstant(var_ty, (try mod.intern(.{ .variable = .{
23546 return sema.addConstant((try mod.intern(.{ .variable = .{
2358823547 .ty = var_ty.toIntern(),
2358923548 .init = init_val,
2359023549 .decl = sema.owner_decl_index,
......@@ -24092,7 +24051,7 @@ fn zirBuiltinExtern(
2409224051 try mod.declareDeclDependency(sema.owner_decl_index, new_decl_index);
2409324052 try sema.ensureDeclAnalyzed(new_decl_index);
2409424053
24095 return sema.addConstant(ty, try mod.getCoerced((try mod.intern(.{ .ptr = .{
24054 return sema.addConstant(try mod.getCoerced((try mod.intern(.{ .ptr = .{
2409624055 .ty = switch (mod.intern_pool.indexToKey(ty.toIntern())) {
2409724056 .ptr_type => ty.toIntern(),
2409824057 .opt_type => |child_type| child_type,
......@@ -24736,13 +24695,13 @@ fn panicWithMsg(
2473624695 },
2473724696 });
2473824697 const opt_ptr_stack_trace_ty = try mod.optionalType(ptr_stack_trace_ty.toIntern());
24739 const null_stack_trace = try sema.addConstant(opt_ptr_stack_trace_ty, (try mod.intern(.{ .opt = .{
24698 const null_stack_trace = try sema.addConstant((try mod.intern(.{ .opt = .{
2474024699 .ty = opt_ptr_stack_trace_ty.toIntern(),
2474124700 .val = .none,
2474224701 } })).toValue());
2474324702
2474424703 const opt_usize_ty = try mod.optionalType(.usize_type);
24745 const null_ret_addr = try sema.addConstant(opt_usize_ty, (try mod.intern(.{ .opt = .{
24704 const null_ret_addr = try sema.addConstant((try mod.intern(.{ .opt = .{
2474624705 .ty = opt_usize_ty.toIntern(),
2474724706 .val = .none,
2474824707 } })).toValue());
......@@ -24830,7 +24789,7 @@ fn panicSentinelMismatch(
2483024789 assert(!parent_block.is_comptime);
2483124790 const mod = sema.mod;
2483224791 const expected_sentinel_val = maybe_sentinel orelse return;
24833 const expected_sentinel = try sema.addConstant(sentinel_ty, expected_sentinel_val);
24792 const expected_sentinel = try sema.addConstant(expected_sentinel_val);
2483424793
2483524794 const ptr_ty = sema.typeOf(ptr);
2483624795 const actual_sentinel = if (ptr_ty.isSlice(mod))
......@@ -24967,7 +24926,6 @@ fn fieldVal(
2496724926 .Array => {
2496824927 if (ip.stringEqlSlice(field_name, "len")) {
2496924928 return sema.addConstant(
24970 Type.usize,
2497124929 try mod.intValue(Type.usize, inner_ty.arrayLen(mod)),
2497224930 );
2497324931 } else if (ip.stringEqlSlice(field_name, "ptr") and is_pointer_to) {
......@@ -25059,7 +25017,7 @@ fn fieldVal(
2505925017 child_type
2506025018 else
2506125019 try mod.singleErrorSetType(field_name);
25062 return sema.addConstant(error_set_type, (try mod.intern(.{ .err = .{
25020 return sema.addConstant((try mod.intern(.{ .err = .{
2506325021 .ty = error_set_type.toIntern(),
2506425022 .name = field_name,
2506525023 } })).toValue());
......@@ -25075,7 +25033,6 @@ fn fieldVal(
2507525033 if (enum_ty.enumFieldIndex(field_name, mod)) |field_index_usize| {
2507625034 const field_index = @intCast(u32, field_index_usize);
2507725035 return sema.addConstant(
25078 enum_ty,
2507925036 try mod.enumValueFieldIndex(enum_ty, field_index),
2508025037 );
2508125038 }
......@@ -25092,7 +25049,7 @@ fn fieldVal(
2509225049 return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
2509325050 const field_index = @intCast(u32, field_index_usize);
2509425051 const enum_val = try mod.enumValueFieldIndex(child_type, field_index);
25095 return sema.addConstant(child_type, enum_val);
25052 return sema.addConstant(enum_val);
2509625053 },
2509725054 .Struct, .Opaque => {
2509825055 if (child_type.getNamespaceIndex(mod).unwrap()) |namespace| {
......@@ -25204,7 +25161,7 @@ fn fieldPtr(
2520425161 });
2520525162
2520625163 if (try sema.resolveDefinedValue(block, object_ptr_src, inner_ptr)) |val| {
25207 return sema.addConstant(result_ty, (try mod.intern(.{ .ptr = .{
25164 return sema.addConstant((try mod.intern(.{ .ptr = .{
2520825165 .ty = result_ty.toIntern(),
2520925166 .addr = .{ .field = .{
2521025167 .base = val.toIntern(),
......@@ -25226,7 +25183,7 @@ fn fieldPtr(
2522625183 });
2522725184
2522825185 if (try sema.resolveDefinedValue(block, object_ptr_src, inner_ptr)) |val| {
25229 return sema.addConstant(result_ty, (try mod.intern(.{ .ptr = .{
25186 return sema.addConstant((try mod.intern(.{ .ptr = .{
2523025187 .ty = result_ty.toIntern(),
2523125188 .addr = .{ .field = .{
2523225189 .base = val.toIntern(),
......@@ -25554,12 +25511,12 @@ fn finishFieldCallBind(
2555425511 const container_ty = ptr_ty.childType(mod);
2555525512 if (container_ty.zigTypeTag(mod) == .Struct) {
2555625513 if (try container_ty.structFieldValueComptime(mod, field_index)) |default_val| {
25557 return .{ .direct = try sema.addConstant(field_ty, default_val) };
25514 return .{ .direct = try sema.addConstant(default_val) };
2555825515 }
2555925516 }
2556025517
2556125518 if (try sema.resolveDefinedValue(block, src, object_ptr)) |struct_ptr_val| {
25562 const pointer = try sema.addConstant(ptr_field_ty, (try mod.intern(.{ .ptr = .{
25519 const pointer = try sema.addConstant((try mod.intern(.{ .ptr = .{
2556325520 .ty = ptr_field_ty.toIntern(),
2556425521 .addr = .{ .field = .{
2556525522 .base = struct_ptr_val.toIntern(),
......@@ -25749,7 +25706,7 @@ fn structFieldPtrByIndex(
2574925706 .ty = ptr_field_ty.toIntern(),
2575025707 .addr = .{ .comptime_field = field.default_val },
2575125708 } });
25752 return sema.addConstant(ptr_field_ty, val.toValue());
25709 return sema.addConstant(val.toValue());
2575325710 }
2575425711
2575525712 if (try sema.resolveDefinedValue(block, src, struct_ptr)) |struct_ptr_val| {
......@@ -25760,7 +25717,7 @@ fn structFieldPtrByIndex(
2576025717 .index = field_index,
2576125718 } },
2576225719 } });
25763 return sema.addConstant(ptr_field_ty, val.toValue());
25720 return sema.addConstant(val.toValue());
2576425721 }
2576525722
2576625723 try sema.requireRuntimeBlock(block, src, null);
......@@ -25791,15 +25748,15 @@ fn structFieldVal(
2579125748 const field = struct_obj.fields.values()[field_index];
2579225749
2579325750 if (field.is_comptime) {
25794 return sema.addConstant(field.ty, field.default_val.toValue());
25751 return sema.addConstant(field.default_val.toValue());
2579525752 }
2579625753
2579725754 if (try sema.resolveMaybeUndefVal(struct_byval)) |struct_val| {
2579825755 if (struct_val.isUndef(mod)) return sema.addConstUndef(field.ty);
2579925756 if ((try sema.typeHasOnePossibleValue(field.ty))) |opv| {
25800 return sema.addConstant(field.ty, opv);
25757 return sema.addConstant(opv);
2580125758 }
25802 return sema.addConstant(field.ty, try struct_val.fieldValue(mod, field_index));
25759 return sema.addConstant(try struct_val.fieldValue(mod, field_index));
2580325760 }
2580425761
2580525762 try sema.requireRuntimeBlock(block, src, null);
......@@ -25868,16 +25825,16 @@ fn tupleFieldValByIndex(
2586825825 const field_ty = tuple_ty.structFieldType(field_index, mod);
2586925826
2587025827 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_value| {
25871 return sema.addConstant(field_ty, default_value);
25828 return sema.addConstant(default_value);
2587225829 }
2587325830
2587425831 if (try sema.resolveMaybeUndefVal(tuple_byval)) |tuple_val| {
2587525832 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
25876 return sema.addConstant(field_ty, opv);
25833 return sema.addConstant(opv);
2587725834 }
2587825835 return switch (mod.intern_pool.indexToKey(tuple_val.toIntern())) {
2587925836 .undef => sema.addConstUndef(field_ty),
25880 .aggregate => |aggregate| sema.addConstant(field_ty, switch (aggregate.storage) {
25837 .aggregate => |aggregate| sema.addConstant(switch (aggregate.storage) {
2588125838 .bytes => |bytes| try mod.intValue(Type.u8, bytes[0]),
2588225839 .elems => |elems| elems[field_index].toValue(),
2588325840 .repeated_elem => |elem| elem.toValue(),
......@@ -25887,7 +25844,7 @@ fn tupleFieldValByIndex(
2588725844 }
2588825845
2588925846 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_val| {
25890 return sema.addConstant(field_ty, default_val);
25847 return sema.addConstant(default_val);
2589125848 }
2589225849
2589325850 try sema.requireRuntimeBlock(block, src, null);
......@@ -25966,7 +25923,7 @@ fn unionFieldPtr(
2596625923 },
2596725924 .Packed, .Extern => {},
2596825925 }
25969 return sema.addConstant(ptr_field_ty, (try mod.intern(.{ .ptr = .{
25926 return sema.addConstant((try mod.intern(.{ .ptr = .{
2597025927 .ty = ptr_field_ty.toIntern(),
2597125928 .addr = .{ .field = .{
2597225929 .base = union_ptr_val.toIntern(),
......@@ -25980,7 +25937,7 @@ fn unionFieldPtr(
2598025937 union_ty.unionTagTypeSafety(mod) != null and union_obj.fields.count() > 1)
2598125938 {
2598225939 const wanted_tag_val = try mod.enumValueFieldIndex(union_obj.tag_ty, enum_field_index);
25983 const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);
25940 const wanted_tag = try sema.addConstant(wanted_tag_val);
2598425941 // TODO would it be better if get_union_tag supported pointers to unions?
2598525942 const union_val = try block.addTyOp(.load, union_ty, union_ptr);
2598625943 const active_tag = try block.addTyOp(.get_union_tag, union_obj.tag_ty, union_val);
......@@ -26021,7 +25978,7 @@ fn unionFieldVal(
2602125978 switch (union_obj.layout) {
2602225979 .Auto => {
2602325980 if (tag_matches) {
26024 return sema.addConstant(field.ty, un.val.toValue());
25981 return sema.addConstant(un.val.toValue());
2602525982 } else {
2602625983 const msg = msg: {
2602725984 const active_index = union_obj.tag_ty.enumTagFieldIndex(un.tag.toValue(), mod).?;
......@@ -26038,11 +25995,11 @@ fn unionFieldVal(
2603825995 },
2603925996 .Packed, .Extern => {
2604025997 if (tag_matches) {
26041 return sema.addConstant(field.ty, un.val.toValue());
25998 return sema.addConstant(un.val.toValue());
2604225999 } else {
2604326000 const old_ty = union_ty.unionFieldType(un.tag.toValue(), mod);
2604426001 if (try sema.bitCastVal(block, src, un.val.toValue(), old_ty, field.ty, 0)) |new_val| {
26045 return sema.addConstant(field.ty, new_val);
26002 return sema.addConstant(new_val);
2604626003 }
2604726004 }
2604826005 },
......@@ -26054,7 +26011,7 @@ fn unionFieldVal(
2605426011 union_ty.unionTagTypeSafety(mod) != null and union_obj.fields.count() > 1)
2605526012 {
2605626013 const wanted_tag_val = try mod.enumValueFieldIndex(union_obj.tag_ty, enum_field_index);
26057 const wanted_tag = try sema.addConstant(union_obj.tag_ty, wanted_tag_val);
26014 const wanted_tag = try sema.addConstant(wanted_tag_val);
2605826015 const active_tag = try block.addTyOp(.get_union_tag, union_obj.tag_ty, union_byval);
2605926016 try sema.panicInactiveUnionField(block, active_tag, wanted_tag);
2606026017 }
......@@ -26128,7 +26085,7 @@ fn elemPtrOneLayerOnly(
2612826085 const index = @intCast(usize, index_val.toUnsignedInt(mod));
2612926086 const result_ty = try sema.elemPtrType(indexable_ty, index);
2613026087 const elem_ptr = try ptr_val.elemPtr(result_ty, index, mod);
26131 return sema.addConstant(result_ty, elem_ptr);
26088 return sema.addConstant(elem_ptr);
2613226089 };
2613326090 const result_ty = try sema.elemPtrType(indexable_ty, null);
2613426091
......@@ -26189,7 +26146,7 @@ fn elemVal(
2618926146 const elem_ptr_ty = try mod.singleConstPtrType(elem_ty);
2619026147 const elem_ptr_val = try many_ptr_val.elemPtr(elem_ptr_ty, index, mod);
2619126148 if (try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty)) |elem_val| {
26192 return sema.addConstant(elem_ty, try mod.getCoerced(elem_val, elem_ty));
26149 return sema.addConstant(try mod.getCoerced(elem_val, elem_ty));
2619326150 }
2619426151 break :rs indexable_src;
2619526152 };
......@@ -26205,7 +26162,7 @@ fn elemVal(
2620526162 const index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index) orelse break :arr_sent;
2620626163 const index = try sema.usizeCast(block, src, index_val.toUnsignedInt(mod));
2620726164 if (index != inner_ty.arrayLen(mod)) break :arr_sent;
26208 return sema.addConstant(inner_ty.childType(mod), sentinel);
26165 return sema.addConstant(sentinel);
2620926166 }
2621026167 const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
2621126168 return sema.analyzeLoad(block, indexable_src, elem_ptr, elem_index_src);
......@@ -26291,14 +26248,14 @@ fn tupleFieldPtr(
2629126248 });
2629226249
2629326250 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_val| {
26294 return sema.addConstant(ptr_field_ty, (try mod.intern(.{ .ptr = .{
26251 return sema.addConstant((try mod.intern(.{ .ptr = .{
2629526252 .ty = ptr_field_ty.toIntern(),
2629626253 .addr = .{ .comptime_field = default_val.toIntern() },
2629726254 } })).toValue());
2629826255 }
2629926256
2630026257 if (try sema.resolveMaybeUndefVal(tuple_ptr)) |tuple_ptr_val| {
26301 return sema.addConstant(ptr_field_ty, (try mod.intern(.{ .ptr = .{
26258 return sema.addConstant((try mod.intern(.{ .ptr = .{
2630226259 .ty = ptr_field_ty.toIntern(),
2630326260 .addr = .{ .field = .{
2630426261 .base = tuple_ptr_val.toIntern(),
......@@ -26340,12 +26297,12 @@ fn tupleField(
2634026297 const field_ty = tuple_ty.structFieldType(field_index, mod);
2634126298
2634226299 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_value| {
26343 return sema.addConstant(field_ty, default_value); // comptime field
26300 return sema.addConstant(default_value); // comptime field
2634426301 }
2634526302
2634626303 if (try sema.resolveMaybeUndefVal(tuple)) |tuple_val| {
2634726304 if (tuple_val.isUndef(mod)) return sema.addConstUndef(field_ty);
26348 return sema.addConstant(field_ty, try tuple_val.fieldValue(mod, field_index));
26305 return sema.addConstant(try tuple_val.fieldValue(mod, field_index));
2634926306 }
2635026307
2635126308 try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_src);
......@@ -26383,7 +26340,7 @@ fn elemValArray(
2638326340 const index = @intCast(usize, index_val.toUnsignedInt(mod));
2638426341 if (array_sent) |s| {
2638526342 if (index == array_len) {
26386 return sema.addConstant(elem_ty, s);
26343 return sema.addConstant(s);
2638726344 }
2638826345 }
2638926346 if (index >= array_len_s) {
......@@ -26398,7 +26355,7 @@ fn elemValArray(
2639826355 if (maybe_index_val) |index_val| {
2639926356 const index = @intCast(usize, index_val.toUnsignedInt(mod));
2640026357 const elem_val = try array_val.elemValue(mod, index);
26401 return sema.addConstant(elem_ty, elem_val);
26358 return sema.addConstant(elem_val);
2640226359 }
2640326360 }
2640426361
......@@ -26458,7 +26415,7 @@ fn elemPtrArray(
2645826415 }
2645926416 if (offset) |index| {
2646026417 const elem_ptr = try array_ptr_val.elemPtr(elem_ptr_ty, index, mod);
26461 return sema.addConstant(elem_ptr_ty, elem_ptr);
26418 return sema.addConstant(elem_ptr);
2646226419 }
2646326420 }
2646426421
......@@ -26516,7 +26473,7 @@ fn elemValSlice(
2651626473 const elem_ptr_ty = try sema.elemPtrType(slice_ty, index);
2651726474 const elem_ptr_val = try slice_val.elemPtr(elem_ptr_ty, index, mod);
2651826475 if (try sema.pointerDeref(block, slice_src, elem_ptr_val, elem_ptr_ty)) |elem_val| {
26519 return sema.addConstant(elem_ty, elem_val);
26476 return sema.addConstant(elem_val);
2652026477 }
2652126478 runtime_src = slice_src;
2652226479 }
......@@ -26575,7 +26532,7 @@ fn elemPtrSlice(
2657526532 return sema.fail(block, elem_index_src, "index {d} outside slice of length {d}{s}", .{ index, slice_len, sentinel_label });
2657626533 }
2657726534 const elem_ptr_val = try slice_val.elemPtr(elem_ptr_ty, index, mod);
26578 return sema.addConstant(elem_ptr_ty, elem_ptr_val);
26535 return sema.addConstant(elem_ptr_val);
2657926536 }
2658026537 }
2658126538
......@@ -26684,7 +26641,7 @@ fn coerceExtra(
2668426641
2668526642 // null to ?T
2668626643 if (inst_ty.zigTypeTag(mod) == .Null) {
26687 return sema.addConstant(dest_ty, (try mod.intern(.{ .opt = .{
26644 return sema.addConstant((try mod.intern(.{ .opt = .{
2668826645 .ty = dest_ty.toIntern(),
2668926646 .val = .none,
2669026647 } })).toValue());
......@@ -26856,7 +26813,7 @@ fn coerceExtra(
2685626813 // coercion to C pointer
2685726814 .C => switch (inst_ty.zigTypeTag(mod)) {
2685826815 .Null => {
26859 return sema.addConstant(dest_ty, try mod.getCoerced(Value.null, dest_ty));
26816 return sema.addConstant(try mod.getCoerced(Value.null, dest_ty));
2686026817 },
2686126818 .ComptimeInt => {
2686226819 const addr = sema.coerceExtra(block, Type.usize, inst, inst_src, .{ .report_err = false }) catch |err| switch (err) {
......@@ -26960,7 +26917,7 @@ fn coerceExtra(
2696026917 if (inst_child_ty.structFieldCount(mod) == 0) {
2696126918 // Optional slice is represented with a null pointer so
2696226919 // we use a dummy pointer value with the required alignment.
26963 return sema.addConstant(dest_ty, (try mod.intern(.{ .ptr = .{
26920 return sema.addConstant((try mod.intern(.{ .ptr = .{
2696426921 .ty = dest_ty.toIntern(),
2696526922 .addr = .{ .int = (if (dest_info.flags.alignment != .none)
2696626923 try mod.intValue(Type.usize, dest_info.flags.alignment.toByteUnitsOptional().?)
......@@ -27032,7 +26989,7 @@ fn coerceExtra(
2703226989 );
2703326990 }
2703426991 const result_val = try sema.intFromFloat(block, inst_src, val, inst_ty, dest_ty);
27035 return try sema.addConstant(dest_ty, result_val);
26992 return try sema.addConstant(result_val);
2703626993 },
2703726994 .Int, .ComptimeInt => {
2703826995 if (is_undef) {
......@@ -27044,7 +27001,7 @@ fn coerceExtra(
2704427001 if (!opts.report_err) return error.NotCoercible;
2704527002 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(mod), val.fmtValue(inst_ty, mod) });
2704627003 }
27047 return try sema.addConstant(dest_ty, try mod.getCoerced(val, dest_ty));
27004 return try sema.addConstant(try mod.getCoerced(val, dest_ty));
2704827005 }
2704927006 if (dest_ty.zigTypeTag(mod) == .ComptimeInt) {
2705027007 if (!opts.report_err) return error.NotCoercible;
......@@ -27072,7 +27029,7 @@ fn coerceExtra(
2707227029 .ComptimeFloat => {
2707327030 const val = try sema.resolveConstValue(block, .unneeded, inst, "");
2707427031 const result_val = try val.floatCast(dest_ty, mod);
27075 return try sema.addConstant(dest_ty, result_val);
27032 return try sema.addConstant(result_val);
2707627033 },
2707727034 .Float => {
2707827035 if (is_undef) {
......@@ -27088,7 +27045,7 @@ fn coerceExtra(
2708827045 .{ dest_ty.fmt(mod), val.fmtValue(inst_ty, mod) },
2708927046 );
2709027047 }
27091 return try sema.addConstant(dest_ty, result_val);
27048 return try sema.addConstant(result_val);
2709227049 } else if (dest_ty.zigTypeTag(mod) == .ComptimeFloat) {
2709327050 if (!opts.report_err) return error.NotCoercible;
2709427051 return sema.failWithNeededComptime(block, inst_src, "value being casted to 'comptime_float' must be comptime-known");
......@@ -27124,7 +27081,7 @@ fn coerceExtra(
2712427081 // .{ dest_ty.fmt(mod), val },
2712527082 // );
2712627083 //}
27127 return try sema.addConstant(dest_ty, result_val);
27084 return try sema.addConstant(result_val);
2712827085 },
2712927086 .Undefined => {
2713027087 return sema.addConstUndef(dest_ty);
......@@ -27151,7 +27108,6 @@ fn coerceExtra(
2715127108 return sema.failWithOwnedErrorMsg(msg);
2715227109 };
2715327110 return sema.addConstant(
27154 dest_ty,
2715527111 try mod.enumValueFieldIndex(dest_ty, @intCast(u32, field_index)),
2715627112 );
2715727113 },
......@@ -27176,7 +27132,7 @@ fn coerceExtra(
2717627132 .error_union => |error_union| switch (error_union.val) {
2717727133 .err_name => |err_name| {
2717827134 const error_set_ty = inst_ty.errorUnionSet(mod);
27179 const error_set_val = try sema.addConstant(error_set_ty, (try mod.intern(.{ .err = .{
27135 const error_set_val = try sema.addConstant((try mod.intern(.{ .err = .{
2718027136 .ty = error_set_ty.toIntern(),
2718127137 .name = err_name,
2718227138 } })).toValue());
......@@ -27184,7 +27140,6 @@ fn coerceExtra(
2718427140 },
2718527141 .payload => |payload| {
2718627142 const payload_val = try sema.addConstant(
27187 inst_ty.errorUnionPayload(mod),
2718827143 payload.toValue(),
2718927144 );
2719027145 return sema.wrapErrorUnionPayload(block, dest_ty, payload_val, inst_src) catch |err| switch (err) {
......@@ -27337,7 +27292,7 @@ fn coerceInMemory(
2733727292 val: Value,
2733827293 dst_ty: Type,
2733927294) CompileError!Air.Inst.Ref {
27340 return sema.addConstant(dst_ty, try sema.mod.getCoerced(val, dst_ty));
27295 return sema.addConstant(try sema.mod.getCoerced(val, dst_ty));
2734127296}
2734227297
2734327298const InMemoryCoercionResult = union(enum) {
......@@ -29370,7 +29325,7 @@ fn bitCast(
2937029325
2937129326 if (try sema.resolveMaybeUndefVal(inst)) |val| {
2937229327 if (try sema.bitCastVal(block, inst_src, val, old_ty, dest_ty, 0)) |result_val| {
29373 return sema.addConstant(dest_ty, result_val);
29328 return sema.addConstant(result_val);
2937429329 }
2937529330 }
2937629331 try sema.requireRuntimeBlock(block, inst_src, operand_src);
......@@ -29423,7 +29378,7 @@ fn coerceArrayPtrToSlice(
2942329378 },
2942429379 .len = (try mod.intValue(Type.usize, array_ty.arrayLen(mod))).toIntern(),
2942529380 } });
29426 return sema.addConstant(dest_ty, slice_val.toValue());
29381 return sema.addConstant(slice_val.toValue());
2942729382 }
2942829383 try sema.requireRuntimeBlock(block, inst_src, null);
2942929384 return block.addTyOp(.array_to_slice, dest_ty, inst);
......@@ -29491,7 +29446,6 @@ fn coerceCompatiblePtrs(
2949129446 }
2949229447 // The comptime Value representation is compatible with both types.
2949329448 return sema.addConstant(
29494 dest_ty,
2949529449 try mod.getCoerced((try val.intern(inst_ty, mod)).toValue(), dest_ty),
2949629450 );
2949729451 }
......@@ -29590,7 +29544,7 @@ fn coerceEnumToUnion(
2959029544 return sema.failWithOwnedErrorMsg(msg);
2959129545 };
2959229546
29593 return sema.addConstant(union_ty, try mod.unionValue(union_ty, val, opv));
29547 return sema.addConstant(try mod.unionValue(union_ty, val, opv));
2959429548 }
2959529549
2959629550 try sema.requireRuntimeBlock(block, inst_src, null);
......@@ -29797,7 +29751,7 @@ fn coerceArrayLike(
2979729751 var runtime_src: ?LazySrcLoc = null;
2979829752
2979929753 for (element_vals, element_refs, 0..) |*val, *ref, i| {
29800 const index_ref = try sema.addConstant(Type.usize, try mod.intValue(Type.usize, i));
29754 const index_ref = try sema.addConstant(try mod.intValue(Type.usize, i));
2980129755 const src = inst_src; // TODO better source location
2980229756 const elem_src = inst_src; // TODO better source location
2980329757 const elem_ref = try sema.elemValArray(block, src, inst_src, inst, elem_src, index_ref, true);
......@@ -29817,7 +29771,7 @@ fn coerceArrayLike(
2981729771 return block.addAggregateInit(dest_ty, element_refs);
2981829772 }
2981929773
29820 return sema.addConstant(dest_ty, (try mod.intern(.{ .aggregate = .{
29774 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2982129775 .ty = dest_ty.toIntern(),
2982229776 .storage = .{ .elems = element_vals },
2982329777 } })).toValue());
......@@ -29861,7 +29815,7 @@ fn coerceTupleToArray(
2986129815 if (i_usize == inst_len) {
2986229816 const sentinel_val = dest_ty.sentinel(mod).?;
2986329817 val.* = sentinel_val.toIntern();
29864 ref.* = try sema.addConstant(dest_elem_ty, sentinel_val);
29818 ref.* = try sema.addConstant(sentinel_val);
2986529819 break;
2986629820 }
2986729821 const elem_src = inst_src; // TODO better source location
......@@ -29882,7 +29836,7 @@ fn coerceTupleToArray(
2988229836 return block.addAggregateInit(dest_ty, element_refs);
2988329837 }
2988429838
29885 return sema.addConstant(dest_ty, (try mod.intern(.{ .aggregate = .{
29839 return sema.addConstant((try mod.intern(.{ .aggregate = .{
2988629840 .ty = dest_ty.toIntern(),
2988729841 .storage = .{ .elems = element_vals },
2988829842 } })).toValue());
......@@ -30025,7 +29979,7 @@ fn coerceTupleToStruct(
3002529979 if (runtime_src == null) {
3002629980 field_vals[i] = field.default_val;
3002729981 } else {
30028 field_ref.* = try sema.addConstant(field.ty, field.default_val.toValue());
29982 field_ref.* = try sema.addConstant(field.default_val.toValue());
3002929983 }
3003029984 }
3003129985
......@@ -30047,7 +30001,7 @@ fn coerceTupleToStruct(
3004730001 // TODO: figure out InternPool removals for incremental compilation
3004830002 //errdefer ip.remove(struct_val);
3004930003
30050 return sema.addConstant(struct_ty, struct_val.toValue());
30004 return sema.addConstant(struct_val.toValue());
3005130005}
3005230006
3005330007fn coerceTupleToTuple(
......@@ -30169,12 +30123,7 @@ fn coerceTupleToTuple(
3016930123 if (runtime_src == null) {
3017030124 field_vals[i] = default_val;
3017130125 } else {
30172 const field_ty = switch (ip.indexToKey(tuple_ty.toIntern())) {
30173 .anon_struct_type => |anon_struct_type| anon_struct_type.types[i].toType(),
30174 .struct_type => |struct_type| mod.structPtrUnwrap(struct_type.index).?.fields.values()[i].ty,
30175 else => unreachable,
30176 };
30177 field_ref.* = try sema.addConstant(field_ty, default_val.toValue());
30126 field_ref.* = try sema.addConstant(default_val.toValue());
3017830127 }
3017930128 }
3018030129
......@@ -30190,7 +30139,6 @@ fn coerceTupleToTuple(
3019030139 }
3019130140
3019230141 return sema.addConstant(
30193 tuple_ty,
3019430142 (try mod.intern(.{ .aggregate = .{
3019530143 .ty = tuple_ty.toIntern(),
3019630144 .storage = .{ .elems = field_vals },
......@@ -30316,7 +30264,7 @@ fn analyzeDeclRefInner(sema: *Sema, decl_index: Decl.Index, analyze_fn_body: boo
3031630264 if (analyze_fn_body) {
3031730265 try sema.maybeQueueFuncBodyAnalysis(decl_index);
3031830266 }
30319 return sema.addConstant(ptr_ty, (try mod.intern(.{ .ptr = .{
30267 return sema.addConstant((try mod.intern(.{ .ptr = .{
3032030268 .ty = ptr_ty.toIntern(),
3032130269 .addr = .{ .decl = decl_index },
3032230270 } })).toValue());
......@@ -30391,12 +30339,12 @@ fn analyzeLoad(
3039130339 };
3039230340
3039330341 if (try sema.typeHasOnePossibleValue(elem_ty)) |opv| {
30394 return sema.addConstant(elem_ty, opv);
30342 return sema.addConstant(opv);
3039530343 }
3039630344
3039730345 if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
3039830346 if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |elem_val| {
30399 return sema.addConstant(elem_ty, try mod.getCoerced(elem_val, elem_ty));
30347 return sema.addConstant(try mod.getCoerced(elem_val, elem_ty));
3040030348 }
3040130349 }
3040230350
......@@ -30427,7 +30375,7 @@ fn analyzeSlicePtr(
3042730375 const result_ty = slice_ty.slicePtrFieldType(mod);
3042830376 if (try sema.resolveMaybeUndefVal(slice)) |val| {
3042930377 if (val.isUndef(mod)) return sema.addConstUndef(result_ty);
30430 return sema.addConstant(result_ty, val.slicePtr(mod));
30378 return sema.addConstant(val.slicePtr(mod));
3043130379 }
3043230380 try sema.requireRuntimeBlock(block, slice_src, null);
3043330381 return block.addTyOp(.slice_ptr, result_ty, slice);
......@@ -30765,7 +30713,7 @@ fn analyzeSlice(
3076530713 break :e end;
3076630714 }
3076730715
30768 break :e try sema.addConstant(Type.usize, len_val);
30716 break :e try sema.addConstant(len_val);
3076930717 } else if (slice_ty.isSlice(mod)) {
3077030718 if (!end_is_len) {
3077130719 const end = if (by_length) end: {
......@@ -30978,7 +30926,7 @@ fn analyzeSlice(
3097830926 };
3097930927
3098030928 if (!new_ptr_val.isUndef(mod)) {
30981 return sema.addConstant(return_ty, try mod.getCoerced(
30929 return sema.addConstant(try mod.getCoerced(
3098230930 (try new_ptr_val.intern(new_ptr_ty, mod)).toValue(),
3098330931 return_ty,
3098430932 ));
......@@ -31466,7 +31414,7 @@ fn cmpVector(
3146631414 return sema.addConstUndef(result_ty);
3146731415 }
3146831416 const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_ty);
31469 return sema.addConstant(result_ty, cmp_val);
31417 return sema.addConstant(cmp_val);
3147031418 } else {
3147131419 break :src rhs_src;
3147231420 }
......@@ -31487,7 +31435,7 @@ fn wrapOptional(
3148731435 inst_src: LazySrcLoc,
3148831436) !Air.Inst.Ref {
3148931437 if (try sema.resolveMaybeUndefVal(inst)) |val| {
31490 return sema.addConstant(dest_ty, (try sema.mod.intern(.{ .opt = .{
31438 return sema.addConstant((try sema.mod.intern(.{ .opt = .{
3149131439 .ty = dest_ty.toIntern(),
3149231440 .val = val.toIntern(),
3149331441 } })).toValue());
......@@ -31508,7 +31456,7 @@ fn wrapErrorUnionPayload(
3150831456 const dest_payload_ty = dest_ty.errorUnionPayload(mod);
3150931457 const coerced = try sema.coerceExtra(block, dest_payload_ty, inst, inst_src, .{ .report_err = false });
3151031458 if (try sema.resolveMaybeUndefVal(coerced)) |val| {
31511 return sema.addConstant(dest_ty, (try mod.intern(.{ .error_union = .{
31459 return sema.addConstant((try mod.intern(.{ .error_union = .{
3151231460 .ty = dest_ty.toIntern(),
3151331461 .val = .{ .payload = try val.intern(dest_payload_ty, mod) },
3151431462 } })).toValue());
......@@ -31554,7 +31502,7 @@ fn wrapErrorUnionSet(
3155431502 else => unreachable,
3155531503 },
3155631504 }
31557 return sema.addConstant(dest_ty, (try mod.intern(.{ .error_union = .{
31505 return sema.addConstant((try mod.intern(.{ .error_union = .{
3155831506 .ty = dest_ty.toIntern(),
3155931507 .val = .{
3156031508 .err_name = mod.intern_pool.indexToKey(try val.intern(dest_err_set_ty, mod)).err.name,
......@@ -31576,10 +31524,10 @@ fn unionToTag(
3157631524) !Air.Inst.Ref {
3157731525 const mod = sema.mod;
3157831526 if ((try sema.typeHasOnePossibleValue(enum_ty))) |opv| {
31579 return sema.addConstant(enum_ty, opv);
31527 return sema.addConstant(opv);
3158031528 }
3158131529 if (try sema.resolveMaybeUndefVal(un)) |un_val| {
31582 return sema.addConstant(enum_ty, un_val.unionTag(mod));
31530 return sema.addConstant(un_val.unionTag(mod));
3158331531 }
3158431532 try sema.requireRuntimeBlock(block, un_src, null);
3158531533 return block.addTyOp(.get_union_tag, enum_ty, un);
......@@ -32921,8 +32869,7 @@ fn resolvePeerTypesInner(
3292132869 comptime_val = null;
3292232870 break;
3292332871 };
32924 const uncoerced_field_ty = struct_ty.structFieldType(field_idx, mod);
32925 const uncoerced_field = try sema.addConstant(uncoerced_field_ty, uncoerced_field_val);
32872 const uncoerced_field = try sema.addConstant(uncoerced_field_val);
3292632873 const coerced_inst = sema.coerceExtra(block, field_ty.toType(), uncoerced_field, src, .{ .report_err = false }) catch |err| switch (err) {
3292732874 // It's possible for PTR to give false positives. Just give up on making this a comptime field, we'll get an error later anyway
3292832875 error.NotCoercible => {
......@@ -35311,30 +35258,17 @@ pub fn addType(sema: *Sema, ty: Type) !Air.Inst.Ref {
3531135258
3531235259fn addIntUnsigned(sema: *Sema, ty: Type, int: u64) CompileError!Air.Inst.Ref {
3531335260 const mod = sema.mod;
35314 return sema.addConstant(ty, try mod.intValue(ty, int));
35261 return sema.addConstant(try mod.intValue(ty, int));
3531535262}
3531635263
3531735264fn addConstUndef(sema: *Sema, ty: Type) CompileError!Air.Inst.Ref {
35318 return sema.addConstant(ty, (try sema.mod.intern(.{ .undef = ty.toIntern() })).toValue());
35265 return sema.addConstant((try sema.mod.intern(.{ .undef = ty.toIntern() })).toValue());
3531935266}
3532035267
35321pub fn addConstant(sema: *Sema, ty: Type, val: Value) SemaError!Air.Inst.Ref {
35322 const mod = sema.mod;
35323 const gpa = sema.gpa;
35324
35325 // This assertion can be removed when the `ty` parameter is removed from
35326 // this function thanks to the InternPool transition being complete.
35327 if (std.debug.runtime_safety) {
35328 const val_ty = mod.intern_pool.typeOf(val.toIntern());
35329 if (ty.toIntern() != val_ty) {
35330 std.debug.panic("addConstant type mismatch: '{}' vs '{}'\n", .{
35331 ty.fmt(mod), val_ty.toType().fmt(mod),
35332 });
35333 }
35334 }
35268pub fn addConstant(sema: *Sema, val: Value) SemaError!Air.Inst.Ref {
3533535269 if (@intFromEnum(val.toIntern()) < Air.ref_start_index)
3533635270 return @enumFromInt(Air.Inst.Ref, @intFromEnum(val.toIntern()));
35337 try sema.air_instructions.append(gpa, .{
35271 try sema.air_instructions.append(sema.gpa, .{
3533835272 .tag = .interned,
3533935273 .data = .{ .interned = val.toIntern() },
3534035274 });
......@@ -35418,7 +35352,7 @@ fn analyzeComptimeAlloc(
3541835352
3541935353 try sema.comptime_mutable_decls.append(decl_index);
3542035354 try mod.declareDeclDependency(sema.owner_decl_index, decl_index);
35421 return sema.addConstant(ptr_type, (try mod.intern(.{ .ptr = .{
35355 return sema.addConstant((try mod.intern(.{ .ptr = .{
3542235356 .ty = ptr_type.toIntern(),
3542335357 .addr = .{ .mut_decl = .{
3542435358 .decl = decl_index,