authorgravatar for mlugg@mlugg.co.ukMatthew Lugg <mlugg@mlugg.co.uk> 2023-08-11 14:02:52+01:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-08-11 11:02:24-07:00
log5e0107fbce8f33f84af232c3edc912a81615175f
tree1e937c9434b6502df9eff05a8175f8171985c936
parent8b9161179d08a3f1dc22ea61e6165a0c638bfae3

Sema: remove redundant addConstant functions

After ff37ccd, interned values are trivial to convert to Air refs, using `Air.internedToRef`. This made functions like `Sema.addConstant` effectively redundant. This commit removes `Sema.addConstant` and `Sema.addType`, replacing them with direct usages of `Air.internedToRef`. Additionally, a new helper `Module.undefValue` is added, and the following functions are moved into Module: * `Sema.addConstUndef` -> `Module.undefRef` * `Sema.addUnsignedInt` -> `Module.intRef` (now also works for signed types) The general pattern here is that any `Module.xyzValue` helper may also have a corresponding `Module.xyzRef` helper, which just wraps the call in `Air.internedToRef`.

2 files changed, 595 insertions(+), 670 deletions(-)

src/Module.zig+12
......@@ -6612,6 +6612,14 @@ pub fn enumValueFieldIndex(mod: *Module, ty: Type, field_index: u32) Allocator.E
66126612 } })).toValue();
66136613}
66146614
6615pub fn undefValue(mod: *Module, ty: Type) Allocator.Error!Value {
6616 return (try mod.intern(.{ .undef = ty.toIntern() })).toValue();
6617}
6618
6619pub fn undefRef(mod: *Module, ty: Type) Allocator.Error!Air.Inst.Ref {
6620 return Air.internedToRef((try mod.undefValue(ty)).toIntern());
6621}
6622
66156623pub fn intValue(mod: *Module, ty: Type, x: anytype) Allocator.Error!Value {
66166624 if (std.math.cast(u64, x)) |casted| return intValue_u64(mod, ty, casted);
66176625 if (std.math.cast(i64, x)) |casted| return intValue_i64(mod, ty, casted);
......@@ -6620,6 +6628,10 @@ pub fn intValue(mod: *Module, ty: Type, x: anytype) Allocator.Error!Value {
66206628 return intValue_big(mod, ty, big_int.toConst());
66216629}
66226630
6631pub fn intRef(mod: *Module, ty: Type, x: anytype) Allocator.Error!Air.Inst.Ref {
6632 return Air.internedToRef((try mod.intValue(ty, x)).toIntern());
6633}
6634
66236635pub fn intValue_big(mod: *Module, ty: Type, x: BigIntConst) Allocator.Error!Value {
66246636 const i = try intern(mod, .{ .int = .{
66256637 .ty = ty.toIntern(),
src/Sema.zig+583-670
......@@ -489,7 +489,7 @@ pub const Block = struct {
489489 return block.addInst(.{
490490 .tag = tag,
491491 .data = .{ .ty_op = .{
492 .ty = try block.sema.addType(ty),
492 .ty = Air.internedToRef(ty.toIntern()),
493493 .operand = operand,
494494 } },
495495 });
......@@ -499,7 +499,7 @@ pub const Block = struct {
499499 return block.addInst(.{
500500 .tag = .bitcast,
501501 .data = .{ .ty_op = .{
502 .ty = try block.sema.addType(ty),
502 .ty = Air.internedToRef(ty.toIntern()),
503503 .operand = operand,
504504 } },
505505 });
......@@ -558,7 +558,7 @@ pub const Block = struct {
558558 field_index: u32,
559559 ptr_field_ty: Type,
560560 ) !Air.Inst.Ref {
561 const ty = try block.sema.addType(ptr_field_ty);
561 const ty = Air.internedToRef(ptr_field_ty.toIntern());
562562 const tag: Air.Inst.Tag = switch (field_index) {
563563 0 => .struct_field_ptr_index_0,
564564 1 => .struct_field_ptr_index_1,
......@@ -595,7 +595,7 @@ pub const Block = struct {
595595 return block.addInst(.{
596596 .tag = .struct_field_val,
597597 .data = .{ .ty_pl = .{
598 .ty = try block.sema.addType(field_ty),
598 .ty = Air.internedToRef(field_ty.toIntern()),
599599 .payload = try block.sema.addExtra(Air.StructField{
600600 .struct_operand = struct_val,
601601 .field_index = field_index,
......@@ -613,7 +613,7 @@ pub const Block = struct {
613613 return block.addInst(.{
614614 .tag = .slice_elem_ptr,
615615 .data = .{ .ty_pl = .{
616 .ty = try block.sema.addType(elem_ptr_ty),
616 .ty = Air.internedToRef(elem_ptr_ty.toIntern()),
617617 .payload = try block.sema.addExtra(Air.Bin{
618618 .lhs = slice,
619619 .rhs = elem_index,
......@@ -628,7 +628,7 @@ pub const Block = struct {
628628 elem_index: Air.Inst.Ref,
629629 elem_ptr_ty: Type,
630630 ) !Air.Inst.Ref {
631 const ty_ref = try block.sema.addType(elem_ptr_ty);
631 const ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
632632 return block.addPtrElemPtrTypeRef(array_ptr, elem_index, ty_ref);
633633 }
634634
......@@ -656,12 +656,10 @@ pub const Block = struct {
656656 return block.addInst(.{
657657 .tag = if (block.float_mode == .Optimized) .cmp_vector_optimized else .cmp_vector,
658658 .data = .{ .ty_pl = .{
659 .ty = try sema.addType(
660 try mod.vectorType(.{
661 .len = sema.typeOf(lhs).vectorLen(mod),
662 .child = .bool_type,
663 }),
664 ),
659 .ty = Air.internedToRef((try mod.vectorType(.{
660 .len = sema.typeOf(lhs).vectorLen(mod),
661 .child = .bool_type,
662 })).toIntern()),
665663 .payload = try sema.addExtra(Air.VectorCmp{
666664 .lhs = lhs,
667665 .rhs = rhs,
......@@ -677,7 +675,7 @@ pub const Block = struct {
677675 elements: []const Air.Inst.Ref,
678676 ) !Air.Inst.Ref {
679677 const sema = block.sema;
680 const ty_ref = try sema.addType(aggregate_ty);
678 const ty_ref = Air.internedToRef(aggregate_ty.toIntern());
681679 try sema.air_extra.ensureUnusedCapacity(sema.gpa, elements.len);
682680 const extra_index = @as(u32, @intCast(sema.air_extra.items.len));
683681 sema.appendRefsAssumeCapacity(elements);
......@@ -700,7 +698,7 @@ pub const Block = struct {
700698 return block.addInst(.{
701699 .tag = .union_init,
702700 .data = .{ .ty_pl = .{
703 .ty = try block.sema.addType(union_ty),
701 .ty = Air.internedToRef(union_ty.toIntern()),
704702 .payload = try block.sema.addExtra(Air.UnionInit{
705703 .field_index = field_index,
706704 .init = init,
......@@ -2665,13 +2663,13 @@ fn zirCoerceResultPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
26652663 });
26662664 try sema.maybeQueueFuncBodyAnalysis(decl_index);
26672665 try sema.comptime_mutable_decls.append(decl_index);
2668 return sema.addConstant((try mod.intern(.{ .ptr = .{
2666 return Air.internedToRef((try mod.intern(.{ .ptr = .{
26692667 .ty = ptr_ty.toIntern(),
26702668 .addr = .{ .mut_decl = .{
26712669 .decl = decl_index,
26722670 .runtime_index = block.runtime_index,
26732671 } },
2674 } })).toValue());
2672 } })));
26752673 },
26762674 else => {},
26772675 }
......@@ -2739,10 +2737,10 @@ fn coerceResultPtr(
27392737
27402738 if (trash_block.instructions.items.len == prev_trash_len) {
27412739 if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
2742 return sema.addConstant(ptr_val);
2740 return Air.internedToRef(ptr_val.toIntern());
27432741 }
27442742 if (pointee_ty.eql(Type.null, sema.mod)) {
2745 const null_inst = try sema.addConstant(Value.null);
2743 const null_inst = Air.internedToRef(Value.null.toIntern());
27462744 _ = try block.addBinOp(.store, new_ptr, null_inst);
27472745 return Air.Inst.Ref.void_value;
27482746 }
......@@ -2761,7 +2759,7 @@ fn coerceResultPtr(
27612759 });
27622760
27632761 if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
2764 return sema.addConstant(ptr_val);
2762 return Air.internedToRef(ptr_val.toIntern());
27652763 } else {
27662764 return sema.bitCast(block, ptr_operand_ty, new_ptr, src, null);
27672765 }
......@@ -2774,7 +2772,7 @@ fn coerceResultPtr(
27742772 .flags = .{ .address_space = addr_space },
27752773 });
27762774 if (try sema.resolveDefinedValue(block, src, new_ptr)) |ptr_val| {
2777 new_ptr = try sema.addConstant(try mod.getCoerced(ptr_val, ptr_operand_ty));
2775 new_ptr = Air.internedToRef((try mod.getCoerced(ptr_val, ptr_operand_ty)).toIntern());
27782776 } else {
27792777 new_ptr = try sema.bitCast(block, ptr_operand_ty, new_ptr, src, null);
27802778 }
......@@ -3781,7 +3779,7 @@ fn makePtrConst(sema: *Sema, block: *Block, alloc: Air.Inst.Ref) CompileError!Ai
37813779
37823780 // Detect if a comptime value simply needs to have its type changed.
37833781 if (try sema.resolveMaybeUndefVal(alloc)) |val| {
3784 return sema.addConstant(try mod.getCoerced(val, const_ptr_ty));
3782 return Air.internedToRef((try mod.getCoerced(val, const_ptr_ty)).toIntern());
37853783 }
37863784
37873785 return block.addBitCast(const_ptr_ty, alloc);
......@@ -4332,7 +4330,7 @@ fn zirOptEuBaseTy(
43324330 switch (ty.zigTypeTag(mod)) {
43334331 .Optional => ty = ty.optionalChild(mod),
43344332 .ErrorUnion => ty = ty.errorUnionPayload(mod),
4335 else => return sema.addType(ty),
4333 else => return Air.internedToRef(ty.toIntern()),
43364334 }
43374335 }
43384336}
......@@ -4584,14 +4582,14 @@ fn validateUnionInit(
45844582 .ty = union_ty.toIntern(),
45854583 .val = union_val,
45864584 } });
4587 const union_init = try sema.addConstant(union_val.toValue());
4585 const union_init = Air.internedToRef(union_val);
45884586 try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store);
45894587 return;
45904588 } else if (try sema.typeRequiresComptime(union_ty)) {
45914589 return sema.failWithNeededComptime(block, field_ptr_data.src(), "initializer of comptime only union must be comptime-known");
45924590 }
45934591
4594 const new_tag = try sema.addConstant(tag_val);
4592 const new_tag = Air.internedToRef(tag_val.toIntern());
45954593 _ = try block.addBinOp(.set_union_tag, union_ptr, new_tag);
45964594}
45974595
......@@ -4685,7 +4683,7 @@ fn validateStructInit(
46854683 try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @as(u32, @intCast(i)), true)
46864684 else
46874685 try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @as(u32, @intCast(i)), field_src, struct_ty, true);
4688 const init = try sema.addConstant(default_val);
4686 const init = Air.internedToRef(default_val.toIntern());
46894687 try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
46904688 }
46914689
......@@ -4876,7 +4874,7 @@ fn validateStructInit(
48764874 .ty = struct_ty.toIntern(),
48774875 .val = struct_val,
48784876 } });
4879 const struct_init = try sema.addConstant(struct_val.toValue());
4877 const struct_init = Air.internedToRef(struct_val);
48804878 try sema.storePtr2(block, init_src, struct_ptr, init_src, struct_init, init_src, .store);
48814879 return;
48824880 }
......@@ -4891,7 +4889,7 @@ fn validateStructInit(
48914889 try sema.tupleFieldPtr(block, init_src, struct_ptr, field_src, @as(u32, @intCast(i)), true)
48924890 else
48934891 try sema.structFieldPtrByIndex(block, init_src, struct_ptr, @as(u32, @intCast(i)), field_src, struct_ty, true);
4894 const init = try sema.addConstant(field_values[i].toValue());
4892 const init = Air.internedToRef(field_values[i]);
48954893 try sema.storePtr2(block, init_src, default_field_ptr, init_src, init, field_src, .store);
48964894 }
48974895}
......@@ -4956,9 +4954,9 @@ fn zirValidateArrayInit(
49564954 // sentinel-terminated array, the sentinel will not have been populated by
49574955 // any ZIR instructions at comptime; we need to do that here.
49584956 if (array_ty.sentinel(mod)) |sentinel_val| {
4959 const array_len_ref = try sema.addIntUnsigned(Type.usize, array_len);
4957 const array_len_ref = try mod.intRef(Type.usize, array_len);
49604958 const sentinel_ptr = try sema.elemPtrArray(block, init_src, init_src, array_ptr, init_src, array_len_ref, true, true);
4961 const sentinel = try sema.addConstant(sentinel_val);
4959 const sentinel = Air.internedToRef(sentinel_val.toIntern());
49624960 try sema.storePtr2(block, init_src, sentinel_ptr, init_src, sentinel, init_src, .store);
49634961 }
49644962 return;
......@@ -4966,7 +4964,7 @@ fn zirValidateArrayInit(
49664964
49674965 // If the array has one possible value, the value is always comptime-known.
49684966 if (try sema.typeHasOnePossibleValue(array_ty)) |array_opv| {
4969 const array_init = try sema.addConstant(array_opv);
4967 const array_init = Air.internedToRef(array_opv.toIntern());
49704968 try sema.storePtr2(block, init_src, array_ptr, init_src, array_init, init_src, .store);
49714969 return;
49724970 }
......@@ -5101,7 +5099,7 @@ fn zirValidateArrayInit(
51015099 .ty = array_ty.toIntern(),
51025100 .val = array_val,
51035101 } });
5104 const array_init = try sema.addConstant(array_val.toValue());
5102 const array_init = Air.internedToRef(array_val);
51055103 try sema.storePtr2(block, init_src, array_ptr, init_src, array_init, init_src, .store);
51065104 }
51075105}
......@@ -5435,7 +5433,7 @@ fn zirInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
54355433 defer tracy.end();
54365434
54375435 const int = sema.code.instructions.items(.data)[inst].int;
5438 return sema.addIntUnsigned(Type.comptime_int, int);
5436 return sema.mod.intRef(Type.comptime_int, int);
54395437}
54405438
54415439fn zirIntBig(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -5454,20 +5452,19 @@ fn zirIntBig(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
54545452 const limbs = try sema.arena.alloc(std.math.big.Limb, int.len);
54555453 @memcpy(mem.sliceAsBytes(limbs), limb_bytes);
54565454
5457 return sema.addConstant(
5458 try mod.intValue_big(Type.comptime_int, .{
5459 .limbs = limbs,
5460 .positive = true,
5461 }),
5462 );
5455 return Air.internedToRef((try mod.intValue_big(Type.comptime_int, .{
5456 .limbs = limbs,
5457 .positive = true,
5458 })).toIntern());
54635459}
54645460
54655461fn zirFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
54665462 _ = block;
54675463 const number = sema.code.instructions.items(.data)[inst].float;
5468 return sema.addConstant(
5469 try sema.mod.floatValue(Type.comptime_float, number),
5470 );
5464 return Air.internedToRef((try sema.mod.floatValue(
5465 Type.comptime_float,
5466 number,
5467 )).toIntern());
54715468}
54725469
54735470fn zirFloat128(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -5475,9 +5472,7 @@ fn zirFloat128(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
54755472 const inst_data = sema.code.instructions.items(.data)[inst].pl_node;
54765473 const extra = sema.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data;
54775474 const number = extra.get();
5478 return sema.addConstant(
5479 try sema.mod.floatValue(Type.comptime_float, number),
5480 );
5475 return Air.internedToRef((try sema.mod.floatValue(Type.comptime_float, number)).toIntern());
54815476}
54825477
54835478fn zirCompileError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Zir.Inst.Index {
......@@ -5742,7 +5737,7 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
57425737 const file_root_decl_index = result.file.root_decl.unwrap().?;
57435738 const file_root_decl = mod.declPtr(file_root_decl_index);
57445739 try mod.declareDeclDependency(sema.owner_decl_index, file_root_decl_index);
5745 return sema.addConstant(file_root_decl.val);
5740 return Air.internedToRef(file_root_decl.val.toIntern());
57465741}
57475742
57485743fn zirSuspendBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -5904,7 +5899,7 @@ fn analyzeBlockBody(
59045899 };
59055900 return sema.failWithOwnedErrorMsg(msg);
59065901 }
5907 const ty_inst = try sema.addType(resolved_ty);
5902 const ty_inst = Air.internedToRef(resolved_ty.toIntern());
59085903 try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).Struct.fields.len +
59095904 child_block.instructions.items.len);
59105905 sema.air_instructions.items(.data)[merges.block_inst] = .{ .ty_pl = .{
......@@ -6498,7 +6493,7 @@ pub fn analyzeSaveErrRetIndex(sema: *Sema, block: *Block) SemaError!Air.Inst.Ref
64986493 return try block.addInst(.{
64996494 .tag = .save_err_return_trace_index,
65006495 .data = .{ .ty_pl = .{
6501 .ty = try sema.addType(stack_trace_ty),
6496 .ty = Air.internedToRef(stack_trace_ty.toIntern()),
65026497 .payload = @as(u32, @intCast(field_index)),
65036498 } },
65046499 });
......@@ -6685,7 +6680,7 @@ fn zirCall(
66856680 const save_inst = try block.insertInst(block_index, .{
66866681 .tag = .save_err_return_trace_index,
66876682 .data = .{ .ty_pl = .{
6688 .ty = try sema.addType(stack_trace_ty),
6683 .ty = Air.internedToRef(stack_trace_ty.toIntern()),
66896684 .payload = @as(u32, @intCast(field_index)),
66906685 } },
66916686 });
......@@ -6938,7 +6933,7 @@ const CallArgsInfo = union(enum) {
69386933 // TODO set comptime_reason
69396934 }
69406935 // Give the arg its result type
6941 sema.inst_map.putAssumeCapacity(zir_call.call_inst, try sema.addType(param_ty));
6936 sema.inst_map.putAssumeCapacity(zir_call.call_inst, Air.internedToRef(param_ty.toIntern()));
69426937 // Resolve the arg!
69436938 const uncoerced_arg = try sema.resolveBody(block, arg_body, zir_call.call_inst);
69446939
......@@ -7398,9 +7393,7 @@ fn analyzeCall(
73987393 .result = .none,
73997394 } })) |memoized_call_index| {
74007395 const memoized_call = mod.intern_pool.indexToKey(memoized_call_index).memoized_call;
7401 break :res2 try sema.addConstant(
7402 memoized_call.result.toValue(),
7403 );
7396 break :res2 Air.internedToRef(memoized_call.result);
74047397 }
74057398 }
74067399
......@@ -8057,7 +8050,7 @@ fn emitDbgInline(
80578050 _ = try block.addInst(.{
80588051 .tag = tag,
80598052 .data = .{ .ty_fn = .{
8060 .ty = try sema.addType(new_func_ty),
8053 .ty = Air.internedToRef(new_func_ty.toIntern()),
80618054 .func = new_func,
80628055 } },
80638056 });
......@@ -8067,7 +8060,7 @@ fn zirIntType(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
80678060 const mod = sema.mod;
80688061 const int_type = sema.code.instructions.items(.data)[inst].int_type;
80698062 const ty = try mod.intType(int_type.signedness, int_type.bit_count);
8070 return sema.addType(ty);
8063 return Air.internedToRef(ty.toIntern());
80718064}
80728065
80738066fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8085,7 +8078,7 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
80858078 }
80868079 const opt_type = try mod.optionalType(child_type.toIntern());
80878080
8088 return sema.addType(opt_type);
8081 return Air.internedToRef(opt_type.toIntern());
80898082}
80908083
80918084fn zirElemTypeIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8103,10 +8096,10 @@ fn zirElemTypeIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
81038096 assert(indexable_ty.isIndexable(mod)); // validated by a previous instruction
81048097 if (indexable_ty.zigTypeTag(mod) == .Struct) {
81058098 const elem_type = indexable_ty.structFieldType(@intFromEnum(bin.rhs), mod);
8106 return sema.addType(elem_type);
8099 return Air.internedToRef(elem_type.toIntern());
81078100 } else {
81088101 const elem_type = indexable_ty.elemType2(mod);
8109 return sema.addType(elem_type);
8102 return Air.internedToRef(elem_type.toIntern());
81108103 }
81118104}
81128105
......@@ -8115,7 +8108,7 @@ fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
81158108 const un_node = sema.code.instructions.items(.data)[inst].un_node;
81168109 const ptr_ty = try sema.resolveType(block, .unneeded, un_node.operand);
81178110 assert(ptr_ty.zigTypeTag(mod) == .Pointer); // validated by a previous instruction
8118 return sema.addType(ptr_ty.childType(mod));
8111 return Air.internedToRef(ptr_ty.childType(mod).toIntern());
81198112}
81208113
81218114fn zirVectorElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8132,7 +8125,7 @@ fn zirVectorElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
81328125 if (!vec_ty.isVector(mod)) {
81338126 return sema.fail(block, un_node.src(), "expected vector type, found '{}'", .{vec_ty.fmt(mod)});
81348127 }
8135 return sema.addType(vec_ty.childType(mod));
8128 return Air.internedToRef(vec_ty.childType(mod).toIntern());
81368129}
81378130
81388131fn zirVectorType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8148,7 +8141,7 @@ fn zirVectorType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
81488141 .len = len,
81498142 .child = elem_type.toIntern(),
81508143 });
8151 return sema.addType(vector_type);
8144 return Air.internedToRef(vector_type.toIntern());
81528145}
81538146
81548147fn zirArrayType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8167,7 +8160,7 @@ fn zirArrayType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
81678160 .child = elem_type.toIntern(),
81688161 });
81698162
8170 return sema.addType(array_ty);
8163 return Air.internedToRef(array_ty.toIntern());
81718164}
81728165
81738166fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8191,7 +8184,7 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
81918184 .child = elem_type.toIntern(),
81928185 });
81938186
8194 return sema.addType(array_ty);
8187 return Air.internedToRef(array_ty.toIntern());
81958188}
81968189
81978190fn validateArrayElemType(sema: *Sema, block: *Block, elem_type: Type, elem_src: LazySrcLoc) !void {
......@@ -8216,7 +8209,7 @@ fn zirAnyframeType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
82168209 const return_type = try sema.resolveType(block, operand_src, inst_data.operand);
82178210 const anyframe_type = try mod.anyframeType(return_type);
82188211
8219 return sema.addType(anyframe_type);
8212 return Air.internedToRef(anyframe_type.toIntern());
82208213}
82218214
82228215fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8238,7 +8231,7 @@ fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
82388231 }
82398232 try sema.validateErrorUnionPayloadType(block, payload, rhs_src);
82408233 const err_union_ty = try mod.errorUnionType(error_set, payload);
8241 return sema.addType(err_union_ty);
8234 return Air.internedToRef(err_union_ty.toIntern());
82428235}
82438236
82448237fn validateErrorUnionPayloadType(sema: *Sema, block: *Block, payload_ty: Type, payload_src: LazySrcLoc) !void {
......@@ -8262,10 +8255,10 @@ fn zirErrorValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
82628255 _ = try mod.getErrorValue(name);
82638256 // Create an error set type with only this error value, and return the value.
82648257 const error_set_type = try mod.singleErrorSetType(name);
8265 return sema.addConstant((try mod.intern(.{ .err = .{
8258 return Air.internedToRef((try mod.intern(.{ .err = .{
82668259 .ty = error_set_type.toIntern(),
82678260 .name = name,
8268 } })).toValue());
8261 } })));
82698262}
82708263
82718264fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
......@@ -8282,13 +8275,13 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
82828275
82838276 if (try sema.resolveMaybeUndefVal(operand)) |val| {
82848277 if (val.isUndef(mod)) {
8285 return sema.addConstUndef(Type.err_int);
8278 return mod.undefRef(Type.err_int);
82868279 }
82878280 const err_name = ip.indexToKey(val.toIntern()).err.name;
8288 return sema.addConstant(try mod.intValue(
8281 return Air.internedToRef((try mod.intValue(
82898282 Type.err_int,
82908283 try mod.getErrorValue(err_name),
8291 ));
8284 )).toIntern());
82928285 }
82938286
82948287 const op_ty = sema.typeOf(uncasted_operand);
......@@ -8297,10 +8290,10 @@ fn zirIntFromError(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
82978290 else => |err_set_ty_index| {
82988291 const names = ip.indexToKey(err_set_ty_index).error_set_type.names;
82998292 switch (names.len) {
8300 0 => return sema.addConstant(try mod.intValue(Type.err_int, 0)),
8293 0 => return Air.internedToRef((try mod.intValue(Type.err_int, 0)).toIntern()),
83018294 1 => {
83028295 const int: Module.ErrorInt = @intCast(mod.global_error_set.getIndex(names.get(ip)[0]).?);
8303 return sema.addIntUnsigned(Type.err_int, int);
8296 return mod.intRef(Type.err_int, int);
83048297 },
83058298 else => {},
83068299 }
......@@ -8326,15 +8319,15 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD
83268319 const int = try sema.usizeCast(block, operand_src, value.toUnsignedInt(mod));
83278320 if (int > mod.global_error_set.count() or int == 0)
83288321 return sema.fail(block, operand_src, "integer value '{d}' represents no error", .{int});
8329 return sema.addConstant((try mod.intern(.{ .err = .{
8322 return Air.internedToRef((try mod.intern(.{ .err = .{
83308323 .ty = .anyerror_type,
83318324 .name = mod.global_error_set.keys()[int],
8332 } })).toValue());
8325 } })));
83338326 }
83348327 try sema.requireRuntimeBlock(block, src, operand_src);
83358328 if (block.wantSafety()) {
83368329 const is_lt_len = try block.addUnOp(.cmp_lt_errors_len, operand);
8337 const zero_val = try sema.addConstant(try mod.intValue(Type.err_int, 0));
8330 const zero_val = Air.internedToRef((try mod.intValue(Type.err_int, 0)).toIntern());
83388331 const is_non_zero = try block.addBinOp(.cmp_neq, operand, zero_val);
83398332 const ok = try block.addBinOp(.bit_and, is_lt_len, is_non_zero);
83408333 try sema.addSafetyCheck(block, src, ok, .invalid_error_code);
......@@ -8411,9 +8404,9 @@ fn zirEnumLiteral(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
84118404 const mod = sema.mod;
84128405 const inst_data = sema.code.instructions.items(.data)[inst].str_tok;
84138406 const name = inst_data.get(sema.code);
8414 return sema.addConstant((try mod.intern(.{
8407 return Air.internedToRef((try mod.intern(.{
84158408 .enum_literal = try mod.intern_pool.getOrPutString(sema.gpa, name),
8416 })).toValue());
8409 })));
84178410}
84188411
84198412fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -8449,12 +8442,12 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
84498442 const int_tag_ty = enum_tag_ty.intTagType(mod);
84508443
84518444 if (try sema.typeHasOnePossibleValue(enum_tag_ty)) |opv| {
8452 return sema.addConstant(try mod.getCoerced(opv, int_tag_ty));
8445 return Air.internedToRef((try mod.getCoerced(opv, int_tag_ty)).toIntern());
84538446 }
84548447
84558448 if (try sema.resolveMaybeUndefVal(enum_tag)) |enum_tag_val| {
84568449 const val = try enum_tag_val.intFromEnum(enum_tag_ty, mod);
8457 return sema.addConstant(val);
8450 return Air.internedToRef(val.toIntern());
84588451 }
84598452
84608453 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -8479,7 +8472,7 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
84798472 if (dest_ty.isNonexhaustiveEnum(mod)) {
84808473 const int_tag_ty = dest_ty.intTagType(mod);
84818474 if (try sema.intFitsInType(int_val, int_tag_ty, null)) {
8482 return sema.addConstant(try mod.getCoerced(int_val, dest_ty));
8475 return Air.internedToRef((try mod.getCoerced(int_val, dest_ty)).toIntern());
84838476 }
84848477 const msg = msg: {
84858478 const msg = try sema.errMsg(
......@@ -8511,11 +8504,11 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
85118504 };
85128505 return sema.failWithOwnedErrorMsg(msg);
85138506 }
8514 return sema.addConstant(try mod.getCoerced(int_val, dest_ty));
8507 return Air.internedToRef((try mod.getCoerced(int_val, dest_ty)).toIntern());
85158508 }
85168509
85178510 if (try sema.typeHasOnePossibleValue(dest_ty)) |opv| {
8518 const result = try sema.addConstant(opv);
8511 const result = Air.internedToRef(opv.toIntern());
85198512 // The operand is runtime-known but the result is comptime-known. In
85208513 // this case we still need a safety check.
85218514 // TODO add a safety check here. we can't use is_named_enum_value -
......@@ -8585,20 +8578,20 @@ fn analyzeOptionalPayloadPtr(
85858578 // we need to emit a runtime instruction to do it.
85868579 _ = try block.addTyOp(.optional_payload_ptr_set, child_pointer, optional_ptr);
85878580 }
8588 return sema.addConstant((try mod.intern(.{ .ptr = .{
8581 return Air.internedToRef((try mod.intern(.{ .ptr = .{
85898582 .ty = child_pointer.toIntern(),
85908583 .addr = .{ .opt_payload = ptr_val.toIntern() },
8591 } })).toValue());
8584 } })));
85928585 }
85938586 if (try sema.pointerDeref(block, src, ptr_val, optional_ptr_ty)) |val| {
85948587 if (val.isNull(mod)) {
85958588 return sema.fail(block, src, "unable to unwrap null", .{});
85968589 }
85978590 // The same Value represents the pointer to the optional and the payload.
8598 return sema.addConstant((try mod.intern(.{ .ptr = .{
8591 return Air.internedToRef((try mod.intern(.{ .ptr = .{
85998592 .ty = child_pointer.toIntern(),
86008593 .addr = .{ .opt_payload = ptr_val.toIntern() },
8601 } })).toValue());
8594 } })));
86028595 }
86038596 }
86048597
......@@ -8654,7 +8647,7 @@ fn zirOptionalPayload(
86548647
86558648 if (try sema.resolveDefinedValue(block, src, operand)) |val| {
86568649 return if (val.optionalValue(mod)) |payload|
8657 sema.addConstant(payload)
8650 Air.internedToRef(payload.toIntern())
86588651 else
86598652 sema.fail(block, src, "unable to unwrap null", .{});
86608653 }
......@@ -8705,9 +8698,7 @@ fn analyzeErrUnionPayload(
87058698 if (val.getErrorName(mod).unwrap()) |name| {
87068699 return sema.fail(block, src, "caught unexpected error '{}'", .{name.fmt(&mod.intern_pool)});
87078700 }
8708 return sema.addConstant(
8709 mod.intern_pool.indexToKey(val.toIntern()).error_union.val.payload.toValue(),
8710 );
8701 return Air.internedToRef(mod.intern_pool.indexToKey(val.toIntern()).error_union.val.payload);
87118702 }
87128703
87138704 try sema.requireRuntimeBlock(block, src, null);
......@@ -8775,19 +8766,19 @@ fn analyzeErrUnionPayloadPtr(
87758766 try sema.requireRuntimeBlock(block, src, null);
87768767 _ = try block.addTyOp(.errunion_payload_ptr_set, operand_pointer_ty, operand);
87778768 }
8778 return sema.addConstant((try mod.intern(.{ .ptr = .{
8769 return Air.internedToRef((try mod.intern(.{ .ptr = .{
87798770 .ty = operand_pointer_ty.toIntern(),
87808771 .addr = .{ .eu_payload = ptr_val.toIntern() },
8781 } })).toValue());
8772 } })));
87828773 }
87838774 if (try sema.pointerDeref(block, src, ptr_val, operand_ty)) |val| {
87848775 if (val.getErrorName(mod).unwrap()) |name| {
87858776 return sema.fail(block, src, "caught unexpected error '{}'", .{name.fmt(&mod.intern_pool)});
87868777 }
8787 return sema.addConstant((try mod.intern(.{ .ptr = .{
8778 return Air.internedToRef((try mod.intern(.{ .ptr = .{
87888779 .ty = operand_pointer_ty.toIntern(),
87898780 .addr = .{ .eu_payload = ptr_val.toIntern() },
8790 } })).toValue());
8781 } })));
87918782 }
87928783 }
87938784
......@@ -8830,10 +8821,10 @@ fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air
88308821 const result_ty = operand_ty.errorUnionSet(mod);
88318822
88328823 if (try sema.resolveDefinedValue(block, src, operand)) |val| {
8833 return sema.addConstant((try mod.intern(.{ .err = .{
8824 return Air.internedToRef((try mod.intern(.{ .err = .{
88348825 .ty = result_ty.toIntern(),
88358826 .name = mod.intern_pool.indexToKey(val.toIntern()).error_union.val.err_name,
8836 } })).toValue());
8827 } })));
88378828 }
88388829
88398830 try sema.requireRuntimeBlock(block, src, null);
......@@ -8863,7 +8854,7 @@ fn zirErrUnionCodePtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
88638854 if (try sema.resolveDefinedValue(block, src, operand)) |pointer_val| {
88648855 if (try sema.pointerDeref(block, src, pointer_val, operand_ty)) |val| {
88658856 assert(val.getErrorName(mod) != .none);
8866 return sema.addConstant(val);
8857 return Air.internedToRef(val.toIntern());
88678858 }
88688859 }
88698860
......@@ -9770,9 +9761,10 @@ fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
97709761 return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ty.fmt(mod)});
97719762 }
97729763 if (try sema.resolveMaybeUndefValIntable(ptr)) |ptr_val| {
9773 return sema.addConstant(
9774 try mod.intValue(Type.usize, (try ptr_val.getUnsignedIntAdvanced(mod, sema)).?),
9775 );
9764 return Air.internedToRef((try mod.intValue(
9765 Type.usize,
9766 (try ptr_val.getUnsignedIntAdvanced(mod, sema)).?,
9767 )).toIntern());
97769768 }
97779769 try sema.requireRuntimeBlock(block, inst_data.src(), ptr_src);
97789770 return block.addUnOp(.int_from_ptr, ptr);
......@@ -9881,7 +9873,7 @@ fn intCast(
98819873 if (wanted_bits == 0) {
98829874 const ok = if (is_vector) ok: {
98839875 const zeros = try sema.splat(operand_ty, try mod.intValue(operand_scalar_ty, 0));
9884 const zero_inst = try sema.addConstant(zeros);
9876 const zero_inst = Air.internedToRef(zeros.toIntern());
98859877 const is_in_range = try block.addCmpVector(operand, zero_inst, .eq);
98869878 const all_in_range = try block.addInst(.{
98879879 .tag = .reduce,
......@@ -9889,7 +9881,7 @@ fn intCast(
98899881 });
98909882 break :ok all_in_range;
98919883 } else ok: {
9892 const zero_inst = try sema.addConstant(try mod.intValue(operand_ty, 0));
9884 const zero_inst = Air.internedToRef((try mod.intValue(operand_ty, 0)).toIntern());
98939885 const is_in_range = try block.addBinOp(.cmp_lte, operand, zero_inst);
98949886 break :ok is_in_range;
98959887 };
......@@ -9897,7 +9889,7 @@ fn intCast(
98979889 }
98989890 }
98999891
9900 return sema.addConstant(opv);
9892 return Air.internedToRef(opv.toIntern());
99019893 }
99029894
99039895 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -9914,7 +9906,7 @@ fn intCast(
99149906 if (wanted_value_bits < actual_value_bits) {
99159907 const dest_max_val_scalar = try dest_scalar_ty.maxIntScalar(mod, operand_scalar_ty);
99169908 const dest_max_val = try sema.splat(operand_ty, dest_max_val_scalar);
9917 const dest_max = try sema.addConstant(dest_max_val);
9909 const dest_max = Air.internedToRef(dest_max_val.toIntern());
99189910 const diff = try block.addBinOp(.sub_wrap, dest_max, operand);
99199911
99209912 if (actual_info.signedness == .signed) {
......@@ -9930,7 +9922,7 @@ fn intCast(
99309922 const range_minus_one = try dest_max_val.shl(one, unsigned_operand_ty, sema.arena, mod);
99319923 break :range_val try sema.intAdd(range_minus_one, one, unsigned_operand_ty, undefined);
99329924 } else try mod.getCoerced(dest_max_val, unsigned_operand_ty);
9933 const dest_range = try sema.addConstant(dest_range_val);
9925 const dest_range = Air.internedToRef(dest_range_val.toIntern());
99349926
99359927 const ok = if (is_vector) ok: {
99369928 const is_in_range = try block.addCmpVector(diff_unsigned, dest_range, .lte);
......@@ -9971,7 +9963,7 @@ fn intCast(
99719963 const ok = if (is_vector) ok: {
99729964 const scalar_zero = try mod.intValue(operand_scalar_ty, 0);
99739965 const zero_val = try sema.splat(operand_ty, scalar_zero);
9974 const zero_inst = try sema.addConstant(zero_val);
9966 const zero_inst = Air.internedToRef(zero_val.toIntern());
99759967 const is_in_range = try block.addCmpVector(operand, zero_inst, .gte);
99769968 const all_in_range = try block.addInst(.{
99779969 .tag = if (block.float_mode == .Optimized) .reduce_optimized else .reduce,
......@@ -9982,7 +9974,7 @@ fn intCast(
99829974 });
99839975 break :ok all_in_range;
99849976 } else ok: {
9985 const zero_inst = try sema.addConstant(try mod.intValue(operand_ty, 0));
9977 const zero_inst = Air.internedToRef((try mod.intValue(operand_ty, 0)).toIntern());
99869978 const is_in_range = try block.addBinOp(.cmp_gte, operand, zero_inst);
99879979 break :ok is_in_range;
99889980 };
......@@ -10172,7 +10164,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
1017210164 }
1017310165
1017410166 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
10175 return sema.addConstant(try operand_val.floatCast(dest_ty, mod));
10167 return Air.internedToRef((try operand_val.floatCast(dest_ty, mod)).toIntern());
1017610168 }
1017710169 if (dest_is_comptime_float) {
1017810170 return sema.fail(block, operand_src, "unable to cast runtime value to 'comptime_float'", .{});
......@@ -10260,7 +10252,7 @@ fn zirElemPtrImm(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1026010252 const src = inst_data.src();
1026110253 const extra = sema.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data;
1026210254 const array_ptr = try sema.resolveInst(extra.ptr);
10263 const elem_index = try sema.addIntUnsigned(Type.usize, extra.index);
10255 const elem_index = try sema.mod.intRef(Type.usize, extra.index);
1026410256 return sema.elemPtr(block, src, array_ptr, elem_index, src, true, true);
1026510257}
1026610258
......@@ -10541,21 +10533,19 @@ const SwitchProngAnalysis = struct {
1054110533 },
1054210534 });
1054310535 if (try sema.resolveDefinedValue(block, sema.src, spa.operand_ptr)) |union_ptr| {
10544 return sema.addConstant(
10545 (try mod.intern(.{ .ptr = .{
10546 .ty = ptr_field_ty.toIntern(),
10547 .addr = .{ .field = .{
10548 .base = union_ptr.toIntern(),
10549 .index = field_index,
10550 } },
10551 } })).toValue(),
10552 );
10536 return Air.internedToRef((try mod.intern(.{ .ptr = .{
10537 .ty = ptr_field_ty.toIntern(),
10538 .addr = .{ .field = .{
10539 .base = union_ptr.toIntern(),
10540 .index = field_index,
10541 } },
10542 } })));
1055310543 }
1055410544 return block.addStructFieldPtr(spa.operand_ptr, field_index, ptr_field_ty);
1055510545 } else {
1055610546 if (try sema.resolveDefinedValue(block, sema.src, spa.operand)) |union_val| {
1055710547 const tag_and_val = mod.intern_pool.indexToKey(union_val.toIntern()).un;
10558 return sema.addConstant(tag_and_val.val.toValue());
10548 return Air.internedToRef(tag_and_val.val);
1055910549 }
1056010550 return block.addStructFieldVal(spa.operand, field_index, field_ty);
1056110551 }
......@@ -10607,7 +10597,7 @@ const SwitchProngAnalysis = struct {
1060710597 // We need values to run PTR on, so make a bunch of undef constants.
1060810598 const dummy_captures = try sema.arena.alloc(Air.Inst.Ref, case_vals.len);
1060910599 for (dummy_captures, field_tys) |*dummy, field_ty| {
10610 dummy.* = try sema.addConstUndef(field_ty);
10600 dummy.* = try mod.undefRef(field_ty);
1061110601 }
1061210602
1061310603 const case_srcs = try sema.arena.alloc(?LazySrcLoc, case_vals.len);
......@@ -10685,16 +10675,14 @@ const SwitchProngAnalysis = struct {
1068510675 }
1068610676
1068710677 if (try sema.resolveDefinedValue(block, operand_src, spa.operand_ptr)) |op_ptr_val| {
10688 if (op_ptr_val.isUndef(mod)) return sema.addConstUndef(capture_ptr_ty);
10689 return sema.addConstant(
10690 (try mod.intern(.{ .ptr = .{
10691 .ty = capture_ptr_ty.toIntern(),
10692 .addr = .{ .field = .{
10693 .base = op_ptr_val.toIntern(),
10694 .index = first_field_index,
10695 } },
10696 } })).toValue(),
10697 );
10678 if (op_ptr_val.isUndef(mod)) return mod.undefRef(capture_ptr_ty);
10679 return Air.internedToRef((try mod.intern(.{ .ptr = .{
10680 .ty = capture_ptr_ty.toIntern(),
10681 .addr = .{ .field = .{
10682 .base = op_ptr_val.toIntern(),
10683 .index = first_field_index,
10684 } },
10685 } })));
1069810686 }
1069910687
1070010688 try sema.requireRuntimeBlock(block, operand_src, null);
......@@ -10702,10 +10690,10 @@ const SwitchProngAnalysis = struct {
1070210690 }
1070310691
1070410692 if (try sema.resolveDefinedValue(block, operand_src, spa.operand)) |operand_val| {
10705 if (operand_val.isUndef(mod)) return sema.addConstUndef(capture_ty);
10693 if (operand_val.isUndef(mod)) return mod.undefRef(capture_ty);
1070610694 const union_val = mod.intern_pool.indexToKey(operand_val.toIntern()).un;
10707 if (union_val.tag.toValue().isUndef(mod)) return sema.addConstUndef(capture_ty);
10708 const uncoerced = try sema.addConstant(union_val.val.toValue());
10695 if (union_val.tag.toValue().isUndef(mod)) return mod.undefRef(capture_ty);
10696 const uncoerced = Air.internedToRef(union_val.val);
1070910697 return sema.coerce(block, capture_ty, uncoerced, operand_src);
1071010698 }
1071110699
......@@ -10751,7 +10739,7 @@ const SwitchProngAnalysis = struct {
1075110739 .tag = .block,
1075210740 .data = .{
1075310741 .ty_pl = .{
10754 .ty = try sema.addType(capture_ty),
10742 .ty = Air.internedToRef(capture_ty.toIntern()),
1075510743 .payload = undefined, // updated below
1075610744 },
1075710745 },
......@@ -10896,7 +10884,7 @@ fn switchCond(
1089610884 return sema.fail(block, src, "switch on type '{}'", .{operand_ty.fmt(mod)});
1089710885 }
1089810886 if ((try sema.typeHasOnePossibleValue(operand_ty))) |opv| {
10899 return sema.addConstant(opv);
10887 return Air.internedToRef(opv.toIntern());
1090010888 }
1090110889 return operand;
1090210890 },
......@@ -11876,7 +11864,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1187611864 }) {
1187711865 cases_len += 1;
1187811866
11879 const item_ref = try sema.addConstant(item);
11867 const item_ref = Air.internedToRef(item.toIntern());
1188011868
1188111869 case_block.instructions.shrinkRetainingCapacity(0);
1188211870 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -12124,7 +12112,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1212412112 cases_len += 1;
1212512113
1212612114 const item_val = try mod.enumValueFieldIndex(operand_ty, @as(u32, @intCast(i)));
12127 const item_ref = try sema.addConstant(item_val);
12115 const item_ref = Air.internedToRef(item_val.toIntern());
1212812116
1212912117 case_block.instructions.shrinkRetainingCapacity(0);
1213012118 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -12174,7 +12162,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1217412162 .ty = operand_ty.toIntern(),
1217512163 .name = error_name,
1217612164 } });
12177 const item_ref = try sema.addConstant(item_val.toValue());
12165 const item_ref = Air.internedToRef(item_val);
1217812166
1217912167 case_block.instructions.shrinkRetainingCapacity(0);
1218012168 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -12205,7 +12193,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r
1220512193 while (try it.next()) |cur| {
1220612194 cases_len += 1;
1220712195
12208 const item_ref = try sema.addConstant(cur.toValue());
12196 const item_ref = Air.internedToRef(cur);
1220912197
1221012198 case_block.instructions.shrinkRetainingCapacity(0);
1221112199 case_block.wip_capture_scope = child_block.wip_capture_scope;
......@@ -12483,7 +12471,7 @@ fn resolveSwitchItemVal(
1248312471
1248412472 const val = try sema.resolveLazyValue(maybe_lazy);
1248512473 const new_item = if (val.toIntern() != maybe_lazy.toIntern()) blk: {
12486 break :blk try sema.addConstant(val);
12474 break :blk Air.internedToRef(val.toIntern());
1248712475 } else item;
1248812476
1248912477 return .{ .ref = new_item, .val = val.toIntern() };
......@@ -12893,7 +12881,7 @@ fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1289312881 const file_root_decl_index = result.file.root_decl.unwrap().?;
1289412882 const file_root_decl = mod.declPtr(file_root_decl_index);
1289512883 try mod.declareDeclDependency(sema.owner_decl_index, file_root_decl_index);
12896 return sema.addConstant(file_root_decl.val);
12884 return Air.internedToRef(file_root_decl.val.toIntern());
1289712885}
1289812886
1289912887fn zirEmbedFile(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -12952,10 +12940,10 @@ fn zirRetErrValueCode(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.R
1295212940 const name = try mod.intern_pool.getOrPutString(sema.gpa, inst_data.get(sema.code));
1295312941 _ = try mod.getErrorValue(name);
1295412942 const error_set_type = try mod.singleErrorSetType(name);
12955 return sema.addConstant((try mod.intern(.{ .err = .{
12943 return Air.internedToRef((try mod.intern(.{ .err = .{
1295612944 .ty = error_set_type.toIntern(),
1295712945 .name = name,
12958 } })).toValue());
12946 } })));
1295912947}
1296012948
1296112949fn zirShl(
......@@ -12991,7 +12979,7 @@ fn zirShl(
1299112979
1299212980 if (maybe_rhs_val) |rhs_val| {
1299312981 if (rhs_val.isUndef(mod)) {
12994 return sema.addConstUndef(sema.typeOf(lhs));
12982 return mod.undefRef(sema.typeOf(lhs));
1299512983 }
1299612984 // If rhs is 0, return lhs without doing any calculations.
1299712985 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
......@@ -13037,7 +13025,7 @@ fn zirShl(
1303713025 }
1303813026
1303913027 const runtime_src = if (maybe_lhs_val) |lhs_val| rs: {
13040 if (lhs_val.isUndef(mod)) return sema.addConstUndef(lhs_ty);
13028 if (lhs_val.isUndef(mod)) return mod.undefRef(lhs_ty);
1304113029 const rhs_val = maybe_rhs_val orelse {
1304213030 if (scalar_ty.zigTypeTag(mod) == .ComptimeInt) {
1304313031 return sema.fail(block, src, "LHS of shift must be a fixed-width integer type, or RHS must be comptime-known", .{});
......@@ -13070,7 +13058,7 @@ fn zirShl(
1307013058 else => unreachable,
1307113059 };
1307213060
13073 return sema.addConstant(val);
13061 return Air.internedToRef(val.toIntern());
1307413062 } else lhs_src;
1307513063
1307613064 const new_rhs = if (air_tag == .shl_sat) rhs: {
......@@ -13078,9 +13066,7 @@ fn zirShl(
1307813066 if (rhs_is_comptime_int or
1307913067 scalar_rhs_ty.intInfo(mod).bits > scalar_ty.intInfo(mod).bits)
1308013068 {
13081 const max_int = try sema.addConstant(
13082 try lhs_ty.maxInt(mod, lhs_ty),
13083 );
13069 const max_int = Air.internedToRef((try lhs_ty.maxInt(mod, lhs_ty)).toIntern());
1308413070 const rhs_limited = try sema.analyzeMinMax(block, rhs_src, .min, &.{ rhs, max_int }, &.{ rhs_src, rhs_src });
1308513071 break :rhs try sema.intCast(block, src, lhs_ty, rhs_src, rhs_limited, rhs_src, false);
1308613072 } else {
......@@ -13094,7 +13080,7 @@ fn zirShl(
1309413080 if (!std.math.isPowerOfTwo(bit_count)) {
1309513081 const bit_count_val = try mod.intValue(scalar_rhs_ty, bit_count);
1309613082 const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
13097 const bit_count_inst = try sema.addConstant(try sema.splat(rhs_ty, bit_count_val));
13083 const bit_count_inst = Air.internedToRef((try sema.splat(rhs_ty, bit_count_val)).toIntern());
1309813084 const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
1309913085 break :ok try block.addInst(.{
1310013086 .tag = .reduce,
......@@ -13104,7 +13090,7 @@ fn zirShl(
1310413090 } },
1310513091 });
1310613092 } else ok: {
13107 const bit_count_inst = try sema.addConstant(bit_count_val);
13093 const bit_count_inst = Air.internedToRef(bit_count_val.toIntern());
1310813094 break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst);
1310913095 };
1311013096 try sema.addSafetyCheck(block, src, ok, .shift_rhs_too_big);
......@@ -13115,7 +13101,7 @@ fn zirShl(
1311513101 const op_ov = try block.addInst(.{
1311613102 .tag = .shl_with_overflow,
1311713103 .data = .{ .ty_pl = .{
13118 .ty = try sema.addType(op_ov_tuple_ty),
13104 .ty = Air.internedToRef(op_ov_tuple_ty.toIntern()),
1311913105 .payload = try sema.addExtra(Air.Bin{
1312013106 .lhs = lhs,
1312113107 .rhs = rhs,
......@@ -13133,7 +13119,7 @@ fn zirShl(
1313313119 })
1313413120 else
1313513121 ov_bit;
13136 const zero_ov = try sema.addConstant(try mod.intValue(Type.u1, 0));
13122 const zero_ov = Air.internedToRef((try mod.intValue(Type.u1, 0)).toIntern());
1313713123 const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
1313813124
1313913125 try sema.addSafetyCheck(block, src, no_ov, .shl_overflow);
......@@ -13171,7 +13157,7 @@ fn zirShr(
1317113157
1317213158 const runtime_src = if (maybe_rhs_val) |rhs_val| rs: {
1317313159 if (rhs_val.isUndef(mod)) {
13174 return sema.addConstUndef(lhs_ty);
13160 return mod.undefRef(lhs_ty);
1317513161 }
1317613162 // If rhs is 0, return lhs without doing any calculations.
1317713163 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
......@@ -13216,7 +13202,7 @@ fn zirShr(
1321613202 }
1321713203 if (maybe_lhs_val) |lhs_val| {
1321813204 if (lhs_val.isUndef(mod)) {
13219 return sema.addConstUndef(lhs_ty);
13205 return mod.undefRef(lhs_ty);
1322013206 }
1322113207 if (air_tag == .shr_exact) {
1322213208 // Detect if any ones would be shifted out.
......@@ -13226,7 +13212,7 @@ fn zirShr(
1322613212 }
1322713213 }
1322813214 const val = try lhs_val.shr(rhs_val, lhs_ty, sema.arena, mod);
13229 return sema.addConstant(val);
13215 return Air.internedToRef(val.toIntern());
1323013216 } else {
1323113217 break :rs lhs_src;
1323213218 }
......@@ -13244,7 +13230,7 @@ fn zirShr(
1324413230 const bit_count_val = try mod.intValue(rhs_ty.scalarType(mod), bit_count);
1324513231
1324613232 const ok = if (rhs_ty.zigTypeTag(mod) == .Vector) ok: {
13247 const bit_count_inst = try sema.addConstant(try sema.splat(rhs_ty, bit_count_val));
13233 const bit_count_inst = Air.internedToRef((try sema.splat(rhs_ty, bit_count_val)).toIntern());
1324813234 const lt = try block.addCmpVector(rhs, bit_count_inst, .lt);
1324913235 break :ok try block.addInst(.{
1325013236 .tag = .reduce,
......@@ -13254,7 +13240,7 @@ fn zirShr(
1325413240 } },
1325513241 });
1325613242 } else ok: {
13257 const bit_count_inst = try sema.addConstant(bit_count_val);
13243 const bit_count_inst = Air.internedToRef(bit_count_val.toIntern());
1325813244 break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst);
1325913245 };
1326013246 try sema.addSafetyCheck(block, src, ok, .shift_rhs_too_big);
......@@ -13326,7 +13312,7 @@ fn zirBitwise(
1332613312 .xor => try lhs_val.bitwiseXor(rhs_val, resolved_type, sema.arena, mod),
1332713313 else => unreachable,
1332813314 };
13329 return sema.addConstant(result_val);
13315 return Air.internedToRef(result_val.toIntern());
1333013316 } else {
1333113317 break :runtime rhs_src;
1333213318 }
......@@ -13360,7 +13346,7 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1336013346
1336113347 if (try sema.resolveMaybeUndefVal(operand)) |val| {
1336213348 if (val.isUndef(mod)) {
13363 return sema.addConstUndef(operand_type);
13349 return mod.undefRef(operand_type);
1336413350 } else if (operand_type.zigTypeTag(mod) == .Vector) {
1336513351 const vec_len = try sema.usizeCast(block, operand_src, operand_type.vectorLen(mod));
1336613352 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
......@@ -13368,13 +13354,13 @@ fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1336813354 const elem_val = try val.elemValue(mod, i);
1336913355 elem.* = try (try elem_val.bitwiseNot(scalar_type, sema.arena, mod)).intern(scalar_type, mod);
1337013356 }
13371 return sema.addConstant((try mod.intern(.{ .aggregate = .{
13357 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
1337213358 .ty = operand_type.toIntern(),
1337313359 .storage = .{ .elems = elems },
13374 } })).toValue());
13360 } })));
1337513361 } else {
1337613362 const result_val = try val.bitwiseNot(operand_type, sema.arena, mod);
13377 return sema.addConstant(result_val);
13363 return Air.internedToRef(result_val.toIntern());
1337813364 }
1337913365 }
1338013366
......@@ -13401,7 +13387,7 @@ fn analyzeTupleCat(
1340113387 const dest_fields = lhs_len + rhs_len;
1340213388
1340313389 if (dest_fields == 0) {
13404 return sema.addConstant(Value.empty_struct);
13390 return Air.internedToRef(Value.empty_struct.toIntern());
1340513391 }
1340613392 if (lhs_len == 0) {
1340713393 return rhs;
......@@ -13452,7 +13438,7 @@ fn analyzeTupleCat(
1345213438 .ty = tuple_ty,
1345313439 .storage = .{ .elems = values },
1345413440 } });
13455 return sema.addConstant(tuple_val.toValue());
13441 return Air.internedToRef(tuple_val);
1345613442 };
1345713443
1345813444 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -13523,9 +13509,9 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1352313509 // coercing it to the peer-resolved element type.
1352413510 const res_sent_val: ?Value = s: {
1352513511 if (lhs_info.sentinel) |lhs_sent_val| {
13526 const lhs_sent = try sema.addConstant(lhs_sent_val);
13512 const lhs_sent = Air.internedToRef(lhs_sent_val.toIntern());
1352713513 if (rhs_info.sentinel) |rhs_sent_val| {
13528 const rhs_sent = try sema.addConstant(rhs_sent_val);
13514 const rhs_sent = Air.internedToRef(rhs_sent_val.toIntern());
1352913515 const lhs_sent_casted = try sema.coerce(block, resolved_elem_ty, lhs_sent, lhs_src);
1353013516 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);
1353113517 const lhs_sent_casted_val = try sema.resolveConstValue(block, lhs_src, lhs_sent_casted, "array sentinel value must be comptime-known");
......@@ -13542,7 +13528,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1354213528 }
1354313529 } else {
1354413530 if (rhs_info.sentinel) |rhs_sent_val| {
13545 const rhs_sent = try sema.addConstant(rhs_sent_val);
13531 const rhs_sent = Air.internedToRef(rhs_sent_val.toIntern());
1354613532 const rhs_sent_casted = try sema.coerce(block, resolved_elem_ty, rhs_sent, rhs_src);
1354713533 const rhs_sent_casted_val = try sema.resolveConstValue(block, rhs_src, rhs_sent_casted, "array sentinel value must be comptime-known");
1354813534 break :s rhs_sent_casted_val;
......@@ -13600,7 +13586,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1360013586 const lhs_elem_i = elem_i;
1360113587 const elem_default_val = if (lhs_is_tuple) lhs_ty.structFieldDefaultValue(lhs_elem_i, mod) else Value.@"unreachable";
1360213588 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try lhs_sub_val.elemValue(mod, lhs_elem_i) else elem_default_val;
13603 const elem_val_inst = try sema.addConstant(elem_val);
13589 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
1360413590 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
1360513591 const coerced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, "");
1360613592 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);
......@@ -13609,7 +13595,7 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1360913595 const rhs_elem_i = elem_i - lhs_len;
1361013596 const elem_default_val = if (rhs_is_tuple) rhs_ty.structFieldDefaultValue(rhs_elem_i, mod) else Value.@"unreachable";
1361113597 const elem_val = if (elem_default_val.toIntern() == .unreachable_value) try rhs_sub_val.elemValue(mod, rhs_elem_i) else elem_default_val;
13612 const elem_val_inst = try sema.addConstant(elem_val);
13598 const elem_val_inst = Air.internedToRef(elem_val.toIntern());
1361313599 const coerced_elem_val_inst = try sema.coerce(block, resolved_elem_ty, elem_val_inst, .unneeded);
1361413600 const coerced_elem_val = try sema.resolveConstMaybeUndefVal(block, .unneeded, coerced_elem_val_inst, "");
1361513601 element_vals[elem_i] = try coerced_elem_val.intern(resolved_elem_ty, mod);
......@@ -13636,22 +13622,22 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1363613622
1363713623 var elem_i: usize = 0;
1363813624 while (elem_i < lhs_len) : (elem_i += 1) {
13639 const elem_index = try sema.addIntUnsigned(Type.usize, elem_i);
13625 const elem_index = try mod.intRef(Type.usize, elem_i);
1364013626 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
1364113627 const init = try sema.elemVal(block, lhs_src, lhs, elem_index, src, true);
1364213628 try sema.storePtr2(block, src, elem_ptr, src, init, lhs_src, .store);
1364313629 }
1364413630 while (elem_i < result_len) : (elem_i += 1) {
13645 const elem_index = try sema.addIntUnsigned(Type.usize, elem_i);
13646 const rhs_index = try sema.addIntUnsigned(Type.usize, elem_i - lhs_len);
13631 const elem_index = try mod.intRef(Type.usize, elem_i);
13632 const rhs_index = try mod.intRef(Type.usize, elem_i - lhs_len);
1364713633 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
1364813634 const init = try sema.elemVal(block, rhs_src, rhs, rhs_index, src, true);
1364913635 try sema.storePtr2(block, src, elem_ptr, src, init, rhs_src, .store);
1365013636 }
1365113637 if (res_sent_val) |sent_val| {
13652 const elem_index = try sema.addIntUnsigned(Type.usize, result_len);
13638 const elem_index = try mod.intRef(Type.usize, result_len);
1365313639 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
13654 const init = try sema.addConstant(try mod.getCoerced(sent_val, lhs_info.elem_type));
13640 const init = Air.internedToRef((try mod.getCoerced(sent_val, lhs_info.elem_type)).toIntern());
1365513641 try sema.storePtr2(block, src, elem_ptr, src, init, lhs_src, .store);
1365613642 }
1365713643
......@@ -13662,12 +13648,12 @@ fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1366213648 {
1366313649 var elem_i: usize = 0;
1366413650 while (elem_i < lhs_len) : (elem_i += 1) {
13665 const index = try sema.addIntUnsigned(Type.usize, elem_i);
13651 const index = try mod.intRef(Type.usize, elem_i);
1366613652 const init = try sema.elemVal(block, lhs_src, lhs, index, src, true);
1366713653 element_refs[elem_i] = try sema.coerce(block, resolved_elem_ty, init, lhs_src);
1366813654 }
1366913655 while (elem_i < result_len) : (elem_i += 1) {
13670 const index = try sema.addIntUnsigned(Type.usize, elem_i - lhs_len);
13656 const index = try mod.intRef(Type.usize, elem_i - lhs_len);
1367113657 const init = try sema.elemVal(block, rhs_src, rhs, index, src, true);
1367213658 element_refs[elem_i] = try sema.coerce(block, resolved_elem_ty, init, rhs_src);
1367313659 }
......@@ -13739,7 +13725,7 @@ fn analyzeTupleMul(
1373913725 return sema.fail(block, rhs_src, "operation results in overflow", .{});
1374013726
1374113727 if (final_len == 0) {
13742 return sema.addConstant(Value.empty_struct);
13728 return Air.internedToRef(Value.empty_struct.toIntern());
1374313729 }
1374413730 const types = try sema.arena.alloc(InternPool.Index, final_len);
1374513731 const values = try sema.arena.alloc(InternPool.Index, final_len);
......@@ -13773,7 +13759,7 @@ fn analyzeTupleMul(
1377313759 .ty = tuple_ty,
1377413760 .storage = .{ .elems = values },
1377513761 } });
13776 return sema.addConstant(tuple_val.toValue());
13762 return Air.internedToRef(tuple_val);
1377713763 };
1377813764
1377913765 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -13897,18 +13883,18 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1389713883 while (elem_i < result_len) {
1389813884 var lhs_i: usize = 0;
1389913885 while (lhs_i < lhs_len) : (lhs_i += 1) {
13900 const elem_index = try sema.addIntUnsigned(Type.usize, elem_i);
13886 const elem_index = try mod.intRef(Type.usize, elem_i);
1390113887 elem_i += 1;
13902 const lhs_index = try sema.addIntUnsigned(Type.usize, lhs_i);
13888 const lhs_index = try mod.intRef(Type.usize, lhs_i);
1390313889 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
1390413890 const init = try sema.elemVal(block, lhs_src, lhs, lhs_index, src, true);
1390513891 try sema.storePtr2(block, src, elem_ptr, src, init, lhs_src, .store);
1390613892 }
1390713893 }
1390813894 if (lhs_info.sentinel) |sent_val| {
13909 const elem_index = try sema.addIntUnsigned(Type.usize, result_len);
13895 const elem_index = try mod.intRef(Type.usize, result_len);
1391013896 const elem_ptr = try block.addPtrElemPtr(alloc, elem_index, elem_ptr_ty);
13911 const init = try sema.addConstant(sent_val);
13897 const init = Air.internedToRef(sent_val.toIntern());
1391213898 try sema.storePtr2(block, src, elem_ptr, src, init, lhs_src, .store);
1391313899 }
1391413900
......@@ -13920,7 +13906,7 @@ fn zirArrayMul(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1392013906 while (elem_i < result_len) {
1392113907 var lhs_i: usize = 0;
1392213908 while (lhs_i < lhs_len) : (lhs_i += 1) {
13923 const lhs_index = try sema.addIntUnsigned(Type.usize, lhs_i);
13909 const lhs_index = try mod.intRef(Type.usize, lhs_i);
1392413910 const init = try sema.elemVal(block, lhs_src, lhs, lhs_index, src, true);
1392513911 element_refs[elem_i] = init;
1392613912 elem_i += 1;
......@@ -13951,14 +13937,14 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1395113937 if (rhs_scalar_ty.isAnyFloat()) {
1395213938 // We handle float negation here to ensure negative zero is represented in the bits.
1395313939 if (try sema.resolveMaybeUndefVal(rhs)) |rhs_val| {
13954 if (rhs_val.isUndef(mod)) return sema.addConstUndef(rhs_ty);
13955 return sema.addConstant(try rhs_val.floatNeg(rhs_ty, sema.arena, mod));
13940 if (rhs_val.isUndef(mod)) return mod.undefRef(rhs_ty);
13941 return Air.internedToRef((try rhs_val.floatNeg(rhs_ty, sema.arena, mod)).toIntern());
1395613942 }
1395713943 try sema.requireRuntimeBlock(block, src, null);
1395813944 return block.addUnOp(if (block.float_mode == .Optimized) .neg_optimized else .neg, rhs);
1395913945 }
1396013946
13961 const lhs = try sema.addConstant(try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0)));
13947 const lhs = Air.internedToRef((try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0))).toIntern());
1396213948 return sema.analyzeArithmetic(block, .sub, lhs, rhs, src, lhs_src, rhs_src, true);
1396313949}
1396413950
......@@ -13978,7 +13964,7 @@ fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1397813964 else => return sema.fail(block, src, "negation of type '{}'", .{rhs_ty.fmt(mod)}),
1397913965 }
1398013966
13981 const lhs = try sema.addConstant(try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0)));
13967 const lhs = Air.internedToRef((try sema.splat(rhs_ty, try mod.intValue(rhs_scalar_ty, 0))).toIntern());
1398213968 return sema.analyzeArithmetic(block, .subwrap, lhs, rhs, src, lhs_src, rhs_src, true);
1398313969}
1398413970
......@@ -14095,7 +14081,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1409514081 else => unreachable,
1409614082 };
1409714083 const zero_val = try sema.splat(resolved_type, scalar_zero);
14098 return sema.addConstant(zero_val);
14084 return Air.internedToRef(zero_val.toIntern());
1409914085 }
1410014086 }
1410114087 }
......@@ -14118,12 +14104,12 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1411814104 if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) {
1411914105 if (maybe_rhs_val) |rhs_val| {
1412014106 if (try sema.compareAll(rhs_val, .neq, try mod.intValue(resolved_type, -1), resolved_type)) {
14121 return sema.addConstUndef(resolved_type);
14107 return mod.undefRef(resolved_type);
1412214108 }
1412314109 }
1412414110 return sema.failWithUseOfUndef(block, rhs_src);
1412514111 }
14126 return sema.addConstUndef(resolved_type);
14112 return mod.undefRef(resolved_type);
1412714113 }
1412814114
1412914115 if (maybe_rhs_val) |rhs_val| {
......@@ -14133,11 +14119,9 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1413314119 if (overflow_idx) |vec_idx| {
1413414120 return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
1413514121 }
14136 return sema.addConstant(res);
14122 return Air.internedToRef(res.toIntern());
1413714123 } else {
14138 return sema.addConstant(
14139 try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, mod),
14140 );
14124 return Air.internedToRef((try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1414114125 }
1414214126 } else {
1414314127 break :rs rhs_src;
......@@ -14234,7 +14218,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1423414218 else => unreachable,
1423514219 };
1423614220 const zero_val = try sema.splat(resolved_type, scalar_zero);
14237 return sema.addConstant(zero_val);
14221 return Air.internedToRef(zero_val.toIntern());
1423814222 }
1423914223 }
1424014224 }
......@@ -14259,15 +14243,13 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1425914243 if (overflow_idx) |vec_idx| {
1426014244 return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
1426114245 }
14262 return sema.addConstant(res);
14246 return Air.internedToRef(res.toIntern());
1426314247 } else {
1426414248 const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod);
1426514249 if (!(modulus_val.compareAllWithZero(.eq, mod))) {
1426614250 return sema.fail(block, src, "exact division produced remainder", .{});
1426714251 }
14268 return sema.addConstant(
14269 try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, mod),
14270 );
14252 return Air.internedToRef((try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1427114253 }
1427214254 } else break :rs rhs_src;
1427314255 } else break :rs lhs_src;
......@@ -14317,7 +14299,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1431714299 };
1431814300 if (resolved_type.zigTypeTag(mod) == .Vector) {
1431914301 const zero_val = try sema.splat(resolved_type, scalar_zero);
14320 const zero = try sema.addConstant(zero_val);
14302 const zero = Air.internedToRef(zero_val.toIntern());
1432114303 const eql = try block.addCmpVector(remainder, zero, .eq);
1432214304 break :ok try block.addInst(.{
1432314305 .tag = .reduce,
......@@ -14327,7 +14309,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1432714309 } },
1432814310 });
1432914311 } else {
14330 const zero = try sema.addConstant(scalar_zero);
14312 const zero = Air.internedToRef(scalar_zero.toIntern());
1433114313 const is_in_range = try block.addBinOp(.cmp_eq, remainder, zero);
1433214314 break :ok is_in_range;
1433314315 }
......@@ -14404,7 +14386,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1440414386 else => unreachable,
1440514387 };
1440614388 const zero_val = try sema.splat(resolved_type, scalar_zero);
14407 return sema.addConstant(zero_val);
14389 return Air.internedToRef(zero_val.toIntern());
1440814390 }
1440914391 }
1441014392 }
......@@ -14422,23 +14404,19 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1442214404 if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) {
1442314405 if (maybe_rhs_val) |rhs_val| {
1442414406 if (try sema.compareAll(rhs_val, .neq, try mod.intValue(resolved_type, -1), resolved_type)) {
14425 return sema.addConstUndef(resolved_type);
14407 return mod.undefRef(resolved_type);
1442614408 }
1442714409 }
1442814410 return sema.failWithUseOfUndef(block, rhs_src);
1442914411 }
14430 return sema.addConstUndef(resolved_type);
14412 return mod.undefRef(resolved_type);
1443114413 }
1443214414
1443314415 if (maybe_rhs_val) |rhs_val| {
1443414416 if (is_int) {
14435 return sema.addConstant(
14436 try lhs_val.intDivFloor(rhs_val, resolved_type, sema.arena, mod),
14437 );
14417 return Air.internedToRef((try lhs_val.intDivFloor(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1443814418 } else {
14439 return sema.addConstant(
14440 try lhs_val.floatDivFloor(rhs_val, resolved_type, sema.arena, mod),
14441 );
14419 return Air.internedToRef((try lhs_val.floatDivFloor(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1444214420 }
1444314421 } else break :rs rhs_src;
1444414422 } else break :rs lhs_src;
......@@ -14519,7 +14497,7 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1451914497 else => unreachable,
1452014498 };
1452114499 const zero_val = try sema.splat(resolved_type, scalar_zero);
14522 return sema.addConstant(zero_val);
14500 return Air.internedToRef(zero_val.toIntern());
1452314501 }
1452414502 }
1452514503 }
......@@ -14536,12 +14514,12 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1453614514 if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) {
1453714515 if (maybe_rhs_val) |rhs_val| {
1453814516 if (try sema.compareAll(rhs_val, .neq, try mod.intValue(resolved_type, -1), resolved_type)) {
14539 return sema.addConstUndef(resolved_type);
14517 return mod.undefRef(resolved_type);
1454014518 }
1454114519 }
1454214520 return sema.failWithUseOfUndef(block, rhs_src);
1454314521 }
14544 return sema.addConstUndef(resolved_type);
14522 return mod.undefRef(resolved_type);
1454514523 }
1454614524
1454714525 if (maybe_rhs_val) |rhs_val| {
......@@ -14551,11 +14529,9 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1455114529 if (overflow_idx) |vec_idx| {
1455214530 return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
1455314531 }
14554 return sema.addConstant(res);
14532 return Air.internedToRef(res.toIntern());
1455514533 } else {
14556 return sema.addConstant(
14557 try lhs_val.floatDivTrunc(rhs_val, resolved_type, sema.arena, mod),
14558 );
14534 return Air.internedToRef((try lhs_val.floatDivTrunc(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1455914535 }
1456014536 } else break :rs rhs_src;
1456114537 } else break :rs lhs_src;
......@@ -14612,11 +14588,11 @@ fn addDivIntOverflowSafety(
1461214588 var ok: Air.Inst.Ref = .none;
1461314589 if (resolved_type.zigTypeTag(mod) == .Vector) {
1461414590 if (maybe_lhs_val == null) {
14615 const min_int_ref = try sema.addConstant(min_int);
14591 const min_int_ref = Air.internedToRef(min_int.toIntern());
1461614592 ok = try block.addCmpVector(casted_lhs, min_int_ref, .neq);
1461714593 }
1461814594 if (maybe_rhs_val == null) {
14619 const neg_one_ref = try sema.addConstant(neg_one);
14595 const neg_one_ref = Air.internedToRef(neg_one.toIntern());
1462014596 const rhs_ok = try block.addCmpVector(casted_rhs, neg_one_ref, .neq);
1462114597 if (ok == .none) {
1462214598 ok = rhs_ok;
......@@ -14634,11 +14610,11 @@ fn addDivIntOverflowSafety(
1463414610 });
1463514611 } else {
1463614612 if (maybe_lhs_val == null) {
14637 const min_int_ref = try sema.addConstant(min_int);
14613 const min_int_ref = Air.internedToRef(min_int.toIntern());
1463814614 ok = try block.addBinOp(.cmp_neq, casted_lhs, min_int_ref);
1463914615 }
1464014616 if (maybe_rhs_val == null) {
14641 const neg_one_ref = try sema.addConstant(neg_one);
14617 const neg_one_ref = Air.internedToRef(neg_one.toIntern());
1464214618 const rhs_ok = try block.addBinOp(.cmp_neq, casted_rhs, neg_one_ref);
1464314619 if (ok == .none) {
1464414620 ok = rhs_ok;
......@@ -14674,7 +14650,7 @@ fn addDivByZeroSafety(
1467414650 try mod.floatValue(resolved_type.scalarType(mod), 0.0);
1467514651 const ok = if (resolved_type.zigTypeTag(mod) == .Vector) ok: {
1467614652 const zero_val = try sema.splat(resolved_type, scalar_zero);
14677 const zero = try sema.addConstant(zero_val);
14653 const zero = Air.internedToRef(zero_val.toIntern());
1467814654 const ok = try block.addCmpVector(casted_rhs, zero, .neq);
1467914655 break :ok try block.addInst(.{
1468014656 .tag = if (is_int) .reduce else .reduce_optimized,
......@@ -14684,7 +14660,7 @@ fn addDivByZeroSafety(
1468414660 } },
1468514661 });
1468614662 } else ok: {
14687 const zero = try sema.addConstant(scalar_zero);
14663 const zero = Air.internedToRef(scalar_zero.toIntern());
1468814664 break :ok try block.addBinOp(if (is_int) .cmp_neq else .cmp_neq_optimized, casted_rhs, zero);
1468914665 };
1469014666 try sema.addSafetyCheck(block, src, ok, .divide_by_zero);
......@@ -14765,7 +14741,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1476514741 .ty = resolved_type.toIntern(),
1476614742 .storage = .{ .repeated_elem = scalar_zero.toIntern() },
1476714743 } })).toValue() else scalar_zero;
14768 return sema.addConstant(zero_val);
14744 return Air.internedToRef(zero_val.toIntern());
1476914745 }
1477014746 } else if (lhs_scalar_ty.isSignedInt(mod)) {
1477114747 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
......@@ -14789,7 +14765,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1478914765 {
1479014766 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
1479114767 }
14792 return sema.addConstant(rem_result);
14768 return Air.internedToRef(rem_result.toIntern());
1479314769 }
1479414770 break :rs lhs_src;
1479514771 } else if (rhs_scalar_ty.isSignedInt(mod)) {
......@@ -14813,9 +14789,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1481314789 if (lhs_val.isUndef(mod) or !(try lhs_val.compareAllWithZeroAdvanced(.gte, sema))) {
1481414790 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
1481514791 }
14816 return sema.addConstant(
14817 try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod),
14818 );
14792 return Air.internedToRef((try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1481914793 } else {
1482014794 return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
1482114795 }
......@@ -14945,9 +14919,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1494514919 return sema.failWithDivideByZero(block, rhs_src);
1494614920 }
1494714921 if (maybe_lhs_val) |lhs_val| {
14948 return sema.addConstant(
14949 try lhs_val.intMod(rhs_val, resolved_type, sema.arena, mod),
14950 );
14922 return Air.internedToRef((try lhs_val.intMod(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1495114923 }
1495214924 break :rs lhs_src;
1495314925 } else {
......@@ -14965,12 +14937,10 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1496514937 }
1496614938 if (maybe_lhs_val) |lhs_val| {
1496714939 if (lhs_val.isUndef(mod)) {
14968 return sema.addConstUndef(resolved_type);
14940 return mod.undefRef(resolved_type);
1496914941 }
1497014942 if (maybe_rhs_val) |rhs_val| {
14971 return sema.addConstant(
14972 try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod),
14973 );
14943 return Air.internedToRef((try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1497414944 } else break :rs rhs_src;
1497514945 } else break :rs lhs_src;
1497614946 };
......@@ -15045,9 +15015,7 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1504515015 return sema.failWithDivideByZero(block, rhs_src);
1504615016 }
1504715017 if (maybe_lhs_val) |lhs_val| {
15048 return sema.addConstant(
15049 try sema.intRem(resolved_type, lhs_val, rhs_val),
15050 );
15018 return Air.internedToRef((try sema.intRem(resolved_type, lhs_val, rhs_val)).toIntern());
1505115019 }
1505215020 break :rs lhs_src;
1505315021 } else {
......@@ -15065,12 +15033,10 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
1506515033 }
1506615034 if (maybe_lhs_val) |lhs_val| {
1506715035 if (lhs_val.isUndef(mod)) {
15068 return sema.addConstUndef(resolved_type);
15036 return mod.undefRef(resolved_type);
1506915037 }
1507015038 if (maybe_rhs_val) |rhs_val| {
15071 return sema.addConstant(
15072 try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod),
15073 );
15039 return Air.internedToRef((try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1507415040 } else break :rs rhs_src;
1507515041 } else break :rs lhs_src;
1507615042 };
......@@ -15263,7 +15229,7 @@ fn zirOverflowArithmetic(
1526315229 return block.addInst(.{
1526415230 .tag = air_tag,
1526515231 .data = .{ .ty_pl = .{
15266 .ty = try block.sema.addType(tuple_ty),
15232 .ty = Air.internedToRef(tuple_ty.toIntern()),
1526715233 .payload = try block.sema.addExtra(Air.Bin{
1526815234 .lhs = lhs,
1526915235 .rhs = rhs,
......@@ -15280,18 +15246,18 @@ fn zirOverflowArithmetic(
1528015246 }
1528115247
1528215248 if (result.inst == .none) {
15283 return sema.addConstant((try mod.intern(.{ .aggregate = .{
15249 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
1528415250 .ty = tuple_ty.toIntern(),
1528515251 .storage = .{ .elems = &.{
1528615252 result.wrapped.toIntern(),
1528715253 result.overflow_bit.toIntern(),
1528815254 } },
15289 } })).toValue());
15255 } })));
1529015256 }
1529115257
1529215258 const element_refs = try sema.arena.alloc(Air.Inst.Ref, 2);
1529315259 element_refs[0] = result.inst;
15294 element_refs[1] = try sema.addConstant(result.overflow_bit);
15260 element_refs[1] = Air.internedToRef(result.overflow_bit.toIntern());
1529515261 return block.addAggregateInit(tuple_ty, element_refs);
1529615262}
1529715263
......@@ -15394,7 +15360,7 @@ fn analyzeArithmetic(
1539415360 if (is_int) {
1539515361 return sema.failWithUseOfUndef(block, rhs_src);
1539615362 } else {
15397 return sema.addConstUndef(resolved_type);
15363 return mod.undefRef(resolved_type);
1539815364 }
1539915365 }
1540015366 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
......@@ -15407,7 +15373,7 @@ fn analyzeArithmetic(
1540715373 if (is_int) {
1540815374 return sema.failWithUseOfUndef(block, lhs_src);
1540915375 } else {
15410 return sema.addConstUndef(resolved_type);
15376 return mod.undefRef(resolved_type);
1541115377 }
1541215378 }
1541315379 if (maybe_rhs_val) |rhs_val| {
......@@ -15417,11 +15383,9 @@ fn analyzeArithmetic(
1541715383 if (overflow_idx) |vec_idx| {
1541815384 return sema.failWithIntegerOverflow(block, src, resolved_type, sum, vec_idx);
1541915385 }
15420 return sema.addConstant(sum);
15386 return Air.internedToRef(sum.toIntern());
1542115387 } else {
15422 return sema.addConstant(
15423 try Value.floatAdd(lhs_val, rhs_val, resolved_type, sema.arena, mod),
15424 );
15388 return Air.internedToRef((try Value.floatAdd(lhs_val, rhs_val, resolved_type, sema.arena, mod)).toIntern());
1542515389 }
1542615390 } else break :rs .{ .src = rhs_src, .air_tag = air_tag, .air_tag_safe = .add_safe };
1542715391 } else break :rs .{ .src = lhs_src, .air_tag = air_tag, .air_tag_safe = .add_safe };
......@@ -15437,15 +15401,13 @@ fn analyzeArithmetic(
1543715401 }
1543815402 if (maybe_rhs_val) |rhs_val| {
1543915403 if (rhs_val.isUndef(mod)) {
15440 return sema.addConstUndef(resolved_type);
15404 return mod.undefRef(resolved_type);
1544115405 }
1544215406 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1544315407 return casted_lhs;
1544415408 }
1544515409 if (maybe_lhs_val) |lhs_val| {
15446 return sema.addConstant(
15447 try sema.numberAddWrapScalar(lhs_val, rhs_val, resolved_type),
15448 );
15410 return Air.internedToRef((try sema.numberAddWrapScalar(lhs_val, rhs_val, resolved_type)).toIntern());
1544915411 } else break :rs .{ .src = lhs_src, .air_tag = .add_wrap, .air_tag_safe = .add_wrap };
1545015412 } else break :rs .{ .src = rhs_src, .air_tag = .add_wrap, .air_tag_safe = .add_wrap };
1545115413 },
......@@ -15460,7 +15422,7 @@ fn analyzeArithmetic(
1546015422 }
1546115423 if (maybe_rhs_val) |rhs_val| {
1546215424 if (rhs_val.isUndef(mod)) {
15463 return sema.addConstUndef(resolved_type);
15425 return mod.undefRef(resolved_type);
1546415426 }
1546515427 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1546615428 return casted_lhs;
......@@ -15471,7 +15433,7 @@ fn analyzeArithmetic(
1547115433 else
1547215434 try lhs_val.intAddSat(rhs_val, resolved_type, sema.arena, mod);
1547315435
15474 return sema.addConstant(val);
15436 return Air.internedToRef(val.toIntern());
1547515437 } else break :rs .{
1547615438 .src = lhs_src,
1547715439 .air_tag = .add_sat,
......@@ -15496,7 +15458,7 @@ fn analyzeArithmetic(
1549615458 if (is_int) {
1549715459 return sema.failWithUseOfUndef(block, rhs_src);
1549815460 } else {
15499 return sema.addConstUndef(resolved_type);
15461 return mod.undefRef(resolved_type);
1550015462 }
1550115463 }
1550215464 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
......@@ -15509,7 +15471,7 @@ fn analyzeArithmetic(
1550915471 if (is_int) {
1551015472 return sema.failWithUseOfUndef(block, lhs_src);
1551115473 } else {
15512 return sema.addConstUndef(resolved_type);
15474 return mod.undefRef(resolved_type);
1551315475 }
1551415476 }
1551515477 if (maybe_rhs_val) |rhs_val| {
......@@ -15519,11 +15481,9 @@ fn analyzeArithmetic(
1551915481 if (overflow_idx) |vec_idx| {
1552015482 return sema.failWithIntegerOverflow(block, src, resolved_type, diff, vec_idx);
1552115483 }
15522 return sema.addConstant(diff);
15484 return Air.internedToRef(diff.toIntern());
1552315485 } else {
15524 return sema.addConstant(
15525 try Value.floatSub(lhs_val, rhs_val, resolved_type, sema.arena, mod),
15526 );
15486 return Air.internedToRef((try Value.floatSub(lhs_val, rhs_val, resolved_type, sema.arena, mod)).toIntern());
1552715487 }
1552815488 } else break :rs .{ .src = rhs_src, .air_tag = air_tag, .air_tag_safe = .sub_safe };
1552915489 } else break :rs .{ .src = lhs_src, .air_tag = air_tag, .air_tag_safe = .sub_safe };
......@@ -15534,7 +15494,7 @@ fn analyzeArithmetic(
1553415494 // If either of the operands are undefined, the result is undefined.
1553515495 if (maybe_rhs_val) |rhs_val| {
1553615496 if (rhs_val.isUndef(mod)) {
15537 return sema.addConstUndef(resolved_type);
15497 return mod.undefRef(resolved_type);
1553815498 }
1553915499 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1554015500 return casted_lhs;
......@@ -15542,12 +15502,10 @@ fn analyzeArithmetic(
1554215502 }
1554315503 if (maybe_lhs_val) |lhs_val| {
1554415504 if (lhs_val.isUndef(mod)) {
15545 return sema.addConstUndef(resolved_type);
15505 return mod.undefRef(resolved_type);
1554615506 }
1554715507 if (maybe_rhs_val) |rhs_val| {
15548 return sema.addConstant(
15549 try sema.numberSubWrapScalar(lhs_val, rhs_val, resolved_type),
15550 );
15508 return Air.internedToRef((try sema.numberSubWrapScalar(lhs_val, rhs_val, resolved_type)).toIntern());
1555115509 } else break :rs .{ .src = rhs_src, .air_tag = .sub_wrap, .air_tag_safe = .sub_wrap };
1555215510 } else break :rs .{ .src = lhs_src, .air_tag = .sub_wrap, .air_tag_safe = .sub_wrap };
1555315511 },
......@@ -15557,7 +15515,7 @@ fn analyzeArithmetic(
1555715515 // If either of the operands are undefined, result is undefined.
1555815516 if (maybe_rhs_val) |rhs_val| {
1555915517 if (rhs_val.isUndef(mod)) {
15560 return sema.addConstUndef(resolved_type);
15518 return mod.undefRef(resolved_type);
1556115519 }
1556215520 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1556315521 return casted_lhs;
......@@ -15565,7 +15523,7 @@ fn analyzeArithmetic(
1556515523 }
1556615524 if (maybe_lhs_val) |lhs_val| {
1556715525 if (lhs_val.isUndef(mod)) {
15568 return sema.addConstUndef(resolved_type);
15526 return mod.undefRef(resolved_type);
1556915527 }
1557015528 if (maybe_rhs_val) |rhs_val| {
1557115529 const val = if (scalar_tag == .ComptimeInt)
......@@ -15573,7 +15531,7 @@ fn analyzeArithmetic(
1557315531 else
1557415532 try lhs_val.intSubSat(rhs_val, resolved_type, sema.arena, mod);
1557515533
15576 return sema.addConstant(val);
15534 return Air.internedToRef(val.toIntern());
1557715535 } else break :rs .{ .src = rhs_src, .air_tag = .sub_sat, .air_tag_safe = .sub_sat };
1557815536 } else break :rs .{ .src = lhs_src, .air_tag = .sub_sat, .air_tag_safe = .sub_sat };
1557915537 },
......@@ -15602,23 +15560,21 @@ fn analyzeArithmetic(
1560215560 if (maybe_lhs_val) |lhs_val| {
1560315561 if (!lhs_val.isUndef(mod)) {
1560415562 if (lhs_val.isNan(mod)) {
15605 return sema.addConstant(lhs_val);
15563 return Air.internedToRef(lhs_val.toIntern());
1560615564 }
1560715565 if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) lz: {
1560815566 if (maybe_rhs_val) |rhs_val| {
1560915567 if (rhs_val.isNan(mod)) {
15610 return sema.addConstant(rhs_val);
15568 return Air.internedToRef(rhs_val.toIntern());
1561115569 }
1561215570 if (rhs_val.isInf(mod)) {
15613 return sema.addConstant(
15614 try mod.floatValue(resolved_type, std.math.nan_f128),
15615 );
15571 return Air.internedToRef((try mod.floatValue(resolved_type, std.math.nan_f128)).toIntern());
1561615572 }
1561715573 } else if (resolved_type.isAnyFloat()) {
1561815574 break :lz;
1561915575 }
1562015576 const zero_val = try sema.splat(resolved_type, scalar_zero);
15621 return sema.addConstant(zero_val);
15577 return Air.internedToRef(zero_val.toIntern());
1562215578 }
1562315579 if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1562415580 return casted_rhs;
......@@ -15631,24 +15587,22 @@ fn analyzeArithmetic(
1563115587 if (is_int) {
1563215588 return sema.failWithUseOfUndef(block, rhs_src);
1563315589 } else {
15634 return sema.addConstUndef(resolved_type);
15590 return mod.undefRef(resolved_type);
1563515591 }
1563615592 }
1563715593 if (rhs_val.isNan(mod)) {
15638 return sema.addConstant(rhs_val);
15594 return Air.internedToRef(rhs_val.toIntern());
1563915595 }
1564015596 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) rz: {
1564115597 if (maybe_lhs_val) |lhs_val| {
1564215598 if (lhs_val.isInf(mod)) {
15643 return sema.addConstant(
15644 try mod.floatValue(resolved_type, std.math.nan_f128),
15645 );
15599 return Air.internedToRef((try mod.floatValue(resolved_type, std.math.nan_f128)).toIntern());
1564615600 }
1564715601 } else if (resolved_type.isAnyFloat()) {
1564815602 break :rz;
1564915603 }
1565015604 const zero_val = try sema.splat(resolved_type, scalar_zero);
15651 return sema.addConstant(zero_val);
15605 return Air.internedToRef(zero_val.toIntern());
1565215606 }
1565315607 if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1565415608 return casted_lhs;
......@@ -15658,7 +15612,7 @@ fn analyzeArithmetic(
1565815612 if (is_int) {
1565915613 return sema.failWithUseOfUndef(block, lhs_src);
1566015614 } else {
15661 return sema.addConstUndef(resolved_type);
15615 return mod.undefRef(resolved_type);
1566215616 }
1566315617 }
1566415618 if (is_int) {
......@@ -15667,11 +15621,9 @@ fn analyzeArithmetic(
1566715621 if (overflow_idx) |vec_idx| {
1566815622 return sema.failWithIntegerOverflow(block, src, resolved_type, product, vec_idx);
1566915623 }
15670 return sema.addConstant(product);
15624 return Air.internedToRef(product.toIntern());
1567115625 } else {
15672 return sema.addConstant(
15673 try lhs_val.floatMul(rhs_val, resolved_type, sema.arena, mod),
15674 );
15626 return Air.internedToRef((try lhs_val.floatMul(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1567515627 }
1567615628 } else break :rs .{ .src = lhs_src, .air_tag = air_tag, .air_tag_safe = .mul_safe };
1567715629 } else break :rs .{ .src = rhs_src, .air_tag = air_tag, .air_tag_safe = .mul_safe };
......@@ -15695,7 +15647,7 @@ fn analyzeArithmetic(
1569515647 if (!lhs_val.isUndef(mod)) {
1569615648 if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1569715649 const zero_val = try sema.splat(resolved_type, scalar_zero);
15698 return sema.addConstant(zero_val);
15650 return Air.internedToRef(zero_val.toIntern());
1569915651 }
1570015652 if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1570115653 return casted_rhs;
......@@ -15704,22 +15656,20 @@ fn analyzeArithmetic(
1570415656 }
1570515657 if (maybe_rhs_val) |rhs_val| {
1570615658 if (rhs_val.isUndef(mod)) {
15707 return sema.addConstUndef(resolved_type);
15659 return mod.undefRef(resolved_type);
1570815660 }
1570915661 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1571015662 const zero_val = try sema.splat(resolved_type, scalar_zero);
15711 return sema.addConstant(zero_val);
15663 return Air.internedToRef(zero_val.toIntern());
1571215664 }
1571315665 if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1571415666 return casted_lhs;
1571515667 }
1571615668 if (maybe_lhs_val) |lhs_val| {
1571715669 if (lhs_val.isUndef(mod)) {
15718 return sema.addConstUndef(resolved_type);
15670 return mod.undefRef(resolved_type);
1571915671 }
15720 return sema.addConstant(
15721 try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, mod),
15722 );
15672 return Air.internedToRef((try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, mod)).toIntern());
1572315673 } else break :rs .{ .src = lhs_src, .air_tag = .mul_wrap, .air_tag_safe = .mul_wrap };
1572415674 } else break :rs .{ .src = rhs_src, .air_tag = .mul_wrap, .air_tag_safe = .mul_wrap };
1572515675 },
......@@ -15742,7 +15692,7 @@ fn analyzeArithmetic(
1574215692 if (!lhs_val.isUndef(mod)) {
1574315693 if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1574415694 const zero_val = try sema.splat(resolved_type, scalar_zero);
15745 return sema.addConstant(zero_val);
15695 return Air.internedToRef(zero_val.toIntern());
1574615696 }
1574715697 if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1574815698 return casted_rhs;
......@@ -15751,18 +15701,18 @@ fn analyzeArithmetic(
1575115701 }
1575215702 if (maybe_rhs_val) |rhs_val| {
1575315703 if (rhs_val.isUndef(mod)) {
15754 return sema.addConstUndef(resolved_type);
15704 return mod.undefRef(resolved_type);
1575515705 }
1575615706 if (try rhs_val.compareAllWithZeroAdvanced(.eq, sema)) {
1575715707 const zero_val = try sema.splat(resolved_type, scalar_zero);
15758 return sema.addConstant(zero_val);
15708 return Air.internedToRef(zero_val.toIntern());
1575915709 }
1576015710 if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
1576115711 return casted_lhs;
1576215712 }
1576315713 if (maybe_lhs_val) |lhs_val| {
1576415714 if (lhs_val.isUndef(mod)) {
15765 return sema.addConstUndef(resolved_type);
15715 return mod.undefRef(resolved_type);
1576615716 }
1576715717
1576815718 const val = if (scalar_tag == .ComptimeInt)
......@@ -15770,7 +15720,7 @@ fn analyzeArithmetic(
1577015720 else
1577115721 try lhs_val.intMulSat(rhs_val, resolved_type, sema.arena, mod);
1577215722
15773 return sema.addConstant(val);
15723 return Air.internedToRef(val.toIntern());
1577415724 } else break :rs .{ .src = lhs_src, .air_tag = .mul_sat, .air_tag_safe = .mul_sat };
1577515725 } else break :rs .{ .src = rhs_src, .air_tag = .mul_sat, .air_tag_safe = .mul_sat };
1577615726 },
......@@ -15795,7 +15745,7 @@ fn analyzeArithmetic(
1579515745 const op_ov = try block.addInst(.{
1579615746 .tag = op_ov_tag,
1579715747 .data = .{ .ty_pl = .{
15798 .ty = try sema.addType(op_ov_tuple_ty),
15748 .ty = Air.internedToRef(op_ov_tuple_ty.toIntern()),
1579915749 .payload = try sema.addExtra(Air.Bin{
1580015750 .lhs = casted_lhs,
1580115751 .rhs = casted_rhs,
......@@ -15813,7 +15763,7 @@ fn analyzeArithmetic(
1581315763 })
1581415764 else
1581515765 ov_bit;
15816 const zero_ov = try sema.addConstant(try mod.intValue(Type.u1, 0));
15766 const zero_ov = Air.internedToRef((try mod.intValue(Type.u1, 0)).toIntern());
1581715767 const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov);
1581815768
1581915769 try sema.addSafetyCheck(block, src, no_ov, .integer_overflow);
......@@ -15885,7 +15835,7 @@ fn analyzePtrArithmetic(
1588515835 const runtime_src = rs: {
1588615836 if (opt_ptr_val) |ptr_val| {
1588715837 if (opt_off_val) |offset_val| {
15888 if (ptr_val.isUndef(mod)) return sema.addConstUndef(new_ptr_ty);
15838 if (ptr_val.isUndef(mod)) return mod.undefRef(new_ptr_ty);
1588915839
1589015840 const offset_int = try sema.usizeCast(block, offset_src, offset_val.toUnsignedInt(mod));
1589115841 if (offset_int == 0) return ptr;
......@@ -15897,13 +15847,13 @@ fn analyzePtrArithmetic(
1589715847 else => unreachable,
1589815848 };
1589915849 const new_ptr_val = try mod.ptrIntValue(new_ptr_ty, new_addr);
15900 return sema.addConstant(new_ptr_val);
15850 return Air.internedToRef(new_ptr_val.toIntern());
1590115851 }
1590215852 if (air_tag == .ptr_sub) {
1590315853 return sema.fail(block, op_src, "TODO implement Sema comptime pointer subtraction", .{});
1590415854 }
1590515855 const new_ptr_val = try ptr_val.elemPtr(new_ptr_ty, offset_int, mod);
15906 return sema.addConstant(new_ptr_val);
15856 return Air.internedToRef(new_ptr_val.toIntern());
1590715857 } else break :rs offset_src;
1590815858 } else break :rs ptr_src;
1590915859 };
......@@ -15912,7 +15862,7 @@ fn analyzePtrArithmetic(
1591215862 return block.addInst(.{
1591315863 .tag = air_tag,
1591415864 .data = .{ .ty_pl = .{
15915 .ty = try sema.addType(new_ptr_ty),
15865 .ty = Air.internedToRef(new_ptr_ty.toIntern()),
1591615866 .payload = try sema.addExtra(Air.Bin{
1591715867 .lhs = ptr,
1591815868 .rhs = offset,
......@@ -15998,7 +15948,7 @@ fn zirAsm(
1599815948 arg.* = .none;
1599915949 const out_ty = try sema.resolveType(block, ret_ty_src, output.data.operand);
1600015950 try sema.queueFullTypeResolution(out_ty);
16001 expr_ty = try sema.addType(out_ty);
15951 expr_ty = Air.internedToRef(out_ty.toIntern());
1600215952 } else {
1600315953 arg.* = try sema.resolveInst(output.data.operand);
1600415954 }
......@@ -16149,7 +16099,7 @@ fn zirCmpEq(
1614916099 if (try sema.resolveMaybeUndefVal(lhs)) |lval| {
1615016100 if (try sema.resolveMaybeUndefVal(rhs)) |rval| {
1615116101 if (lval.isUndef(mod) or rval.isUndef(mod)) {
16152 return sema.addConstUndef(Type.bool);
16102 return mod.undefRef(Type.bool);
1615316103 }
1615416104 const lkey = mod.intern_pool.indexToKey(lval.toIntern());
1615516105 const rkey = mod.intern_pool.indexToKey(rval.toIntern());
......@@ -16207,7 +16157,7 @@ fn analyzeCmpUnionTag(
1620716157 const coerced_union = try sema.coerce(block, union_tag_ty, un, un_src);
1620816158
1620916159 if (try sema.resolveMaybeUndefVal(coerced_tag)) |enum_val| {
16210 if (enum_val.isUndef(mod)) return sema.addConstUndef(Type.bool);
16160 if (enum_val.isUndef(mod)) return mod.undefRef(Type.bool);
1621116161 const field_ty = union_ty.unionFieldType(enum_val, mod);
1621216162 if (field_ty.zigTypeTag(mod) == .NoReturn) {
1621316163 return Air.Inst.Ref.bool_false;
......@@ -16309,13 +16259,13 @@ fn cmpSelf(
1630916259 const resolved_type = sema.typeOf(casted_lhs);
1631016260 const runtime_src: LazySrcLoc = src: {
1631116261 if (try sema.resolveMaybeUndefVal(casted_lhs)) |lhs_val| {
16312 if (lhs_val.isUndef(mod)) return sema.addConstUndef(Type.bool);
16262 if (lhs_val.isUndef(mod)) return mod.undefRef(Type.bool);
1631316263 if (try sema.resolveMaybeUndefVal(casted_rhs)) |rhs_val| {
16314 if (rhs_val.isUndef(mod)) return sema.addConstUndef(Type.bool);
16264 if (rhs_val.isUndef(mod)) return mod.undefRef(Type.bool);
1631516265
1631616266 if (resolved_type.zigTypeTag(mod) == .Vector) {
1631716267 const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_type);
16318 return sema.addConstant(cmp_val);
16268 return Air.internedToRef(cmp_val.toIntern());
1631916269 }
1632016270
1632116271 if (try sema.compareAll(lhs_val, op, rhs_val, resolved_type)) {
......@@ -16335,7 +16285,7 @@ fn cmpSelf(
1633516285 // bool eq/neq more efficiently.
1633616286 if (resolved_type.zigTypeTag(mod) == .Bool) {
1633716287 if (try sema.resolveMaybeUndefVal(casted_rhs)) |rhs_val| {
16338 if (rhs_val.isUndef(mod)) return sema.addConstUndef(Type.bool);
16288 if (rhs_val.isUndef(mod)) return mod.undefRef(Type.bool);
1633916289 return sema.runtimeBoolCmp(block, src, op, casted_lhs, rhs_val.toBool(), lhs_src);
1634016290 }
1634116291 }
......@@ -16389,7 +16339,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1638916339 .ComptimeFloat,
1639016340 .ComptimeInt,
1639116341 .Void,
16392 => return sema.addIntUnsigned(Type.comptime_int, 0),
16342 => return mod.intRef(Type.comptime_int, 0),
1639316343
1639416344 .Bool,
1639516345 .Int,
......@@ -16411,7 +16361,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1641116361 if (val.isLazySize(mod)) {
1641216362 try sema.queueFullTypeResolution(ty);
1641316363 }
16414 return sema.addConstant(val);
16364 return Air.internedToRef(val.toIntern());
1641516365}
1641616366
1641716367fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -16432,7 +16382,7 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
1643216382 .ComptimeFloat,
1643316383 .ComptimeInt,
1643416384 .Void,
16435 => return sema.addIntUnsigned(Type.comptime_int, 0),
16385 => return mod.intRef(Type.comptime_int, 0),
1643616386
1643716387 .Bool,
1643816388 .Int,
......@@ -16451,7 +16401,7 @@ fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
1645116401 => {},
1645216402 }
1645316403 const bit_size = try operand_ty.bitSizeAdvanced(mod, sema);
16454 return sema.addIntUnsigned(Type.comptime_int, bit_size);
16404 return mod.intRef(Type.comptime_int, bit_size);
1645516405}
1645616406
1645716407fn zirThis(
......@@ -16575,7 +16525,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
1657516525 return block.addTy(.alloc, ty_ip_index.toType());
1657616526 },
1657716527 .comptime_val => |val_ip_index| {
16578 return sema.addConstant(val_ip_index.toValue());
16528 return Air.internedToRef(val_ip_index);
1657916529 },
1658016530 }
1658116531}
......@@ -16588,7 +16538,7 @@ fn zirRetAddr(
1658816538 _ = extended;
1658916539 if (block.is_comptime) {
1659016540 // TODO: we could give a meaningful lazy value here. #14938
16591 return sema.addIntUnsigned(Type.usize, 0);
16541 return sema.mod.intRef(Type.usize, 0);
1659216542 } else {
1659316543 return block.addNoOp(.ret_addr);
1659416544 }
......@@ -16682,10 +16632,10 @@ fn zirBuiltinSrc(
1668216632 // column: u32,
1668316633 (try mod.intValue(Type.u32, extra.column + 1)).toIntern(),
1668416634 };
16685 return sema.addConstant((try mod.intern(.{ .aggregate = .{
16635 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
1668616636 .ty = src_loc_ty.toIntern(),
1668716637 .storage = .{ .elems = &fields },
16688 } })).toValue());
16638 } })));
1668916639}
1669016640
1669116641fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -16708,11 +16658,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1670816658 .Undefined,
1670916659 .Null,
1671016660 .EnumLiteral,
16711 => |type_info_tag| return sema.addConstant((try mod.intern(.{ .un = .{
16661 => |type_info_tag| return Air.internedToRef((try mod.intern(.{ .un = .{
1671216662 .ty = type_info_ty.toIntern(),
1671316663 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(type_info_tag))).toIntern(),
1671416664 .val = .void_value,
16715 } })).toValue()),
16665 } }))),
1671616666 .Fn => {
1671716667 // TODO: look into memoizing this result.
1671816668 var params_anon_decl = try block.startAnonDecl();
......@@ -16819,14 +16769,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1681916769 // args: []const Fn.Param,
1682016770 args_val,
1682116771 };
16822 return sema.addConstant((try mod.intern(.{ .un = .{
16772 return Air.internedToRef((try mod.intern(.{ .un = .{
1682316773 .ty = type_info_ty.toIntern(),
1682416774 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Fn))).toIntern(),
1682516775 .val = try mod.intern(.{ .aggregate = .{
1682616776 .ty = fn_info_ty.toIntern(),
1682716777 .storage = .{ .elems = &field_values },
1682816778 } }),
16829 } })).toValue());
16779 } })));
1683016780 },
1683116781 .Int => {
1683216782 const int_info_decl_index = (try sema.namespaceLookup(
......@@ -16848,14 +16798,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1684816798 // bits: u16,
1684916799 (try mod.intValue(Type.u16, info.bits)).toIntern(),
1685016800 };
16851 return sema.addConstant((try mod.intern(.{ .un = .{
16801 return Air.internedToRef((try mod.intern(.{ .un = .{
1685216802 .ty = type_info_ty.toIntern(),
1685316803 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Int))).toIntern(),
1685416804 .val = try mod.intern(.{ .aggregate = .{
1685516805 .ty = int_info_ty.toIntern(),
1685616806 .storage = .{ .elems = &field_values },
1685716807 } }),
16858 } })).toValue());
16808 } })));
1685916809 },
1686016810 .Float => {
1686116811 const float_info_decl_index = (try sema.namespaceLookup(
......@@ -16873,14 +16823,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1687316823 // bits: u16,
1687416824 (try mod.intValue(Type.u16, ty.bitSize(mod))).toIntern(),
1687516825 };
16876 return sema.addConstant((try mod.intern(.{ .un = .{
16826 return Air.internedToRef((try mod.intern(.{ .un = .{
1687716827 .ty = type_info_ty.toIntern(),
1687816828 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Float))).toIntern(),
1687916829 .val = try mod.intern(.{ .aggregate = .{
1688016830 .ty = float_info_ty.toIntern(),
1688116831 .storage = .{ .elems = &field_vals },
1688216832 } }),
16883 } })).toValue());
16833 } })));
1688416834 },
1688516835 .Pointer => {
1688616836 const info = ty.ptrInfo(mod);
......@@ -16936,14 +16886,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1693616886 else => info.sentinel.toValue(),
1693716887 })).toIntern(),
1693816888 };
16939 return sema.addConstant((try mod.intern(.{ .un = .{
16889 return Air.internedToRef((try mod.intern(.{ .un = .{
1694016890 .ty = type_info_ty.toIntern(),
1694116891 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Pointer))).toIntern(),
1694216892 .val = try mod.intern(.{ .aggregate = .{
1694316893 .ty = pointer_ty.toIntern(),
1694416894 .storage = .{ .elems = &field_values },
1694516895 } }),
16946 } })).toValue());
16896 } })));
1694716897 },
1694816898 .Array => {
1694916899 const array_field_ty = t: {
......@@ -16968,14 +16918,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1696816918 // sentinel: ?*const anyopaque,
1696916919 (try sema.optRefValue(block, info.elem_type, info.sentinel)).toIntern(),
1697016920 };
16971 return sema.addConstant((try mod.intern(.{ .un = .{
16921 return Air.internedToRef((try mod.intern(.{ .un = .{
1697216922 .ty = type_info_ty.toIntern(),
1697316923 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Array))).toIntern(),
1697416924 .val = try mod.intern(.{ .aggregate = .{
1697516925 .ty = array_field_ty.toIntern(),
1697616926 .storage = .{ .elems = &field_values },
1697716927 } }),
16978 } })).toValue());
16928 } })));
1697916929 },
1698016930 .Vector => {
1698116931 const vector_field_ty = t: {
......@@ -16998,14 +16948,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1699816948 // child: type,
1699916949 info.elem_type.toIntern(),
1700016950 };
17001 return sema.addConstant((try mod.intern(.{ .un = .{
16951 return Air.internedToRef((try mod.intern(.{ .un = .{
1700216952 .ty = type_info_ty.toIntern(),
1700316953 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Vector))).toIntern(),
1700416954 .val = try mod.intern(.{ .aggregate = .{
1700516955 .ty = vector_field_ty.toIntern(),
1700616956 .storage = .{ .elems = &field_values },
1700716957 } }),
17008 } })).toValue());
16958 } })));
1700916959 },
1701016960 .Optional => {
1701116961 const optional_field_ty = t: {
......@@ -17025,14 +16975,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1702516975 // child: type,
1702616976 ty.optionalChild(mod).toIntern(),
1702716977 };
17028 return sema.addConstant((try mod.intern(.{ .un = .{
16978 return Air.internedToRef((try mod.intern(.{ .un = .{
1702916979 .ty = type_info_ty.toIntern(),
1703016980 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Optional))).toIntern(),
1703116981 .val = try mod.intern(.{ .aggregate = .{
1703216982 .ty = optional_field_ty.toIntern(),
1703316983 .storage = .{ .elems = &field_values },
1703416984 } }),
17035 } })).toValue());
16985 } })));
1703616986 },
1703716987 .ErrorSet => {
1703816988 var fields_anon_decl = try block.startAnonDecl();
......@@ -17135,11 +17085,11 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1713517085 } });
1713617086
1713717087 // Construct Type{ .ErrorSet = errors_val }
17138 return sema.addConstant((try mod.intern(.{ .un = .{
17088 return Air.internedToRef((try mod.intern(.{ .un = .{
1713917089 .ty = type_info_ty.toIntern(),
1714017090 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.ErrorSet))).toIntern(),
1714117091 .val = errors_val,
17142 } })).toValue());
17092 } })));
1714317093 },
1714417094 .ErrorUnion => {
1714517095 const error_union_field_ty = t: {
......@@ -17161,14 +17111,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1716117111 // payload: type,
1716217112 ty.errorUnionPayload(mod).toIntern(),
1716317113 };
17164 return sema.addConstant((try mod.intern(.{ .un = .{
17114 return Air.internedToRef((try mod.intern(.{ .un = .{
1716517115 .ty = type_info_ty.toIntern(),
1716617116 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.ErrorUnion))).toIntern(),
1716717117 .val = try mod.intern(.{ .aggregate = .{
1716817118 .ty = error_union_field_ty.toIntern(),
1716917119 .storage = .{ .elems = &field_values },
1717017120 } }),
17171 } })).toValue());
17121 } })));
1717217122 },
1717317123 .Enum => {
1717417124 // TODO: look into memoizing this result.
......@@ -17287,14 +17237,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1728717237 // is_exhaustive: bool,
1728817238 is_exhaustive.toIntern(),
1728917239 };
17290 return sema.addConstant((try mod.intern(.{ .un = .{
17240 return Air.internedToRef((try mod.intern(.{ .un = .{
1729117241 .ty = type_info_ty.toIntern(),
1729217242 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Enum))).toIntern(),
1729317243 .val = try mod.intern(.{ .aggregate = .{
1729417244 .ty = type_enum_ty.toIntern(),
1729517245 .storage = .{ .elems = &field_values },
1729617246 } }),
17297 } })).toValue());
17247 } })));
1729817248 },
1729917249 .Union => {
1730017250 // TODO: look into memoizing this result.
......@@ -17438,14 +17388,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1743817388 // decls: []const Declaration,
1743917389 decls_val,
1744017390 };
17441 return sema.addConstant((try mod.intern(.{ .un = .{
17391 return Air.internedToRef((try mod.intern(.{ .un = .{
1744217392 .ty = type_info_ty.toIntern(),
1744317393 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Union))).toIntern(),
1744417394 .val = try mod.intern(.{ .aggregate = .{
1744517395 .ty = type_union_ty.toIntern(),
1744617396 .storage = .{ .elems = &field_values },
1744717397 } }),
17448 } })).toValue());
17398 } })));
1744917399 },
1745017400 .Struct => {
1745117401 // TODO: look into memoizing this result.
......@@ -17669,14 +17619,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1766917619 // is_tuple: bool,
1767017620 Value.makeBool(struct_ty.isTuple(mod)).toIntern(),
1767117621 };
17672 return sema.addConstant((try mod.intern(.{ .un = .{
17622 return Air.internedToRef((try mod.intern(.{ .un = .{
1767317623 .ty = type_info_ty.toIntern(),
1767417624 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Struct))).toIntern(),
1767517625 .val = try mod.intern(.{ .aggregate = .{
1767617626 .ty = type_struct_ty.toIntern(),
1767717627 .storage = .{ .elems = &field_values },
1767817628 } }),
17679 } })).toValue());
17629 } })));
1768017630 },
1768117631 .Opaque => {
1768217632 // TODO: look into memoizing this result.
......@@ -17701,14 +17651,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
1770117651 // decls: []const Declaration,
1770217652 decls_val,
1770317653 };
17704 return sema.addConstant((try mod.intern(.{ .un = .{
17654 return Air.internedToRef((try mod.intern(.{ .un = .{
1770517655 .ty = type_info_ty.toIntern(),
1770617656 .tag = (try mod.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.builtin.TypeId.Opaque))).toIntern(),
1770717657 .val = try mod.intern(.{ .aggregate = .{
1770817658 .ty = type_opaque_ty.toIntern(),
1770917659 .storage = .{ .elems = &field_values },
1771017660 } }),
17711 } })).toValue());
17661 } })));
1771217662 },
1771317663 .Frame => return sema.failWithUseOfAsync(block, src),
1771417664 .AnyFrame => return sema.failWithUseOfAsync(block, src),
......@@ -17842,7 +17792,7 @@ fn zirTypeof(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
1784217792 const inst_data = zir_datas[inst].un_node;
1784317793 const operand = try sema.resolveInst(inst_data.operand);
1784417794 const operand_ty = sema.typeOf(operand);
17845 return sema.addType(operand_ty);
17795 return Air.internedToRef(operand_ty.toIntern());
1784617796}
1784717797
1784817798fn zirTypeofBuiltin(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -17868,7 +17818,7 @@ fn zirTypeofBuiltin(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr
1786817818 const operand = try sema.resolveBody(&child_block, body, inst);
1786917819 const operand_ty = sema.typeOf(operand);
1787017820 if (operand_ty.isGenericPoison()) return error.GenericPoison;
17871 return sema.addType(operand_ty);
17821 return Air.internedToRef(operand_ty.toIntern());
1787217822}
1787317823
1787417824fn zirTypeofLog2IntType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -17877,7 +17827,7 @@ fn zirTypeofLog2IntType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil
1787717827 const operand = try sema.resolveInst(inst_data.operand);
1787817828 const operand_ty = sema.typeOf(operand);
1787917829 const res_ty = try sema.log2IntType(block, operand_ty, src);
17880 return sema.addType(res_ty);
17830 return Air.internedToRef(res_ty.toIntern());
1788117831}
1788217832
1788317833fn log2IntType(sema: *Sema, block: *Block, operand: Type, src: LazySrcLoc) CompileError!Type {
......@@ -17956,7 +17906,7 @@ fn zirTypeofPeer(
1795617906 }
1795717907
1795817908 const result_type = try sema.resolvePeerTypes(block, src, inst_list, .{ .typeof_builtin_call_node_offset = extra.data.src_node });
17959 return sema.addType(result_type);
17909 return Air.internedToRef(result_type.toIntern());
1796017910}
1796117911
1796217912fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -17972,7 +17922,7 @@ fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
1797217922 const operand = try sema.coerce(block, Type.bool, uncasted_operand, operand_src);
1797317923 if (try sema.resolveMaybeUndefVal(operand)) |val| {
1797417924 return if (val.isUndef(mod))
17975 sema.addConstUndef(Type.bool)
17925 mod.undefRef(Type.bool)
1797617926 else if (val.toBool())
1797717927 Air.Inst.Ref.bool_false
1797817928 else
......@@ -18348,7 +18298,7 @@ fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErr
1834818298 .address_space = ptr_info.flags.address_space,
1834918299 },
1835018300 });
18351 const res_ty_ref = try sema.addType(res_ty);
18301 const res_ty_ref = Air.internedToRef(res_ty.toIntern());
1835218302 try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.TryPtr).Struct.fields.len +
1835318303 sub_block.instructions.items.len);
1835418304 const try_inst = try parent_block.addInst(.{
......@@ -18453,10 +18403,10 @@ fn zirRetErrValue(
1845318403 const src = inst_data.src();
1845418404 // Return the error code from the function.
1845518405 const error_set_type = try mod.singleErrorSetType(err_name);
18456 const result_inst = try sema.addConstant((try mod.intern(.{ .err = .{
18406 const result_inst = Air.internedToRef((try mod.intern(.{ .err = .{
1845718407 .ty = error_set_type.toIntern(),
1845818408 .name = err_name,
18459 } })).toValue());
18409 } })));
1846018410 return sema.analyzeRet(block, result_inst, src);
1846118411}
1846218412
......@@ -18900,7 +18850,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
1890018850 .host_size = host_size,
1890118851 },
1890218852 });
18903 return sema.addType(ty);
18853 return Air.internedToRef(ty.toIntern());
1890418854}
1890518855
1890618856fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -18915,7 +18865,7 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
1891518865 switch (obj_ty.zigTypeTag(mod)) {
1891618866 .Struct => return sema.structInitEmpty(block, obj_ty, src, src),
1891718867 .Array, .Vector => return sema.arrayInitEmpty(block, src, obj_ty),
18918 .Void => return sema.addConstant(Value.void),
18868 .Void => return Air.internedToRef(Value.void.toIntern()),
1891918869 .Union => return sema.fail(block, src, "union initializer must initialize one field", .{}),
1892018870 else => return sema.failWithArrayInitNotSupported(block, src, obj_ty),
1892118871 }
......@@ -18951,10 +18901,10 @@ fn arrayInitEmpty(sema: *Sema, block: *Block, src: LazySrcLoc, obj_ty: Type) Com
1895118901 return sema.fail(block, src, "expected {d} vector elements; found 0", .{arr_len});
1895218902 }
1895318903 }
18954 return sema.addConstant((try mod.intern(.{ .aggregate = .{
18904 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
1895518905 .ty = obj_ty.toIntern(),
1895618906 .storage = .{ .elems = &.{} },
18957 } })).toValue());
18907 } })));
1895818908}
1895918909
1896018910fn zirUnionInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -18997,11 +18947,11 @@ fn unionInit(
1899718947 const tag_ty = union_ty.unionTagTypeHypothetical(mod);
1899818948 const enum_field_index = @as(u32, @intCast(tag_ty.enumFieldIndex(field_name, mod).?));
1899918949 const tag_val = try mod.enumValueFieldIndex(tag_ty, enum_field_index);
19000 return sema.addConstant((try mod.intern(.{ .un = .{
18950 return Air.internedToRef((try mod.intern(.{ .un = .{
1900118951 .ty = union_ty.toIntern(),
1900218952 .tag = try tag_val.intern(tag_ty, mod),
1900318953 .val = try init_val.intern(field.ty, mod),
19004 } })).toValue());
18954 } })));
1900518955 }
1900618956
1900718957 try sema.requireRuntimeBlock(block, init_src, null);
......@@ -19125,7 +19075,7 @@ fn zirStructInit(
1912519075 const alloc = try block.addTy(.alloc, alloc_ty);
1912619076 const field_ptr = try sema.unionFieldPtr(block, field_src, alloc, field_name, field_src, resolved_ty, true);
1912719077 try sema.storePtr(block, src, field_ptr, init_inst);
19128 const new_tag = try sema.addConstant(tag_val);
19078 const new_tag = Air.internedToRef(tag_val.toIntern());
1912919079 _ = try block.addBinOp(.set_union_tag, alloc, new_tag);
1913019080 return sema.makePtrConst(block, alloc);
1913119081 }
......@@ -19178,7 +19128,7 @@ fn finishStructInit(
1917819128 }
1917919129 }
1918019130 } else {
19181 field_inits[i] = try sema.addConstant(default_val.toValue());
19131 field_inits[i] = Air.internedToRef(default_val);
1918219132 }
1918319133 }
1918419134 },
......@@ -19197,7 +19147,7 @@ fn finishStructInit(
1919719147 root_msg = try sema.errMsg(block, init_src, template, args);
1919819148 }
1919919149 } else {
19200 field_inits[i] = try sema.addConstant(field.default_val.toValue());
19150 field_inits[i] = Air.internedToRef(field.default_val);
1920119151 }
1920219152 }
1920319153 },
......@@ -19492,7 +19442,7 @@ fn zirArrayInit(
1949219442 }
1949319443
1949419444 if (sentinel_val) |some| {
19495 resolved_args[resolved_args.len - 1] = try sema.addConstant(some);
19445 resolved_args[resolved_args.len - 1] = Air.internedToRef(some.toIntern());
1949619446 }
1949719447
1949819448 const opt_runtime_index: ?u32 = for (resolved_args, 0..) |arg, i| {
......@@ -19541,9 +19491,9 @@ fn zirArrayInit(
1954119491 .child = array_ty.structFieldType(i, mod).toIntern(),
1954219492 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
1954319493 });
19544 const elem_ptr_ty_ref = try sema.addType(elem_ptr_ty);
19494 const elem_ptr_ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
1954519495
19546 const index = try sema.addIntUnsigned(Type.usize, i);
19496 const index = try mod.intRef(Type.usize, i);
1954719497 const elem_ptr = try block.addPtrElemPtrTypeRef(alloc, index, elem_ptr_ty_ref);
1954819498 _ = try block.addBinOp(.store, elem_ptr, arg);
1954919499 }
......@@ -19554,10 +19504,10 @@ fn zirArrayInit(
1955419504 .child = array_ty.elemType2(mod).toIntern(),
1955519505 .flags = .{ .address_space = target_util.defaultAddressSpace(target, .local) },
1955619506 });
19557 const elem_ptr_ty_ref = try sema.addType(elem_ptr_ty);
19507 const elem_ptr_ty_ref = Air.internedToRef(elem_ptr_ty.toIntern());
1955819508
1955919509 for (resolved_args, 0..) |arg, i| {
19560 const index = try sema.addIntUnsigned(Type.usize, i);
19510 const index = try mod.intRef(Type.usize, i);
1956119511 const elem_ptr = try block.addPtrElemPtrTypeRef(alloc, index, elem_ptr_ty_ref);
1956219512 _ = try block.addBinOp(.store, elem_ptr, arg);
1956319513 }
......@@ -19671,7 +19621,7 @@ fn addConstantMaybeRef(
1967119621 val: Value,
1967219622 is_ref: bool,
1967319623) !Air.Inst.Ref {
19674 if (!is_ref) return sema.addConstant(val);
19624 if (!is_ref) return Air.internedToRef(val.toIntern());
1967519625
1967619626 var anon_decl = try block.startAnonDecl();
1967719627 defer anon_decl.deinit();
......@@ -19730,13 +19680,13 @@ fn fieldType(
1973019680 .Struct => switch (mod.intern_pool.indexToKey(cur_ty.toIntern())) {
1973119681 .anon_struct_type => |anon_struct| {
1973219682 const field_index = try sema.anonStructFieldIndex(block, cur_ty, field_name, field_src);
19733 return sema.addType(anon_struct.types[field_index].toType());
19683 return Air.internedToRef(anon_struct.types[field_index]);
1973419684 },
1973519685 .struct_type => |struct_type| {
1973619686 const struct_obj = mod.structPtrUnwrap(struct_type.index).?;
1973719687 const field = struct_obj.fields.get(field_name) orelse
1973819688 return sema.failWithBadStructFieldAccess(block, struct_obj, field_src, field_name);
19739 return sema.addType(field.ty);
19689 return Air.internedToRef(field.ty.toIntern());
1974019690 },
1974119691 else => unreachable,
1974219692 },
......@@ -19744,7 +19694,7 @@ fn fieldType(
1974419694 const union_obj = mod.typeToUnion(cur_ty).?;
1974519695 const field = union_obj.fields.get(field_name) orelse
1974619696 return sema.failWithBadUnionFieldAccess(block, union_obj, field_src, field_name);
19747 return sema.addType(field.ty);
19697 return Air.internedToRef(field.ty.toIntern());
1974819698 },
1974919699 .Optional => {
1975019700 // Struct/array init through optional requires the child type to not be a pointer.
......@@ -19783,10 +19733,10 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref {
1978319733 {
1978419734 return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty);
1978519735 }
19786 return sema.addConstant((try mod.intern(.{ .opt = .{
19736 return Air.internedToRef((try mod.intern(.{ .opt = .{
1978719737 .ty = opt_ptr_stack_trace_ty.toIntern(),
1978819738 .val = .none,
19789 } })).toValue());
19739 } })));
1979019740}
1979119741
1979219742fn zirFrame(
......@@ -19810,7 +19760,7 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air
1981019760 if (val.isLazyAlign(mod)) {
1981119761 try sema.queueFullTypeResolution(ty);
1981219762 }
19813 return sema.addConstant(val);
19763 return Air.internedToRef(val.toIntern());
1981419764}
1981519765
1981619766fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -19818,9 +19768,9 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
1981819768 const inst_data = sema.code.instructions.items(.data)[inst].un_node;
1981919769 const operand = try sema.resolveInst(inst_data.operand);
1982019770 if (try sema.resolveMaybeUndefVal(operand)) |val| {
19821 if (val.isUndef(mod)) return sema.addConstUndef(Type.u1);
19822 if (val.toBool()) return sema.addConstant(try mod.intValue(Type.u1, 1));
19823 return sema.addConstant(try mod.intValue(Type.u1, 0));
19771 if (val.isUndef(mod)) return mod.undefRef(Type.u1);
19772 if (val.toBool()) return Air.internedToRef((try mod.intValue(Type.u1, 1)).toIntern());
19773 return Air.internedToRef((try mod.intValue(Type.u1, 0)).toIntern());
1982419774 }
1982519775 return block.addUnOp(.int_from_bool, operand);
1982619776}
......@@ -19878,17 +19828,17 @@ fn zirUnaryMath(
1987819828 });
1987919829 if (try sema.resolveMaybeUndefVal(operand)) |val| {
1988019830 if (val.isUndef(mod))
19881 return sema.addConstUndef(result_ty);
19831 return mod.undefRef(result_ty);
1988219832
1988319833 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
1988419834 for (elems, 0..) |*elem, i| {
1988519835 const elem_val = try val.elemValue(sema.mod, i);
1988619836 elem.* = try (try eval(elem_val, scalar_ty, sema.arena, sema.mod)).intern(scalar_ty, mod);
1988719837 }
19888 return sema.addConstant((try mod.intern(.{ .aggregate = .{
19838 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
1988919839 .ty = result_ty.toIntern(),
1989019840 .storage = .{ .elems = elems },
19891 } })).toValue());
19841 } })));
1989219842 }
1989319843
1989419844 try sema.requireRuntimeBlock(block, operand_src, null);
......@@ -19897,9 +19847,9 @@ fn zirUnaryMath(
1989719847 .ComptimeFloat, .Float => {
1989819848 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
1989919849 if (operand_val.isUndef(mod))
19900 return sema.addConstUndef(operand_ty);
19850 return mod.undefRef(operand_ty);
1990119851 const result_val = try eval(operand_val, operand_ty, sema.arena, sema.mod);
19902 return sema.addConstant(result_val);
19852 return Air.internedToRef(result_val.toIntern());
1990319853 }
1990419854
1990519855 try sema.requireRuntimeBlock(block, operand_src, null);
......@@ -20024,7 +19974,7 @@ fn zirReify(
2002419974 const signedness = mod.toEnum(std.builtin.Signedness, signedness_val);
2002519975 const bits = @as(u16, @intCast(bits_val.toUnsignedInt(mod)));
2002619976 const ty = try mod.intType(signedness, bits);
20027 return sema.addType(ty);
19977 return Air.internedToRef(ty.toIntern());
2002819978 },
2002919979 .Vector => {
2003019980 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20044,7 +19994,7 @@ fn zirReify(
2004419994 .len = len,
2004519995 .child = child_ty.toIntern(),
2004619996 });
20047 return sema.addType(ty);
19997 return Air.internedToRef(ty.toIntern());
2004819998 },
2004919999 .Float => {
2005020000 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20061,7 +20011,7 @@ fn zirReify(
2006120011 128 => Type.f128,
2006220012 else => return sema.fail(block, src, "{}-bit float unsupported", .{bits}),
2006320013 };
20064 return sema.addType(ty);
20014 return Air.internedToRef(ty.toIntern());
2006520015 },
2006620016 .Pointer => {
2006720017 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20167,7 +20117,7 @@ fn zirReify(
2016720117 .is_allowzero = is_allowzero_val.toBool(),
2016820118 },
2016920119 });
20170 return sema.addType(ty);
20120 return Air.internedToRef(ty.toIntern());
2017120121 },
2017220122 .Array => {
2017320123 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20193,7 +20143,7 @@ fn zirReify(
2019320143 .sentinel = if (sentinel) |s| s.toIntern() else .none,
2019420144 .child = child_ty.toIntern(),
2019520145 });
20196 return sema.addType(ty);
20146 return Air.internedToRef(ty.toIntern());
2019720147 },
2019820148 .Optional => {
2019920149 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20204,7 +20154,7 @@ fn zirReify(
2020420154 const child_ty = child_val.toType();
2020520155
2020620156 const ty = try mod.optionalType(child_ty.toIntern());
20207 return sema.addType(ty);
20157 return Air.internedToRef(ty.toIntern());
2020820158 },
2020920159 .ErrorUnion => {
2021020160 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20223,11 +20173,11 @@ fn zirReify(
2022320173 }
2022420174
2022520175 const ty = try mod.errorUnionType(error_set_ty, payload_ty);
20226 return sema.addType(ty);
20176 return Air.internedToRef(ty.toIntern());
2022720177 },
2022820178 .ErrorSet => {
2022920179 const payload_val = union_val.val.toValue().optionalValue(mod) orelse
20230 return sema.addType(Type.anyerror);
20180 return Air.internedToRef(Type.anyerror.toIntern());
2023120181
2023220182 const len = try sema.usizeCast(block, src, payload_val.sliceLen(mod));
2023320183 var names: InferredErrorSet.NameMap = .{};
......@@ -20250,7 +20200,7 @@ fn zirReify(
2025020200 }
2025120201
2025220202 const ty = try mod.errorSetFromUnsortedNames(names.keys());
20253 return sema.addType(ty);
20203 return Air.internedToRef(ty.toIntern());
2025420204 },
2025520205 .Struct => {
2025620206 const fields = ip.typeOf(union_val.val).toType().structFields(mod);
......@@ -20744,7 +20694,7 @@ fn zirReify(
2074420694 .section_is_generic = false,
2074520695 .addrspace_is_generic = false,
2074620696 });
20747 return sema.addType(ty);
20697 return Air.internedToRef(ty.toIntern());
2074820698 },
2074920699 .Frame => return sema.failWithUseOfAsync(block, src),
2075020700 }
......@@ -21106,7 +21056,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
2110621056
2110721057 if (try sema.resolveMaybeUndefVal(operand)) |val| {
2110821058 const result_val = try sema.intFromFloat(block, operand_src, val, operand_ty, dest_ty);
21109 return sema.addConstant(result_val);
21059 return Air.internedToRef(result_val.toIntern());
2111021060 } else if (dest_ty.zigTypeTag(mod) == .ComptimeInt) {
2111121061 return sema.failWithNeededComptime(block, operand_src, "value being casted to 'comptime_int' must be comptime-known");
2111221062 }
......@@ -21114,17 +21064,17 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
2111421064 try sema.requireRuntimeBlock(block, inst_data.src(), operand_src);
2111521065 if (dest_ty.intInfo(mod).bits == 0) {
2111621066 if (block.wantSafety()) {
21117 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)));
21067 const ok = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_eq_optimized else .cmp_eq, operand, Air.internedToRef((try mod.floatValue(operand_ty, 0.0)).toIntern()));
2111821068 try sema.addSafetyCheck(block, src, ok, .integer_part_out_of_bounds);
2111921069 }
21120 return sema.addConstant(try mod.intValue(dest_ty, 0));
21070 return Air.internedToRef((try mod.intValue(dest_ty, 0)).toIntern());
2112121071 }
2112221072 const result = try block.addTyOp(if (block.float_mode == .Optimized) .int_from_float_optimized else .int_from_float, dest_ty, operand);
2112321073 if (block.wantSafety()) {
2112421074 const back = try block.addTyOp(.float_from_int, operand_ty, result);
2112521075 const diff = try block.addBinOp(.sub, operand, back);
21126 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)));
21127 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)));
21076 const ok_pos = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_lt_optimized else .cmp_lt, diff, Air.internedToRef((try mod.floatValue(operand_ty, 1.0)).toIntern()));
21077 const ok_neg = try block.addBinOp(if (block.float_mode == .Optimized) .cmp_gt_optimized else .cmp_gt, diff, Air.internedToRef((try mod.floatValue(operand_ty, -1.0)).toIntern()));
2112821078 const ok = try block.addBinOp(.bool_and, ok_pos, ok_neg);
2112921079 try sema.addSafetyCheck(block, src, ok, .integer_part_out_of_bounds);
2113021080 }
......@@ -21146,7 +21096,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro
2114621096
2114721097 if (try sema.resolveMaybeUndefVal(operand)) |val| {
2114821098 const result_val = try val.floatFromIntAdvanced(sema.arena, operand_ty, dest_ty, sema.mod, sema);
21149 return sema.addConstant(result_val);
21099 return Air.internedToRef(result_val.toIntern());
2115021100 } else if (dest_ty.zigTypeTag(mod) == .ComptimeFloat) {
2115121101 return sema.failWithNeededComptime(block, operand_src, "value being casted to 'comptime_float' must be comptime-known");
2115221102 }
......@@ -21196,7 +21146,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2119621146 .Pointer => try mod.ptrIntValue(ptr_ty, addr),
2119721147 else => unreachable,
2119821148 };
21199 return sema.addConstant(ptr_val);
21149 return Air.internedToRef(ptr_val.toIntern());
2120021150 }
2120121151
2120221152 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -21207,9 +21157,7 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2120721157 }
2120821158
2120921159 if (ptr_align > 1) {
21210 const align_minus_1 = try sema.addConstant(
21211 try mod.intValue(Type.usize, ptr_align - 1),
21212 );
21160 const align_minus_1 = Air.internedToRef((try mod.intValue(Type.usize, ptr_align - 1)).toIntern());
2121321161 const remainder = try block.addBinOp(.bit_and, operand_coerced, align_minus_1);
2121421162 const is_aligned = try block.addBinOp(.cmp_eq, remainder, .zero_usize);
2121521163 try sema.addSafetyCheck(block, src, is_aligned, .incorrect_alignment);
......@@ -21293,7 +21241,7 @@ fn zirErrSetCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
2129321241 }
2129421242 }
2129521243
21296 return sema.addConstant(try mod.getCoerced(val, dest_ty));
21244 return Air.internedToRef((try mod.getCoerced(val, dest_ty)).toIntern());
2129721245 }
2129821246
2129921247 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -21620,16 +21568,16 @@ fn ptrCastFull(
2162021568 }
2162121569 }
2162221570 if (dest_info.flags.size == .Slice and src_info.flags.size != .Slice) {
21623 if (ptr_val.isUndef(mod)) return sema.addConstUndef(dest_ty);
21571 if (ptr_val.isUndef(mod)) return mod.undefRef(dest_ty);
2162421572 const arr_len = try mod.intValue(Type.usize, src_info.child.toType().arrayLen(mod));
21625 return sema.addConstant((try mod.intern(.{ .ptr = .{
21573 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2162621574 .ty = dest_ty.toIntern(),
2162721575 .addr = mod.intern_pool.indexToKey(ptr_val.toIntern()).ptr.addr,
2162821576 .len = arr_len.toIntern(),
21629 } })).toValue());
21577 } })));
2163021578 } else {
2163121579 assert(dest_ptr_ty.eql(dest_ty, mod));
21632 return sema.addConstant(try mod.getCoerced(ptr_val, dest_ty));
21580 return Air.internedToRef((try mod.getCoerced(ptr_val, dest_ty)).toIntern());
2163321581 }
2163421582 }
2163521583 }
......@@ -21650,9 +21598,7 @@ fn ptrCastFull(
2165021598 }
2165121599
2165221600 if (block.wantSafety() and dest_align > src_align and try sema.typeHasRuntimeBits(dest_info.child.toType())) {
21653 const align_minus_1 = try sema.addConstant(
21654 try mod.intValue(Type.usize, dest_align - 1),
21655 );
21601 const align_minus_1 = Air.internedToRef((try mod.intValue(Type.usize, dest_align - 1)).toIntern());
2165621602 const ptr_int = try block.addUnOp(.int_from_ptr, ptr);
2165721603 const remainder = try block.addBinOp(.bit_and, ptr_int, align_minus_1);
2165821604 const is_aligned = try block.addBinOp(.cmp_eq, remainder, .zero_usize);
......@@ -21676,7 +21622,7 @@ fn ptrCastFull(
2167621622 const intermediate = try block.addInst(.{
2167721623 .tag = .addrspace_cast,
2167821624 .data = .{ .ty_op = .{
21679 .ty = try sema.addType(intermediate_ty),
21625 .ty = Air.internedToRef(intermediate_ty.toIntern()),
2168021626 .operand = ptr,
2168121627 } },
2168221628 });
......@@ -21692,13 +21638,11 @@ fn ptrCastFull(
2169221638 if (dest_info.flags.size == .Slice and src_info.flags.size != .Slice) {
2169321639 // We have to construct a slice using the operand's child's array length
2169421640 // Note that we know from the check at the start of the function that operand_ty is slice-like
21695 const arr_len = try sema.addConstant(
21696 try mod.intValue(Type.usize, src_info.child.toType().arrayLen(mod)),
21697 );
21641 const arr_len = Air.internedToRef((try mod.intValue(Type.usize, src_info.child.toType().arrayLen(mod))).toIntern());
2169821642 return block.addInst(.{
2169921643 .tag = .slice,
2170021644 .data = .{ .ty_pl = .{
21701 .ty = try sema.addType(dest_ty),
21645 .ty = Air.internedToRef(dest_ty.toIntern()),
2170221646 .payload = try sema.addExtra(Air.Bin{
2170321647 .lhs = result_ptr,
2170421648 .rhs = arr_len,
......@@ -21727,7 +21671,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst
2172721671 const dest_ty = try mod.ptrType(ptr_info);
2172821672
2172921673 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
21730 return sema.addConstant(try mod.getCoerced(operand_val, dest_ty));
21674 return Air.internedToRef((try mod.getCoerced(operand_val, dest_ty)).toIntern());
2173121675 }
2173221676
2173321677 try sema.requireRuntimeBlock(block, src, null);
......@@ -21759,13 +21703,13 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2175921703 const dest_info = dest_scalar_ty.intInfo(mod);
2176021704
2176121705 if (try sema.typeHasOnePossibleValue(dest_ty)) |val| {
21762 return sema.addConstant(val);
21706 return Air.internedToRef(val.toIntern());
2176321707 }
2176421708
2176521709 if (operand_scalar_ty.zigTypeTag(mod) != .ComptimeInt) {
2176621710 const operand_info = operand_ty.intInfo(mod);
2176721711 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21768 return sema.addConstant(val);
21712 return Air.internedToRef(val.toIntern());
2176921713 }
2177021714
2177121715 if (operand_info.signedness != dest_info.signedness) {
......@@ -21795,22 +21739,22 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2179521739 }
2179621740
2179721741 if (try sema.resolveMaybeUndefValIntable(operand)) |val| {
21798 if (val.isUndef(mod)) return sema.addConstUndef(dest_ty);
21742 if (val.isUndef(mod)) return mod.undefRef(dest_ty);
2179921743 if (!dest_is_vector) {
21800 return sema.addConstant(try mod.getCoerced(
21744 return Air.internedToRef((try mod.getCoerced(
2180121745 try val.intTrunc(operand_ty, sema.arena, dest_info.signedness, dest_info.bits, mod),
2180221746 dest_ty,
21803 ));
21747 )).toIntern());
2180421748 }
2180521749 const elems = try sema.arena.alloc(InternPool.Index, operand_ty.vectorLen(mod));
2180621750 for (elems, 0..) |*elem, i| {
2180721751 const elem_val = try val.elemValue(mod, i);
2180821752 elem.* = try (try elem_val.intTrunc(operand_scalar_ty, sema.arena, dest_info.signedness, dest_info.bits, mod)).intern(dest_scalar_ty, mod);
2180921753 }
21810 return sema.addConstant((try mod.intern(.{ .aggregate = .{
21754 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
2181121755 .ty = dest_ty.toIntern(),
2181221756 .storage = .{ .elems = elems },
21813 } })).toValue());
21757 } })));
2181421758 }
2181521759
2181621760 try sema.requireRuntimeBlock(block, src, operand_src);
......@@ -21834,7 +21778,7 @@ fn zirBitCount(
2183421778 const bits = operand_ty.intInfo(mod).bits;
2183521779
2183621780 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21837 return sema.addConstant(val);
21781 return Air.internedToRef(val.toIntern());
2183821782 }
2183921783
2184021784 const result_scalar_ty = try mod.smallestUnsignedInt(bits);
......@@ -21846,7 +21790,7 @@ fn zirBitCount(
2184621790 .child = result_scalar_ty.toIntern(),
2184721791 });
2184821792 if (try sema.resolveMaybeUndefVal(operand)) |val| {
21849 if (val.isUndef(mod)) return sema.addConstUndef(result_ty);
21793 if (val.isUndef(mod)) return mod.undefRef(result_ty);
2185021794
2185121795 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
2185221796 const scalar_ty = operand_ty.scalarType(mod);
......@@ -21855,10 +21799,10 @@ fn zirBitCount(
2185521799 const count = comptimeOp(elem_val, scalar_ty, mod);
2185621800 elem.* = (try mod.intValue(result_scalar_ty, count)).toIntern();
2185721801 }
21858 return sema.addConstant((try mod.intern(.{ .aggregate = .{
21802 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
2185921803 .ty = result_ty.toIntern(),
2186021804 .storage = .{ .elems = elems },
21861 } })).toValue());
21805 } })));
2186221806 } else {
2186321807 try sema.requireRuntimeBlock(block, src, operand_src);
2186421808 return block.addTyOp(air_tag, result_ty, operand);
......@@ -21866,8 +21810,8 @@ fn zirBitCount(
2186621810 },
2186721811 .Int => {
2186821812 if (try sema.resolveMaybeUndefLazyVal(operand)) |val| {
21869 if (val.isUndef(mod)) return sema.addConstUndef(result_scalar_ty);
21870 return sema.addIntUnsigned(result_scalar_ty, comptimeOp(val, operand_ty, mod));
21813 if (val.isUndef(mod)) return mod.undefRef(result_scalar_ty);
21814 return mod.intRef(result_scalar_ty, comptimeOp(val, operand_ty, mod));
2187121815 } else {
2187221816 try sema.requireRuntimeBlock(block, src, operand_src);
2187321817 return block.addTyOp(air_tag, result_scalar_ty, operand);
......@@ -21896,15 +21840,15 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2189621840 }
2189721841
2189821842 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21899 return sema.addConstant(val);
21843 return Air.internedToRef(val.toIntern());
2190021844 }
2190121845
2190221846 switch (operand_ty.zigTypeTag(mod)) {
2190321847 .Int => {
2190421848 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
21905 if (val.isUndef(mod)) return sema.addConstUndef(operand_ty);
21849 if (val.isUndef(mod)) return mod.undefRef(operand_ty);
2190621850 const result_val = try val.byteSwap(operand_ty, mod, sema.arena);
21907 return sema.addConstant(result_val);
21851 return Air.internedToRef(result_val.toIntern());
2190821852 } else operand_src;
2190921853
2191021854 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -21913,7 +21857,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2191321857 .Vector => {
2191421858 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
2191521859 if (val.isUndef(mod))
21916 return sema.addConstUndef(operand_ty);
21860 return mod.undefRef(operand_ty);
2191721861
2191821862 const vec_len = operand_ty.vectorLen(mod);
2191921863 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
......@@ -21921,10 +21865,10 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
2192121865 const elem_val = try val.elemValue(mod, i);
2192221866 elem.* = try (try elem_val.byteSwap(scalar_ty, mod, sema.arena)).intern(scalar_ty, mod);
2192321867 }
21924 return sema.addConstant((try mod.intern(.{ .aggregate = .{
21868 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
2192521869 .ty = operand_ty.toIntern(),
2192621870 .storage = .{ .elems = elems },
21927 } })).toValue());
21871 } })));
2192821872 } else operand_src;
2192921873
2193021874 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -21943,16 +21887,16 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2194321887 const scalar_ty = try sema.checkIntOrVector(block, operand, operand_src);
2194421888
2194521889 if (try sema.typeHasOnePossibleValue(operand_ty)) |val| {
21946 return sema.addConstant(val);
21890 return Air.internedToRef(val.toIntern());
2194721891 }
2194821892
2194921893 const mod = sema.mod;
2195021894 switch (operand_ty.zigTypeTag(mod)) {
2195121895 .Int => {
2195221896 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
21953 if (val.isUndef(mod)) return sema.addConstUndef(operand_ty);
21897 if (val.isUndef(mod)) return mod.undefRef(operand_ty);
2195421898 const result_val = try val.bitReverse(operand_ty, mod, sema.arena);
21955 return sema.addConstant(result_val);
21899 return Air.internedToRef(result_val.toIntern());
2195621900 } else operand_src;
2195721901
2195821902 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -21961,7 +21905,7 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2196121905 .Vector => {
2196221906 const runtime_src = if (try sema.resolveMaybeUndefVal(operand)) |val| {
2196321907 if (val.isUndef(mod))
21964 return sema.addConstUndef(operand_ty);
21908 return mod.undefRef(operand_ty);
2196521909
2196621910 const vec_len = operand_ty.vectorLen(mod);
2196721911 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
......@@ -21969,10 +21913,10 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2196921913 const elem_val = try val.elemValue(mod, i);
2197021914 elem.* = try (try elem_val.bitReverse(scalar_ty, mod, sema.arena)).intern(scalar_ty, mod);
2197121915 }
21972 return sema.addConstant((try mod.intern(.{ .aggregate = .{
21916 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
2197321917 .ty = operand_ty.toIntern(),
2197421918 .storage = .{ .elems = elems },
21975 } })).toValue());
21919 } })));
2197621920 } else operand_src;
2197721921
2197821922 try sema.requireRuntimeBlock(block, src, runtime_src);
......@@ -21984,13 +21928,13 @@ fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2198421928
2198521929fn zirBitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
2198621930 const offset = try sema.bitOffsetOf(block, inst);
21987 return sema.addIntUnsigned(Type.comptime_int, offset);
21931 return sema.mod.intRef(Type.comptime_int, offset);
2198821932}
2198921933
2199021934fn zirOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
2199121935 const offset = try sema.bitOffsetOf(block, inst);
2199221936 // TODO reminder to make this a compile error for packed structs
21993 return sema.addIntUnsigned(Type.comptime_int, offset / 8);
21937 return sema.mod.intRef(Type.comptime_int, offset / 8);
2199421938}
2199521939
2199621940fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u64 {
......@@ -22622,10 +22566,10 @@ fn zirCmpxchg(
2262222566
2262322567 // special case zero bit types
2262422568 if ((try sema.typeHasOnePossibleValue(elem_ty)) != null) {
22625 return sema.addConstant((try mod.intern(.{ .opt = .{
22569 return Air.internedToRef((try mod.intern(.{ .opt = .{
2262622570 .ty = result_ty.toIntern(),
2262722571 .val = .none,
22628 } })).toValue());
22572 } })));
2262922573 }
2263022574
2263122575 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
......@@ -22634,7 +22578,7 @@ fn zirCmpxchg(
2263422578 if (expected_val.isUndef(mod) or new_val.isUndef(mod)) {
2263522579 // TODO: this should probably cause the memory stored at the pointer
2263622580 // to become undef as well
22637 return sema.addConstUndef(result_ty);
22581 return mod.undefRef(result_ty);
2263822582 }
2263922583 const ptr_ty = sema.typeOf(ptr);
2264022584 const stored_val = (try sema.pointerDeref(block, ptr_src, ptr_val, ptr_ty)) orelse break :rs ptr_src;
......@@ -22645,7 +22589,7 @@ fn zirCmpxchg(
2264522589 break :blk .none;
2264622590 } else stored_val.toIntern(),
2264722591 } });
22648 return sema.addConstant(result_val.toValue());
22592 return Air.internedToRef(result_val);
2264922593 } else break :rs new_value_src;
2265022594 } else break :rs expected_src;
2265122595 } else ptr_src;
......@@ -22657,7 +22601,7 @@ fn zirCmpxchg(
2265722601 return block.addInst(.{
2265822602 .tag = air_tag,
2265922603 .data = .{ .ty_pl = .{
22660 .ty = try sema.addType(result_ty),
22604 .ty = Air.internedToRef(result_ty.toIntern()),
2266122605 .payload = try sema.addExtra(Air.Cmpxchg{
2266222606 .ptr = ptr,
2266322607 .expected_value = expected_value,
......@@ -22682,8 +22626,8 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I
2268222626 const scalar_ty = dest_ty.childType(mod);
2268322627 const scalar = try sema.coerce(block, scalar_ty, operand, scalar_src);
2268422628 if (try sema.resolveMaybeUndefVal(scalar)) |scalar_val| {
22685 if (scalar_val.isUndef(mod)) return sema.addConstUndef(dest_ty);
22686 return sema.addConstant(try sema.splat(dest_ty, scalar_val));
22629 if (scalar_val.isUndef(mod)) return mod.undefRef(dest_ty);
22630 return Air.internedToRef((try sema.splat(dest_ty, scalar_val)).toIntern());
2268722631 }
2268822632
2268922633 try sema.requireRuntimeBlock(block, inst_data.src(), scalar_src);
......@@ -22730,7 +22674,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
2273022674 }
2273122675
2273222676 if (try sema.resolveMaybeUndefVal(operand)) |operand_val| {
22733 if (operand_val.isUndef(mod)) return sema.addConstUndef(scalar_ty);
22677 if (operand_val.isUndef(mod)) return mod.undefRef(scalar_ty);
2273422678
2273522679 var accum: Value = try operand_val.elemValue(mod, 0);
2273622680 var i: u32 = 1;
......@@ -22746,7 +22690,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
2274622690 .Mul => accum = try accum.numberMulWrap(elem_val, scalar_ty, sema.arena, mod),
2274722691 }
2274822692 }
22749 return sema.addConstant(accum);
22693 return Air.internedToRef(accum.toIntern());
2275022694 }
2275122695
2275222696 try sema.requireRuntimeBlock(block, inst_data.src(), operand_src);
......@@ -22825,7 +22769,7 @@ fn analyzeShuffle(
2282522769 }),
2282622770 };
2282722771 if (maybe_a_len == null and maybe_b_len == null) {
22828 return sema.addConstUndef(res_ty);
22772 return mod.undefRef(res_ty);
2282922773 }
2283022774 const a_len = @as(u32, @intCast(maybe_a_len orelse maybe_b_len.?));
2283122775 const b_len = @as(u32, @intCast(maybe_b_len orelse a_len));
......@@ -22839,8 +22783,8 @@ fn analyzeShuffle(
2283922783 .child = elem_ty.toIntern(),
2284022784 });
2284122785
22842 if (maybe_a_len == null) a = try sema.addConstUndef(a_ty) else a = try sema.coerce(block, a_ty, a, a_src);
22843 if (maybe_b_len == null) b = try sema.addConstUndef(b_ty) else b = try sema.coerce(block, b_ty, b, b_src);
22786 if (maybe_a_len == null) a = try mod.undefRef(a_ty) else a = try sema.coerce(block, a_ty, a, a_src);
22787 if (maybe_b_len == null) b = try mod.undefRef(b_ty) else b = try sema.coerce(block, b_ty, b, b_src);
2284422788
2284522789 const operand_info = [2]std.meta.Tuple(&.{ u64, LazySrcLoc, Type }){
2284622790 .{ a_len, a_src, a_ty },
......@@ -22893,10 +22837,10 @@ fn analyzeShuffle(
2289322837 const unsigned = if (int >= 0) @as(u32, @intCast(int)) else @as(u32, @intCast(~int));
2289422838 values[i] = try (try (if (int >= 0) a_val else b_val).elemValue(mod, unsigned)).intern(elem_ty, mod);
2289522839 }
22896 return sema.addConstant((try mod.intern(.{ .aggregate = .{
22840 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
2289722841 .ty = res_ty.toIntern(),
2289822842 .storage = .{ .elems = values },
22899 } })).toValue());
22843 } })));
2290022844 }
2290122845 }
2290222846
......@@ -22923,10 +22867,10 @@ fn analyzeShuffle(
2292322867 } });
2292422868
2292522869 if (a_len < b_len) {
22926 const undef = try sema.addConstUndef(a_ty);
22870 const undef = try mod.undefRef(a_ty);
2292722871 a = try sema.analyzeShuffle(block, src_node, elem_ty, a, undef, expand_mask.toValue(), @as(u32, @intCast(max_len)));
2292822872 } else {
22929 const undef = try sema.addConstUndef(b_ty);
22873 const undef = try mod.undefRef(b_ty);
2293022874 b = try sema.analyzeShuffle(block, src_node, elem_ty, b, undef, expand_mask.toValue(), @as(u32, @intCast(max_len)));
2293122875 }
2293222876 }
......@@ -22934,7 +22878,7 @@ fn analyzeShuffle(
2293422878 return block.addInst(.{
2293522879 .tag = .shuffle,
2293622880 .data = .{ .ty_pl = .{
22937 .ty = try sema.addType(res_ty),
22881 .ty = Air.internedToRef(res_ty.toIntern()),
2293822882 .payload = try block.sema.addExtra(Air.Shuffle{
2293922883 .a = a,
2294022884 .b = b,
......@@ -22984,13 +22928,13 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
2298422928 const maybe_b = try sema.resolveMaybeUndefVal(b);
2298522929
2298622930 const runtime_src = if (maybe_pred) |pred_val| rs: {
22987 if (pred_val.isUndef(mod)) return sema.addConstUndef(vec_ty);
22931 if (pred_val.isUndef(mod)) return mod.undefRef(vec_ty);
2298822932
2298922933 if (maybe_a) |a_val| {
22990 if (a_val.isUndef(mod)) return sema.addConstUndef(vec_ty);
22934 if (a_val.isUndef(mod)) return mod.undefRef(vec_ty);
2299122935
2299222936 if (maybe_b) |b_val| {
22993 if (b_val.isUndef(mod)) return sema.addConstUndef(vec_ty);
22937 if (b_val.isUndef(mod)) return mod.undefRef(vec_ty);
2299422938
2299522939 const elems = try sema.gpa.alloc(InternPool.Index, vec_len);
2299622940 for (elems, 0..) |*elem, i| {
......@@ -22999,25 +22943,25 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C
2299922943 elem.* = try (try (if (should_choose_a) a_val else b_val).elemValue(mod, i)).intern(elem_ty, mod);
2300022944 }
2300122945
23002 return sema.addConstant((try mod.intern(.{ .aggregate = .{
22946 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
2300322947 .ty = vec_ty.toIntern(),
2300422948 .storage = .{ .elems = elems },
23005 } })).toValue());
22949 } })));
2300622950 } else {
2300722951 break :rs b_src;
2300822952 }
2300922953 } else {
2301022954 if (maybe_b) |b_val| {
23011 if (b_val.isUndef(mod)) return sema.addConstUndef(vec_ty);
22955 if (b_val.isUndef(mod)) return mod.undefRef(vec_ty);
2301222956 }
2301322957 break :rs a_src;
2301422958 }
2301522959 } else rs: {
2301622960 if (maybe_a) |a_val| {
23017 if (a_val.isUndef(mod)) return sema.addConstUndef(vec_ty);
22961 if (a_val.isUndef(mod)) return mod.undefRef(vec_ty);
2301822962 }
2301922963 if (maybe_b) |b_val| {
23020 if (b_val.isUndef(mod)) return sema.addConstUndef(vec_ty);
22964 if (b_val.isUndef(mod)) return mod.undefRef(vec_ty);
2302122965 }
2302222966 break :rs pred_src;
2302322967 };
......@@ -23061,12 +23005,12 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!
2306123005 }
2306223006
2306323007 if (try sema.typeHasOnePossibleValue(elem_ty)) |val| {
23064 return sema.addConstant(val);
23008 return Air.internedToRef(val.toIntern());
2306523009 }
2306623010
2306723011 if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
2306823012 if (try sema.pointerDeref(block, ptr_src, ptr_val, sema.typeOf(ptr))) |elem_val| {
23069 return sema.addConstant(elem_val);
23013 return Air.internedToRef(elem_val.toIntern());
2307023014 }
2307123015 }
2307223016
......@@ -23119,7 +23063,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2311923063
2312023064 // special case zero bit types
2312123065 if (try sema.typeHasOnePossibleValue(elem_ty)) |val| {
23122 return sema.addConstant(val);
23066 return Air.internedToRef(val.toIntern());
2312323067 }
2312423068
2312523069 const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
......@@ -23145,7 +23089,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
2314523089 // zig fmt: on
2314623090 };
2314723091 try sema.storePtrVal(block, src, ptr_val, new_val, elem_ty);
23148 return sema.addConstant(stored_val);
23092 return Air.internedToRef(stored_val.toIntern());
2314923093 } else break :rs ptr_src;
2315023094 } else ptr_src;
2315123095
......@@ -23224,27 +23168,27 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
2322423168
2322523169 const runtime_src = if (maybe_mulend1) |mulend1_val| rs: {
2322623170 if (maybe_mulend2) |mulend2_val| {
23227 if (mulend2_val.isUndef(mod)) return sema.addConstUndef(ty);
23171 if (mulend2_val.isUndef(mod)) return mod.undefRef(ty);
2322823172
2322923173 if (maybe_addend) |addend_val| {
23230 if (addend_val.isUndef(mod)) return sema.addConstUndef(ty);
23174 if (addend_val.isUndef(mod)) return mod.undefRef(ty);
2323123175 const result_val = try Value.mulAdd(ty, mulend1_val, mulend2_val, addend_val, sema.arena, sema.mod);
23232 return sema.addConstant(result_val);
23176 return Air.internedToRef(result_val.toIntern());
2323323177 } else {
2323423178 break :rs addend_src;
2323523179 }
2323623180 } else {
2323723181 if (maybe_addend) |addend_val| {
23238 if (addend_val.isUndef(mod)) return sema.addConstUndef(ty);
23182 if (addend_val.isUndef(mod)) return mod.undefRef(ty);
2323923183 }
2324023184 break :rs mulend2_src;
2324123185 }
2324223186 } else rs: {
2324323187 if (maybe_mulend2) |mulend2_val| {
23244 if (mulend2_val.isUndef(mod)) return sema.addConstUndef(ty);
23188 if (mulend2_val.isUndef(mod)) return mod.undefRef(ty);
2324523189 }
2324623190 if (maybe_addend) |addend_val| {
23247 if (addend_val.isUndef(mod)) return sema.addConstUndef(ty);
23191 if (addend_val.isUndef(mod)) return mod.undefRef(ty);
2324823192 }
2324923193 break :rs mulend1_src;
2325023194 };
......@@ -23453,7 +23397,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
2345323397 };
2345423398 return sema.failWithOwnedErrorMsg(msg);
2345523399 }
23456 return sema.addConstant(field.base.toValue());
23400 return Air.internedToRef(field.base);
2345723401 }
2345823402
2345923403 try sema.requireRuntimeBlock(block, src, ptr_src);
......@@ -23461,7 +23405,7 @@ fn zirFieldParentPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr
2346123405 return block.addInst(.{
2346223406 .tag = .field_parent_ptr,
2346323407 .data = .{ .ty_pl = .{
23464 .ty = try sema.addType(result_ptr),
23408 .ty = Air.internedToRef(result_ptr.toIntern()),
2346523409 .payload = try block.sema.addExtra(Air.FieldParentPtr{
2346623410 .field_ptr = casted_field_ptr,
2346723411 .field_index = @as(u32, @intCast(field_index)),
......@@ -23611,7 +23555,7 @@ fn analyzeMinMax(
2361123555
2361223556 const vec_len = simd_op.len orelse {
2361323557 const result_val = opFunc(cur_val, operand_val, mod);
23614 cur_minmax = try sema.addConstant(result_val);
23558 cur_minmax = Air.internedToRef(result_val.toIntern());
2361523559 continue;
2361623560 };
2361723561 const elems = try sema.arena.alloc(InternPool.Index, vec_len);
......@@ -23621,10 +23565,10 @@ fn analyzeMinMax(
2362123565 const uncoerced_elem = opFunc(lhs_elem_val, rhs_elem_val, mod);
2362223566 elem.* = (try mod.getCoerced(uncoerced_elem, simd_op.scalar_ty)).toIntern();
2362323567 }
23624 cur_minmax = try sema.addConstant((try mod.intern(.{ .aggregate = .{
23568 cur_minmax = Air.internedToRef((try mod.intern(.{ .aggregate = .{
2362523569 .ty = simd_op.result_ty.toIntern(),
2362623570 .storage = .{ .elems = elems },
23627 } })).toValue());
23571 } })));
2362823572 }
2362923573
2363023574 const opt_runtime_idx = runtime_known.findFirstSet();
......@@ -23699,7 +23643,7 @@ fn analyzeMinMax(
2369923643 const rhs_src = operand_srcs[idx];
2370023644 const simd_op = try sema.checkSimdBinOp(block, src, lhs, rhs, lhs_src, rhs_src);
2370123645 if (known_undef) {
23702 cur_minmax = try sema.addConstUndef(simd_op.result_ty);
23646 cur_minmax = try mod.undefRef(simd_op.result_ty);
2370323647 } else {
2370423648 cur_minmax = try block.addBinOp(air_tag, simd_op.lhs, simd_op.rhs);
2370523649 }
......@@ -23855,7 +23799,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2385523799 const len_u64 = (try len_val.?.getUnsignedIntAdvanced(mod, sema)).?;
2385623800 const len = try sema.usizeCast(block, dest_src, len_u64);
2385723801 for (0..len) |i| {
23858 const elem_index = try sema.addIntUnsigned(Type.usize, i);
23802 const elem_index = try mod.intRef(Type.usize, i);
2385923803 const dest_elem_ptr = try sema.elemPtrOneLayerOnly(
2386023804 block,
2386123805 src,
......@@ -23942,7 +23886,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2394223886 // Aliasing safety check.
2394323887 if (block.wantSafety()) {
2394423888 const len = if (len_val) |v|
23945 try sema.addConstant(v)
23889 Air.internedToRef(v.toIntern())
2394623890 else if (dest_len != .none)
2394723891 dest_len
2394823892 else
......@@ -24025,7 +23969,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void
2402523969 if (!ptr_val.isComptimeMutablePtr(mod)) break :rs dest_src;
2402623970 if (try sema.resolveMaybeUndefVal(uncoerced_elem)) |_| {
2402723971 for (0..len) |i| {
24028 const elem_index = try sema.addIntUnsigned(Type.usize, i);
23972 const elem_index = try mod.intRef(Type.usize, i);
2402923973 const elem_ptr = try sema.elemPtrOneLayerOnly(
2403023974 block,
2403123975 src,
......@@ -24142,7 +24086,7 @@ fn zirVarExtended(
2414224086
2414324087 try sema.validateVarType(block, ty_src, var_ty, small.is_extern);
2414424088
24145 return sema.addConstant((try mod.intern(.{ .variable = .{
24089 return Air.internedToRef((try mod.intern(.{ .variable = .{
2414624090 .ty = var_ty.toIntern(),
2414724091 .init = init_val,
2414824092 .decl = sema.owner_decl_index,
......@@ -24152,7 +24096,7 @@ fn zirVarExtended(
2415224096 )).toOptional() else .none,
2415324097 .is_extern = small.is_extern,
2415424098 .is_threadlocal = small.is_threadlocal,
24155 } })).toValue());
24099 } })));
2415624100}
2415724101
2415824102fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
......@@ -24650,14 +24594,14 @@ fn zirBuiltinExtern(
2465024594 try mod.declareDeclDependency(sema.owner_decl_index, new_decl_index);
2465124595 try sema.ensureDeclAnalyzed(new_decl_index);
2465224596
24653 return sema.addConstant(try mod.getCoerced((try mod.intern(.{ .ptr = .{
24597 return Air.internedToRef((try mod.getCoerced((try mod.intern(.{ .ptr = .{
2465424598 .ty = switch (mod.intern_pool.indexToKey(ty.toIntern())) {
2465524599 .ptr_type => ty.toIntern(),
2465624600 .opt_type => |child_type| child_type,
2465724601 else => unreachable,
2465824602 },
2465924603 .addr = .{ .decl = new_decl_index },
24660 } })).toValue(), ty));
24604 } })).toValue(), ty)).toIntern());
2466124605}
2466224606
2466324607fn zirWorkItem(
......@@ -25259,13 +25203,13 @@ fn panicWithMsg(sema: *Sema, block: *Block, src: LazySrcLoc, msg_inst: Air.Inst.
2525925203
2526025204 const panic_func = mod.funcInfo(mod.panic_func_index);
2526125205 const panic_fn = try sema.analyzeDeclVal(block, .unneeded, panic_func.owner_decl);
25262 const null_stack_trace = try sema.addConstant(mod.null_stack_trace.toValue());
25206 const null_stack_trace = Air.internedToRef(mod.null_stack_trace);
2526325207
2526425208 const opt_usize_ty = try mod.optionalType(.usize_type);
25265 const null_ret_addr = try sema.addConstant((try mod.intern(.{ .opt = .{
25209 const null_ret_addr = Air.internedToRef((try mod.intern(.{ .opt = .{
2526625210 .ty = opt_usize_ty.toIntern(),
2526725211 .val = .none,
25268 } })).toValue());
25212 } })));
2526925213 try sema.callBuiltin(block, src, panic_fn, .auto, &.{ msg_inst, null_stack_trace, null_ret_addr }, operation);
2527025214}
2527125215
......@@ -25354,7 +25298,7 @@ fn panicSentinelMismatch(
2535425298 assert(!parent_block.is_comptime);
2535525299 const mod = sema.mod;
2535625300 const expected_sentinel_val = maybe_sentinel orelse return;
25357 const expected_sentinel = try sema.addConstant(expected_sentinel_val);
25301 const expected_sentinel = Air.internedToRef(expected_sentinel_val.toIntern());
2535825302
2535925303 const ptr_ty = sema.typeOf(ptr);
2536025304 const actual_sentinel = if (ptr_ty.isSlice(mod))
......@@ -25478,9 +25422,7 @@ fn fieldVal(
2547825422 switch (inner_ty.zigTypeTag(mod)) {
2547925423 .Array => {
2548025424 if (ip.stringEqlSlice(field_name, "len")) {
25481 return sema.addConstant(
25482 try mod.intValue(Type.usize, inner_ty.arrayLen(mod)),
25483 );
25425 return Air.internedToRef((try mod.intValue(Type.usize, inner_ty.arrayLen(mod))).toIntern());
2548425426 } else if (ip.stringEqlSlice(field_name, "ptr") and is_pointer_to) {
2548525427 const ptr_info = object_ty.ptrInfo(mod);
2548625428 const result_ty = try mod.ptrType(.{
......@@ -25570,10 +25512,10 @@ fn fieldVal(
2557025512 child_type
2557125513 else
2557225514 try mod.singleErrorSetType(field_name);
25573 return sema.addConstant((try mod.intern(.{ .err = .{
25515 return Air.internedToRef((try mod.intern(.{ .err = .{
2557425516 .ty = error_set_type.toIntern(),
2557525517 .name = field_name,
25576 } })).toValue());
25518 } })));
2557725519 },
2557825520 .Union => {
2557925521 if (child_type.getNamespaceIndex(mod).unwrap()) |namespace| {
......@@ -25585,9 +25527,7 @@ fn fieldVal(
2558525527 if (union_ty.unionTagType(mod)) |enum_ty| {
2558625528 if (enum_ty.enumFieldIndex(field_name, mod)) |field_index_usize| {
2558725529 const field_index = @as(u32, @intCast(field_index_usize));
25588 return sema.addConstant(
25589 try mod.enumValueFieldIndex(enum_ty, field_index),
25590 );
25530 return Air.internedToRef((try mod.enumValueFieldIndex(enum_ty, field_index)).toIntern());
2559125531 }
2559225532 }
2559325533 return sema.failWithBadMemberAccess(block, union_ty, field_name_src, field_name);
......@@ -25602,7 +25542,7 @@ fn fieldVal(
2560225542 return sema.failWithBadMemberAccess(block, child_type, field_name_src, field_name);
2560325543 const field_index = @as(u32, @intCast(field_index_usize));
2560425544 const enum_val = try mod.enumValueFieldIndex(child_type, field_index);
25605 return sema.addConstant(enum_val);
25545 return Air.internedToRef(enum_val.toIntern());
2560625546 },
2560725547 .Struct, .Opaque => {
2560825548 if (child_type.getNamespaceIndex(mod).unwrap()) |namespace| {
......@@ -25714,13 +25654,13 @@ fn fieldPtr(
2571425654 });
2571525655
2571625656 if (try sema.resolveDefinedValue(block, object_ptr_src, inner_ptr)) |val| {
25717 return sema.addConstant((try mod.intern(.{ .ptr = .{
25657 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2571825658 .ty = result_ty.toIntern(),
2571925659 .addr = .{ .field = .{
2572025660 .base = val.toIntern(),
2572125661 .index = Value.slice_ptr_index,
2572225662 } },
25723 } })).toValue());
25663 } })));
2572425664 }
2572525665 try sema.requireRuntimeBlock(block, src, null);
2572625666
......@@ -25736,13 +25676,13 @@ fn fieldPtr(
2573625676 });
2573725677
2573825678 if (try sema.resolveDefinedValue(block, object_ptr_src, inner_ptr)) |val| {
25739 return sema.addConstant((try mod.intern(.{ .ptr = .{
25679 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2574025680 .ty = result_ty.toIntern(),
2574125681 .addr = .{ .field = .{
2574225682 .base = val.toIntern(),
2574325683 .index = Value.slice_len_index,
2574425684 } },
25745 } })).toValue());
25685 } })));
2574625686 }
2574725687 try sema.requireRuntimeBlock(block, src, null);
2574825688
......@@ -25924,7 +25864,7 @@ fn fieldCallBind(
2592425864 return sema.finishFieldCallBind(block, src, ptr_ty, field.ty, field_index, object_ptr);
2592525865 } else if (struct_ty.isTuple(mod)) {
2592625866 if (ip.stringEqlSlice(field_name, "len")) {
25927 return .{ .direct = try sema.addIntUnsigned(Type.usize, struct_ty.structFieldCount(mod)) };
25867 return .{ .direct = try mod.intRef(Type.usize, struct_ty.structFieldCount(mod)) };
2592825868 }
2592925869 if (field_name.toUnsigned(ip)) |field_index| {
2593025870 if (field_index >= struct_ty.structFieldCount(mod)) break :find_field;
......@@ -26064,18 +26004,18 @@ fn finishFieldCallBind(
2606426004 const container_ty = ptr_ty.childType(mod);
2606526005 if (container_ty.zigTypeTag(mod) == .Struct) {
2606626006 if (try container_ty.structFieldValueComptime(mod, field_index)) |default_val| {
26067 return .{ .direct = try sema.addConstant(default_val) };
26007 return .{ .direct = Air.internedToRef(default_val.toIntern()) };
2606826008 }
2606926009 }
2607026010
2607126011 if (try sema.resolveDefinedValue(block, src, object_ptr)) |struct_ptr_val| {
26072 const pointer = try sema.addConstant((try mod.intern(.{ .ptr = .{
26012 const pointer = Air.internedToRef((try mod.intern(.{ .ptr = .{
2607326013 .ty = ptr_field_ty.toIntern(),
2607426014 .addr = .{ .field = .{
2607526015 .base = struct_ptr_val.toIntern(),
2607626016 .index = field_index,
2607726017 } },
26078 } })).toValue());
26018 } })));
2607926019 return .{ .direct = try sema.analyzeLoad(block, src, pointer, src) };
2608026020 }
2608126021
......@@ -26152,7 +26092,7 @@ fn structFieldPtr(
2615226092
2615326093 if (struct_ty.isTuple(mod)) {
2615426094 if (mod.intern_pool.stringEqlSlice(field_name, "len")) {
26155 const len_inst = try sema.addIntUnsigned(Type.usize, struct_ty.structFieldCount(mod));
26095 const len_inst = try mod.intRef(Type.usize, struct_ty.structFieldCount(mod));
2615626096 return sema.analyzeRef(block, src, len_inst);
2615726097 }
2615826098 const field_index = try sema.tupleFieldIndex(block, struct_ty, field_name, field_name_src);
......@@ -26269,7 +26209,7 @@ fn structFieldPtrByIndex(
2626926209 .ty = ptr_field_ty.toIntern(),
2627026210 .addr = .{ .comptime_field = field.default_val },
2627126211 } });
26272 return sema.addConstant(val.toValue());
26212 return Air.internedToRef(val);
2627326213 }
2627426214
2627526215 if (try sema.resolveDefinedValue(block, src, struct_ptr)) |struct_ptr_val| {
......@@ -26280,7 +26220,7 @@ fn structFieldPtrByIndex(
2628026220 .index = field_index,
2628126221 } },
2628226222 } });
26283 return sema.addConstant(val.toValue());
26223 return Air.internedToRef(val);
2628426224 }
2628526225
2628626226 try sema.requireRuntimeBlock(block, src, null);
......@@ -26311,15 +26251,15 @@ fn structFieldVal(
2631126251 const field = struct_obj.fields.values()[field_index];
2631226252
2631326253 if (field.is_comptime) {
26314 return sema.addConstant(field.default_val.toValue());
26254 return Air.internedToRef(field.default_val);
2631526255 }
2631626256
2631726257 if (try sema.resolveMaybeUndefVal(struct_byval)) |struct_val| {
26318 if (struct_val.isUndef(mod)) return sema.addConstUndef(field.ty);
26258 if (struct_val.isUndef(mod)) return mod.undefRef(field.ty);
2631926259 if ((try sema.typeHasOnePossibleValue(field.ty))) |opv| {
26320 return sema.addConstant(opv);
26260 return Air.internedToRef(opv.toIntern());
2632126261 }
26322 return sema.addConstant(try struct_val.fieldValue(mod, field_index));
26262 return Air.internedToRef((try struct_val.fieldValue(mod, field_index)).toIntern());
2632326263 }
2632426264
2632526265 try sema.requireRuntimeBlock(block, src, null);
......@@ -26348,7 +26288,7 @@ fn tupleFieldVal(
2634826288) CompileError!Air.Inst.Ref {
2634926289 const mod = sema.mod;
2635026290 if (mod.intern_pool.stringEqlSlice(field_name, "len")) {
26351 return sema.addIntUnsigned(Type.usize, tuple_ty.structFieldCount(mod));
26291 return mod.intRef(Type.usize, tuple_ty.structFieldCount(mod));
2635226292 }
2635326293 const field_index = try sema.tupleFieldIndex(block, tuple_ty, field_name, field_name_src);
2635426294 return sema.tupleFieldValByIndex(block, src, tuple_byval, field_index, tuple_ty);
......@@ -26388,26 +26328,26 @@ fn tupleFieldValByIndex(
2638826328 const field_ty = tuple_ty.structFieldType(field_index, mod);
2638926329
2639026330 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_value| {
26391 return sema.addConstant(default_value);
26331 return Air.internedToRef(default_value.toIntern());
2639226332 }
2639326333
2639426334 if (try sema.resolveMaybeUndefVal(tuple_byval)) |tuple_val| {
2639526335 if ((try sema.typeHasOnePossibleValue(field_ty))) |opv| {
26396 return sema.addConstant(opv);
26336 return Air.internedToRef(opv.toIntern());
2639726337 }
2639826338 return switch (mod.intern_pool.indexToKey(tuple_val.toIntern())) {
26399 .undef => sema.addConstUndef(field_ty),
26400 .aggregate => |aggregate| sema.addConstant(switch (aggregate.storage) {
26339 .undef => mod.undefRef(field_ty),
26340 .aggregate => |aggregate| Air.internedToRef(switch (aggregate.storage) {
2640126341 .bytes => |bytes| try mod.intValue(Type.u8, bytes[0]),
2640226342 .elems => |elems| elems[field_index].toValue(),
2640326343 .repeated_elem => |elem| elem.toValue(),
26404 }),
26344 }.toIntern()),
2640526345 else => unreachable,
2640626346 };
2640726347 }
2640826348
2640926349 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_val| {
26410 return sema.addConstant(default_val);
26350 return Air.internedToRef(default_val.toIntern());
2641126351 }
2641226352
2641326353 try sema.requireRuntimeBlock(block, src, null);
......@@ -26493,13 +26433,13 @@ fn unionFieldPtr(
2649326433 },
2649426434 .Packed, .Extern => {},
2649526435 }
26496 return sema.addConstant((try mod.intern(.{ .ptr = .{
26436 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2649726437 .ty = ptr_field_ty.toIntern(),
2649826438 .addr = .{ .field = .{
2649926439 .base = union_ptr_val.toIntern(),
2650026440 .index = field_index,
2650126441 } },
26502 } })).toValue());
26442 } })));
2650326443 }
2650426444
2650526445 try sema.requireRuntimeBlock(block, src, null);
......@@ -26507,7 +26447,7 @@ fn unionFieldPtr(
2650726447 union_ty.unionTagTypeSafety(mod) != null and union_obj.fields.count() > 1)
2650826448 {
2650926449 const wanted_tag_val = try mod.enumValueFieldIndex(union_obj.tag_ty, enum_field_index);
26510 const wanted_tag = try sema.addConstant(wanted_tag_val);
26450 const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern());
2651126451 // TODO would it be better if get_union_tag supported pointers to unions?
2651226452 const union_val = try block.addTyOp(.load, union_ty, union_ptr);
2651326453 const active_tag = try block.addTyOp(.get_union_tag, union_obj.tag_ty, union_val);
......@@ -26540,7 +26480,7 @@ fn unionFieldVal(
2654026480 const enum_field_index = @as(u32, @intCast(union_obj.tag_ty.enumFieldIndex(field_name, mod).?));
2654126481
2654226482 if (try sema.resolveMaybeUndefVal(union_byval)) |union_val| {
26543 if (union_val.isUndef(mod)) return sema.addConstUndef(field.ty);
26483 if (union_val.isUndef(mod)) return mod.undefRef(field.ty);
2654426484
2654526485 const un = ip.indexToKey(union_val.toIntern()).un;
2654626486 const field_tag = try mod.enumValueFieldIndex(union_obj.tag_ty, enum_field_index);
......@@ -26548,7 +26488,7 @@ fn unionFieldVal(
2654826488 switch (union_obj.layout) {
2654926489 .Auto => {
2655026490 if (tag_matches) {
26551 return sema.addConstant(un.val.toValue());
26491 return Air.internedToRef(un.val);
2655226492 } else {
2655326493 const msg = msg: {
2655426494 const active_index = union_obj.tag_ty.enumTagFieldIndex(un.tag.toValue(), mod).?;
......@@ -26565,11 +26505,11 @@ fn unionFieldVal(
2656526505 },
2656626506 .Packed, .Extern => {
2656726507 if (tag_matches) {
26568 return sema.addConstant(un.val.toValue());
26508 return Air.internedToRef(un.val);
2656926509 } else {
2657026510 const old_ty = union_ty.unionFieldType(un.tag.toValue(), mod);
2657126511 if (try sema.bitCastVal(block, src, un.val.toValue(), old_ty, field.ty, 0)) |new_val| {
26572 return sema.addConstant(new_val);
26512 return Air.internedToRef(new_val.toIntern());
2657326513 }
2657426514 }
2657526515 },
......@@ -26581,7 +26521,7 @@ fn unionFieldVal(
2658126521 union_ty.unionTagTypeSafety(mod) != null and union_obj.fields.count() > 1)
2658226522 {
2658326523 const wanted_tag_val = try mod.enumValueFieldIndex(union_obj.tag_ty, enum_field_index);
26584 const wanted_tag = try sema.addConstant(wanted_tag_val);
26524 const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern());
2658526525 const active_tag = try block.addTyOp(.get_union_tag, union_obj.tag_ty, union_byval);
2658626526 try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag);
2658726527 }
......@@ -26655,7 +26595,7 @@ fn elemPtrOneLayerOnly(
2665526595 const index = @as(usize, @intCast(index_val.toUnsignedInt(mod)));
2665626596 const result_ty = try sema.elemPtrType(indexable_ty, index);
2665726597 const elem_ptr = try ptr_val.elemPtr(result_ty, index, mod);
26658 return sema.addConstant(elem_ptr);
26598 return Air.internedToRef(elem_ptr.toIntern());
2665926599 };
2666026600 const result_ty = try sema.elemPtrType(indexable_ty, null);
2666126601
......@@ -26716,7 +26656,7 @@ fn elemVal(
2671626656 const elem_ptr_ty = try mod.singleConstPtrType(elem_ty);
2671726657 const elem_ptr_val = try many_ptr_val.elemPtr(elem_ptr_ty, index, mod);
2671826658 if (try sema.pointerDeref(block, indexable_src, elem_ptr_val, elem_ptr_ty)) |elem_val| {
26719 return sema.addConstant(try mod.getCoerced(elem_val, elem_ty));
26659 return Air.internedToRef((try mod.getCoerced(elem_val, elem_ty)).toIntern());
2672026660 }
2672126661 break :rs indexable_src;
2672226662 };
......@@ -26732,7 +26672,7 @@ fn elemVal(
2673226672 const index_val = try sema.resolveDefinedValue(block, elem_index_src, elem_index) orelse break :arr_sent;
2673326673 const index = try sema.usizeCast(block, src, index_val.toUnsignedInt(mod));
2673426674 if (index != inner_ty.arrayLen(mod)) break :arr_sent;
26735 return sema.addConstant(sentinel);
26675 return Air.internedToRef(sentinel.toIntern());
2673626676 }
2673726677 const elem_ptr = try sema.elemPtr(block, indexable_src, indexable, elem_index, elem_index_src, false, oob_safety);
2673826678 return sema.analyzeLoad(block, indexable_src, elem_ptr, elem_index_src);
......@@ -26817,20 +26757,20 @@ fn tupleFieldPtr(
2681726757 });
2681826758
2681926759 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_val| {
26820 return sema.addConstant((try mod.intern(.{ .ptr = .{
26760 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2682126761 .ty = ptr_field_ty.toIntern(),
2682226762 .addr = .{ .comptime_field = default_val.toIntern() },
26823 } })).toValue());
26763 } })));
2682426764 }
2682526765
2682626766 if (try sema.resolveMaybeUndefVal(tuple_ptr)) |tuple_ptr_val| {
26827 return sema.addConstant((try mod.intern(.{ .ptr = .{
26767 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2682826768 .ty = ptr_field_ty.toIntern(),
2682926769 .addr = .{ .field = .{
2683026770 .base = tuple_ptr_val.toIntern(),
2683126771 .index = field_index,
2683226772 } },
26833 } })).toValue());
26773 } })));
2683426774 }
2683526775
2683626776 if (!init) {
......@@ -26866,12 +26806,12 @@ fn tupleField(
2686626806 const field_ty = tuple_ty.structFieldType(field_index, mod);
2686726807
2686826808 if (try tuple_ty.structFieldValueComptime(mod, field_index)) |default_value| {
26869 return sema.addConstant(default_value); // comptime field
26809 return Air.internedToRef(default_value.toIntern()); // comptime field
2687026810 }
2687126811
2687226812 if (try sema.resolveMaybeUndefVal(tuple)) |tuple_val| {
26873 if (tuple_val.isUndef(mod)) return sema.addConstUndef(field_ty);
26874 return sema.addConstant(try tuple_val.fieldValue(mod, field_index));
26813 if (tuple_val.isUndef(mod)) return mod.undefRef(field_ty);
26814 return Air.internedToRef((try tuple_val.fieldValue(mod, field_index)).toIntern());
2687526815 }
2687626816
2687726817 try sema.validateRuntimeElemAccess(block, field_index_src, field_ty, tuple_ty, tuple_src);
......@@ -26909,7 +26849,7 @@ fn elemValArray(
2690926849 const index = @as(usize, @intCast(index_val.toUnsignedInt(mod)));
2691026850 if (array_sent) |s| {
2691126851 if (index == array_len) {
26912 return sema.addConstant(s);
26852 return Air.internedToRef(s.toIntern());
2691326853 }
2691426854 }
2691526855 if (index >= array_len_s) {
......@@ -26919,12 +26859,12 @@ fn elemValArray(
2691926859 }
2692026860 if (maybe_undef_array_val) |array_val| {
2692126861 if (array_val.isUndef(mod)) {
26922 return sema.addConstUndef(elem_ty);
26862 return mod.undefRef(elem_ty);
2692326863 }
2692426864 if (maybe_index_val) |index_val| {
2692526865 const index = @as(usize, @intCast(index_val.toUnsignedInt(mod)));
2692626866 const elem_val = try array_val.elemValue(mod, index);
26927 return sema.addConstant(elem_val);
26867 return Air.internedToRef(elem_val.toIntern());
2692826868 }
2692926869 }
2693026870
......@@ -26935,7 +26875,7 @@ fn elemValArray(
2693526875 if (oob_safety and block.wantSafety()) {
2693626876 // Runtime check is only needed if unable to comptime check
2693726877 if (maybe_index_val == null) {
26938 const len_inst = try sema.addIntUnsigned(Type.usize, array_len);
26878 const len_inst = try mod.intRef(Type.usize, array_len);
2693926879 const cmp_op: Air.Inst.Tag = if (array_sent != null) .cmp_lte else .cmp_lt;
2694026880 try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op);
2694126881 }
......@@ -26980,11 +26920,11 @@ fn elemPtrArray(
2698026920
2698126921 if (maybe_undef_array_ptr_val) |array_ptr_val| {
2698226922 if (array_ptr_val.isUndef(mod)) {
26983 return sema.addConstUndef(elem_ptr_ty);
26923 return mod.undefRef(elem_ptr_ty);
2698426924 }
2698526925 if (offset) |index| {
2698626926 const elem_ptr = try array_ptr_val.elemPtr(elem_ptr_ty, index, mod);
26987 return sema.addConstant(elem_ptr);
26927 return Air.internedToRef(elem_ptr.toIntern());
2698826928 }
2698926929 }
2699026930
......@@ -26997,7 +26937,7 @@ fn elemPtrArray(
2699726937
2699826938 // Runtime check is only needed if unable to comptime check.
2699926939 if (oob_safety and block.wantSafety() and offset == null) {
27000 const len_inst = try sema.addIntUnsigned(Type.usize, array_len);
26940 const len_inst = try mod.intRef(Type.usize, array_len);
2700126941 const cmp_op: Air.Inst.Tag = if (array_sent) .cmp_lte else .cmp_lt;
2700226942 try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op);
2700326943 }
......@@ -27042,7 +26982,7 @@ fn elemValSlice(
2704226982 const elem_ptr_ty = try sema.elemPtrType(slice_ty, index);
2704326983 const elem_ptr_val = try slice_val.elemPtr(elem_ptr_ty, index, mod);
2704426984 if (try sema.pointerDeref(block, slice_src, elem_ptr_val, elem_ptr_ty)) |elem_val| {
27045 return sema.addConstant(elem_val);
26985 return Air.internedToRef(elem_val.toIntern());
2704626986 }
2704726987 runtime_src = slice_src;
2704826988 }
......@@ -27053,7 +26993,7 @@ fn elemValSlice(
2705326993 try sema.requireRuntimeBlock(block, src, runtime_src);
2705426994 if (oob_safety and block.wantSafety()) {
2705526995 const len_inst = if (maybe_slice_val) |slice_val|
27056 try sema.addIntUnsigned(Type.usize, slice_val.sliceLen(mod))
26996 try mod.intRef(Type.usize, slice_val.sliceLen(mod))
2705726997 else
2705826998 try block.addTyOp(.slice_len, Type.usize, slice);
2705926999 const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
......@@ -27088,7 +27028,7 @@ fn elemPtrSlice(
2708827028
2708927029 if (maybe_undef_slice_val) |slice_val| {
2709027030 if (slice_val.isUndef(mod)) {
27091 return sema.addConstUndef(elem_ptr_ty);
27031 return mod.undefRef(elem_ptr_ty);
2709227032 }
2709327033 const slice_len = slice_val.sliceLen(mod);
2709427034 const slice_len_s = slice_len + @intFromBool(slice_sent);
......@@ -27101,7 +27041,7 @@ fn elemPtrSlice(
2710127041 return sema.fail(block, elem_index_src, "index {d} outside slice of length {d}{s}", .{ index, slice_len, sentinel_label });
2710227042 }
2710327043 const elem_ptr_val = try slice_val.elemPtr(elem_ptr_ty, index, mod);
27104 return sema.addConstant(elem_ptr_val);
27044 return Air.internedToRef(elem_ptr_val.toIntern());
2710527045 }
2710627046 }
2710727047
......@@ -27113,7 +27053,7 @@ fn elemPtrSlice(
2711327053 const len_inst = len: {
2711427054 if (maybe_undef_slice_val) |slice_val|
2711527055 if (!slice_val.isUndef(mod))
27116 break :len try sema.addIntUnsigned(Type.usize, slice_val.sliceLen(mod));
27056 break :len try mod.intRef(Type.usize, slice_val.sliceLen(mod));
2711727057 break :len try block.addTyOp(.slice_len, Type.usize, slice);
2711827058 };
2711927059 const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt;
......@@ -27205,15 +27145,15 @@ fn coerceExtra(
2720527145 .Optional => optional: {
2720627146 // undefined sets the optional bit also to undefined.
2720727147 if (is_undef) {
27208 return sema.addConstUndef(dest_ty);
27148 return mod.undefRef(dest_ty);
2720927149 }
2721027150
2721127151 // null to ?T
2721227152 if (inst_ty.zigTypeTag(mod) == .Null) {
27213 return sema.addConstant((try mod.intern(.{ .opt = .{
27153 return Air.internedToRef((try mod.intern(.{ .opt = .{
2721427154 .ty = dest_ty.toIntern(),
2721527155 .val = .none,
27216 } })).toValue());
27156 } })));
2721727157 }
2721827158
2721927159 // cast from ?*T and ?[*]T to ?*anyopaque
......@@ -27382,7 +27322,7 @@ fn coerceExtra(
2738227322 // coercion to C pointer
2738327323 .C => switch (inst_ty.zigTypeTag(mod)) {
2738427324 .Null => {
27385 return sema.addConstant(try mod.getCoerced(Value.null, dest_ty));
27325 return Air.internedToRef((try mod.getCoerced(Value.null, dest_ty)).toIntern());
2738627326 },
2738727327 .ComptimeInt => {
2738827328 const addr = sema.coerceExtra(block, Type.usize, inst, inst_src, .{ .report_err = false }) catch |err| switch (err) {
......@@ -27486,14 +27426,14 @@ fn coerceExtra(
2748627426 if (inst_child_ty.structFieldCount(mod) == 0) {
2748727427 // Optional slice is represented with a null pointer so
2748827428 // we use a dummy pointer value with the required alignment.
27489 return sema.addConstant((try mod.intern(.{ .ptr = .{
27429 return Air.internedToRef((try mod.intern(.{ .ptr = .{
2749027430 .ty = dest_ty.toIntern(),
2749127431 .addr = .{ .int = (if (dest_info.flags.alignment != .none)
2749227432 try mod.intValue(Type.usize, dest_info.flags.alignment.toByteUnitsOptional().?)
2749327433 else
2749427434 try mod.getCoerced(try dest_info.child.toType().lazyAbiAlignment(mod), Type.usize)).toIntern() },
2749527435 .len = (try mod.intValue(Type.usize, 0)).toIntern(),
27496 } })).toValue());
27436 } })));
2749727437 }
2749827438
2749927439 // pointer to tuple to slice
......@@ -27539,7 +27479,7 @@ fn coerceExtra(
2753927479 .Int, .ComptimeInt => switch (inst_ty.zigTypeTag(mod)) {
2754027480 .Float, .ComptimeFloat => float: {
2754127481 if (is_undef) {
27542 return sema.addConstUndef(dest_ty);
27482 return mod.undefRef(dest_ty);
2754327483 }
2754427484 const val = (try sema.resolveMaybeUndefVal(inst)) orelse {
2754527485 if (dest_ty.zigTypeTag(mod) == .ComptimeInt) {
......@@ -27558,11 +27498,11 @@ fn coerceExtra(
2755827498 );
2755927499 }
2756027500 const result_val = try sema.intFromFloat(block, inst_src, val, inst_ty, dest_ty);
27561 return try sema.addConstant(result_val);
27501 return Air.internedToRef(result_val.toIntern());
2756227502 },
2756327503 .Int, .ComptimeInt => {
2756427504 if (is_undef) {
27565 return sema.addConstUndef(dest_ty);
27505 return mod.undefRef(dest_ty);
2756627506 }
2756727507 if (try sema.resolveMaybeUndefVal(inst)) |val| {
2756827508 // comptime-known integer to other number
......@@ -27570,7 +27510,7 @@ fn coerceExtra(
2757027510 if (!opts.report_err) return error.NotCoercible;
2757127511 return sema.fail(block, inst_src, "type '{}' cannot represent integer value '{}'", .{ dest_ty.fmt(mod), val.fmtValue(inst_ty, mod) });
2757227512 }
27573 return try sema.addConstant(try mod.getCoerced(val, dest_ty));
27513 return Air.internedToRef((try mod.getCoerced(val, dest_ty)).toIntern());
2757427514 }
2757527515 if (dest_ty.zigTypeTag(mod) == .ComptimeInt) {
2757627516 if (!opts.report_err) return error.NotCoercible;
......@@ -27590,7 +27530,7 @@ fn coerceExtra(
2759027530 }
2759127531 },
2759227532 .Undefined => {
27593 return sema.addConstUndef(dest_ty);
27533 return mod.undefRef(dest_ty);
2759427534 },
2759527535 else => {},
2759627536 },
......@@ -27598,11 +27538,11 @@ fn coerceExtra(
2759827538 .ComptimeFloat => {
2759927539 const val = try sema.resolveConstValue(block, .unneeded, inst, "");
2760027540 const result_val = try val.floatCast(dest_ty, mod);
27601 return try sema.addConstant(result_val);
27541 return Air.internedToRef(result_val.toIntern());
2760227542 },
2760327543 .Float => {
2760427544 if (is_undef) {
27605 return sema.addConstUndef(dest_ty);
27545 return mod.undefRef(dest_ty);
2760627546 }
2760727547 if (try sema.resolveMaybeUndefVal(inst)) |val| {
2760827548 const result_val = try val.floatCast(dest_ty, mod);
......@@ -27614,7 +27554,7 @@ fn coerceExtra(
2761427554 .{ dest_ty.fmt(mod), val.fmtValue(inst_ty, mod) },
2761527555 );
2761627556 }
27617 return try sema.addConstant(result_val);
27557 return Air.internedToRef(result_val.toIntern());
2761827558 } else if (dest_ty.zigTypeTag(mod) == .ComptimeFloat) {
2761927559 if (!opts.report_err) return error.NotCoercible;
2762027560 return sema.failWithNeededComptime(block, inst_src, "value being casted to 'comptime_float' must be comptime-known");
......@@ -27630,7 +27570,7 @@ fn coerceExtra(
2763027570 },
2763127571 .Int, .ComptimeInt => int: {
2763227572 if (is_undef) {
27633 return sema.addConstUndef(dest_ty);
27573 return mod.undefRef(dest_ty);
2763427574 }
2763527575 const val = (try sema.resolveMaybeUndefVal(inst)) orelse {
2763627576 if (dest_ty.zigTypeTag(mod) == .ComptimeFloat) {
......@@ -27650,10 +27590,10 @@ fn coerceExtra(
2765027590 // .{ dest_ty.fmt(mod), val },
2765127591 // );
2765227592 //}
27653 return try sema.addConstant(result_val);
27593 return Air.internedToRef(result_val.toIntern());
2765427594 },
2765527595 .Undefined => {
27656 return sema.addConstUndef(dest_ty);
27596 return mod.undefRef(dest_ty);
2765727597 },
2765827598 else => {},
2765927599 },
......@@ -27676,9 +27616,7 @@ fn coerceExtra(
2767627616 };
2767727617 return sema.failWithOwnedErrorMsg(msg);
2767827618 };
27679 return sema.addConstant(
27680 try mod.enumValueFieldIndex(dest_ty, @as(u32, @intCast(field_index))),
27681 );
27619 return Air.internedToRef((try mod.enumValueFieldIndex(dest_ty, @as(u32, @intCast(field_index)))).toIntern());
2768227620 },
2768327621 .Union => blk: {
2768427622 // union to its own tag type
......@@ -27688,7 +27626,7 @@ fn coerceExtra(
2768827626 }
2768927627 },
2769027628 .Undefined => {
27691 return sema.addConstUndef(dest_ty);
27629 return mod.undefRef(dest_ty);
2769227630 },
2769327631 else => {},
2769427632 },
......@@ -27696,21 +27634,19 @@ fn coerceExtra(
2769627634 .ErrorUnion => eu: {
2769727635 if (maybe_inst_val) |inst_val| {
2769827636 switch (inst_val.toIntern()) {
27699 .undef => return sema.addConstUndef(dest_ty),
27637 .undef => return mod.undefRef(dest_ty),
2770027638 else => switch (mod.intern_pool.indexToKey(inst_val.toIntern())) {
2770127639 .error_union => |error_union| switch (error_union.val) {
2770227640 .err_name => |err_name| {
2770327641 const error_set_ty = inst_ty.errorUnionSet(mod);
27704 const error_set_val = try sema.addConstant((try mod.intern(.{ .err = .{
27642 const error_set_val = Air.internedToRef((try mod.intern(.{ .err = .{
2770527643 .ty = error_set_ty.toIntern(),
2770627644 .name = err_name,
27707 } })).toValue());
27645 } })));
2770827646 return sema.wrapErrorUnionSet(block, dest_ty, error_set_val, inst_src);
2770927647 },
2771027648 .payload => |payload| {
27711 const payload_val = try sema.addConstant(
27712 payload.toValue(),
27713 );
27649 const payload_val = Air.internedToRef(payload);
2771427650 return sema.wrapErrorUnionPayload(block, dest_ty, payload_val, inst_src) catch |err| switch (err) {
2771527651 error.NotCoercible => break :eu,
2771627652 else => |e| return e,
......@@ -27727,7 +27663,7 @@ fn coerceExtra(
2772727663 return sema.wrapErrorUnionSet(block, dest_ty, inst, inst_src);
2772827664 },
2772927665 .Undefined => {
27730 return sema.addConstUndef(dest_ty);
27666 return mod.undefRef(dest_ty);
2773127667 },
2773227668 else => eu: {
2773327669 // T to E!T
......@@ -27745,7 +27681,7 @@ fn coerceExtra(
2774527681 }
2774627682 },
2774727683 .Undefined => {
27748 return sema.addConstUndef(dest_ty);
27684 return mod.undefRef(dest_ty);
2774927685 },
2775027686 else => {},
2775127687 },
......@@ -27760,7 +27696,7 @@ fn coerceExtra(
2776027696 }
2776127697 },
2776227698 .Undefined => {
27763 return sema.addConstUndef(dest_ty);
27699 return mod.undefRef(dest_ty);
2776427700 },
2776527701 else => {},
2776627702 },
......@@ -27772,7 +27708,7 @@ fn coerceExtra(
2777227708 }
2777327709 },
2777427710 .Undefined => {
27775 return sema.addConstUndef(dest_ty);
27711 return mod.undefRef(dest_ty);
2777627712 },
2777727713 else => {},
2777827714 },
......@@ -27794,7 +27730,7 @@ fn coerceExtra(
2779427730 // special logic has a chance to run first, such as `*[N]T` to `[]T` which
2779527731 // should initialize the length field of the slice.
2779627732 if (is_undef) {
27797 return sema.addConstUndef(dest_ty);
27733 return mod.undefRef(dest_ty);
2779827734 }
2779927735
2780027736 if (!opts.report_err) return error.NotCoercible;
......@@ -27863,7 +27799,7 @@ fn coerceInMemory(
2786327799 val: Value,
2786427800 dst_ty: Type,
2786527801) CompileError!Air.Inst.Ref {
27866 return sema.addConstant(try sema.mod.getCoerced(val, dst_ty));
27802 return Air.internedToRef((try sema.mod.getCoerced(val, dst_ty)).toIntern());
2786727803}
2786827804
2786927805const InMemoryCoercionResult = union(enum) {
......@@ -28880,7 +28816,7 @@ fn storePtr2(
2888028816 while (i < field_count) : (i += 1) {
2888128817 const elem_src = operand_src; // TODO better source location
2888228818 const elem = try sema.tupleField(block, operand_src, uncasted_operand, elem_src, i);
28883 const elem_index = try sema.addIntUnsigned(Type.usize, i);
28819 const elem_index = try mod.intRef(Type.usize, i);
2888428820 const elem_ptr = try sema.elemPtr(block, ptr_src, ptr, elem_index, elem_src, false, true);
2888528821 try sema.storePtr2(block, src, elem_ptr, elem_src, elem, elem_src, .store);
2888628822 }
......@@ -29920,7 +29856,7 @@ fn bitCast(
2992029856
2992129857 if (try sema.resolveMaybeUndefVal(inst)) |val| {
2992229858 if (try sema.bitCastVal(block, inst_src, val, old_ty, dest_ty, 0)) |result_val| {
29923 return sema.addConstant(result_val);
29859 return Air.internedToRef(result_val.toIntern());
2992429860 }
2992529861 }
2992629862 try sema.requireRuntimeBlock(block, inst_src, operand_src);
......@@ -29973,7 +29909,7 @@ fn coerceArrayPtrToSlice(
2997329909 },
2997429910 .len = (try mod.intValue(Type.usize, array_ty.arrayLen(mod))).toIntern(),
2997529911 } });
29976 return sema.addConstant(slice_val.toValue());
29912 return Air.internedToRef(slice_val);
2997729913 }
2997829914 try sema.requireRuntimeBlock(block, inst_src, null);
2997929915 return block.addTyOp(.array_to_slice, dest_ty, inst);
......@@ -30040,8 +29976,8 @@ fn coerceCompatiblePtrs(
3004029976 return sema.fail(block, inst_src, "null pointer casted to type '{}'", .{dest_ty.fmt(sema.mod)});
3004129977 }
3004229978 // The comptime Value representation is compatible with both types.
30043 return sema.addConstant(
30044 try mod.getCoerced((try val.intern(inst_ty, mod)).toValue(), dest_ty),
29979 return Air.internedToRef(
29980 (try mod.getCoerced((try val.intern(inst_ty, mod)).toValue(), dest_ty)).toIntern(),
3004529981 );
3004629982 }
3004729983 try sema.requireRuntimeBlock(block, inst_src, null);
......@@ -30139,7 +30075,7 @@ fn coerceEnumToUnion(
3013930075 return sema.failWithOwnedErrorMsg(msg);
3014030076 };
3014130077
30142 return sema.addConstant(try mod.unionValue(union_ty, val, opv));
30078 return Air.internedToRef((try mod.unionValue(union_ty, val, opv)).toIntern());
3014330079 }
3014430080
3014530081 try sema.requireRuntimeBlock(block, inst_src, null);
......@@ -30347,7 +30283,7 @@ fn coerceArrayLike(
3034730283 var runtime_src: ?LazySrcLoc = null;
3034830284
3034930285 for (element_vals, element_refs, 0..) |*val, *ref, i| {
30350 const index_ref = try sema.addConstant(try mod.intValue(Type.usize, i));
30286 const index_ref = Air.internedToRef((try mod.intValue(Type.usize, i)).toIntern());
3035130287 const src = inst_src; // TODO better source location
3035230288 const elem_src = inst_src; // TODO better source location
3035330289 const elem_ref = try sema.elemValArray(block, src, inst_src, inst, elem_src, index_ref, true);
......@@ -30367,10 +30303,10 @@ fn coerceArrayLike(
3036730303 return block.addAggregateInit(dest_ty, element_refs);
3036830304 }
3036930305
30370 return sema.addConstant((try mod.intern(.{ .aggregate = .{
30306 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
3037130307 .ty = dest_ty.toIntern(),
3037230308 .storage = .{ .elems = element_vals },
30373 } })).toValue());
30309 } })));
3037430310}
3037530311
3037630312/// If the lengths match, coerces element-wise.
......@@ -30411,7 +30347,7 @@ fn coerceTupleToArray(
3041130347 if (i_usize == inst_len) {
3041230348 const sentinel_val = dest_ty.sentinel(mod).?;
3041330349 val.* = sentinel_val.toIntern();
30414 ref.* = try sema.addConstant(sentinel_val);
30350 ref.* = Air.internedToRef(sentinel_val.toIntern());
3041530351 break;
3041630352 }
3041730353 const elem_src = inst_src; // TODO better source location
......@@ -30432,10 +30368,10 @@ fn coerceTupleToArray(
3043230368 return block.addAggregateInit(dest_ty, element_refs);
3043330369 }
3043430370
30435 return sema.addConstant((try mod.intern(.{ .aggregate = .{
30371 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
3043630372 .ty = dest_ty.toIntern(),
3043730373 .storage = .{ .elems = element_vals },
30438 } })).toValue());
30374 } })));
3043930375}
3044030376
3044130377/// If the lengths match, coerces element-wise.
......@@ -30575,7 +30511,7 @@ fn coerceTupleToStruct(
3057530511 if (runtime_src == null) {
3057630512 field_vals[i] = field.default_val;
3057730513 } else {
30578 field_ref.* = try sema.addConstant(field.default_val.toValue());
30514 field_ref.* = Air.internedToRef(field.default_val);
3057930515 }
3058030516 }
3058130517
......@@ -30597,7 +30533,7 @@ fn coerceTupleToStruct(
3059730533 // TODO: figure out InternPool removals for incremental compilation
3059830534 //errdefer ip.remove(struct_val);
3059930535
30600 return sema.addConstant(struct_val.toValue());
30536 return Air.internedToRef(struct_val);
3060130537}
3060230538
3060330539fn coerceTupleToTuple(
......@@ -30719,7 +30655,7 @@ fn coerceTupleToTuple(
3071930655 if (runtime_src == null) {
3072030656 field_vals[i] = default_val;
3072130657 } else {
30722 field_ref.* = try sema.addConstant(default_val.toValue());
30658 field_ref.* = Air.internedToRef(default_val);
3072330659 }
3072430660 }
3072530661
......@@ -30734,12 +30670,10 @@ fn coerceTupleToTuple(
3073430670 return block.addAggregateInit(tuple_ty, field_refs);
3073530671 }
3073630672
30737 return sema.addConstant(
30738 (try mod.intern(.{ .aggregate = .{
30739 .ty = tuple_ty.toIntern(),
30740 .storage = .{ .elems = field_vals },
30741 } })).toValue(),
30742 );
30673 return Air.internedToRef((try mod.intern(.{ .aggregate = .{
30674 .ty = tuple_ty.toIntern(),
30675 .storage = .{ .elems = field_vals },
30676 } })));
3074330677}
3074430678
3074530679fn analyzeDeclVal(
......@@ -30863,10 +30797,10 @@ fn analyzeDeclRefInner(sema: *Sema, decl_index: Decl.Index, analyze_fn_body: boo
3086330797 if (analyze_fn_body) {
3086430798 try sema.maybeQueueFuncBodyAnalysis(decl_index);
3086530799 }
30866 return sema.addConstant((try mod.intern(.{ .ptr = .{
30800 return Air.internedToRef((try mod.intern(.{ .ptr = .{
3086730801 .ty = ptr_ty.toIntern(),
3086830802 .addr = .{ .decl = decl_index },
30869 } })).toValue());
30803 } })));
3087030804}
3087130805
3087230806fn maybeQueueFuncBodyAnalysis(sema: *Sema, decl_index: Decl.Index) !void {
......@@ -30939,12 +30873,12 @@ fn analyzeLoad(
3093930873 };
3094030874
3094130875 if (try sema.typeHasOnePossibleValue(elem_ty)) |opv| {
30942 return sema.addConstant(opv);
30876 return Air.internedToRef(opv.toIntern());
3094330877 }
3094430878
3094530879 if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| {
3094630880 if (try sema.pointerDeref(block, src, ptr_val, ptr_ty)) |elem_val| {
30947 return sema.addConstant(elem_val);
30881 return Air.internedToRef(elem_val.toIntern());
3094830882 }
3094930883 }
3095030884
......@@ -30974,8 +30908,8 @@ fn analyzeSlicePtr(
3097430908 const mod = sema.mod;
3097530909 const result_ty = slice_ty.slicePtrFieldType(mod);
3097630910 if (try sema.resolveMaybeUndefVal(slice)) |val| {
30977 if (val.isUndef(mod)) return sema.addConstUndef(result_ty);
30978 return sema.addConstant(val.slicePtr(mod));
30911 if (val.isUndef(mod)) return mod.undefRef(result_ty);
30912 return Air.internedToRef(val.slicePtr(mod).toIntern());
3097930913 }
3098030914 try sema.requireRuntimeBlock(block, slice_src, null);
3098130915 return block.addTyOp(.slice_ptr, result_ty, slice);
......@@ -30990,9 +30924,9 @@ fn analyzeSliceLen(
3099030924 const mod = sema.mod;
3099130925 if (try sema.resolveMaybeUndefVal(slice_inst)) |slice_val| {
3099230926 if (slice_val.isUndef(mod)) {
30993 return sema.addConstUndef(Type.usize);
30927 return mod.undefRef(Type.usize);
3099430928 }
30995 return sema.addIntUnsigned(Type.usize, slice_val.sliceLen(sema.mod));
30929 return mod.intRef(Type.usize, slice_val.sliceLen(sema.mod));
3099630930 }
3099730931 try sema.requireRuntimeBlock(block, src, null);
3099830932 return block.addTyOp(.slice_len, Type.usize, slice_inst);
......@@ -31009,7 +30943,7 @@ fn analyzeIsNull(
3100930943 const result_ty = Type.bool;
3101030944 if (try sema.resolveMaybeUndefVal(operand)) |opt_val| {
3101130945 if (opt_val.isUndef(mod)) {
31012 return sema.addConstUndef(result_ty);
30946 return mod.undefRef(result_ty);
3101330947 }
3101430948 const is_null = opt_val.isNull(mod);
3101530949 const bool_value = if (invert_logic) !is_null else is_null;
......@@ -31081,7 +31015,7 @@ fn analyzeIsNonErrComptimeOnly(
3108131015 else => {},
3108231016 }
3108331017 } else if (operand == .undef) {
31084 return sema.addConstUndef(Type.bool);
31018 return mod.undefRef(Type.bool);
3108531019 } else if (@intFromEnum(operand) < InternPool.static_len) {
3108631020 // None of the ref tags can be errors.
3108731021 return .bool_true;
......@@ -31165,7 +31099,7 @@ fn analyzeIsNonErrComptimeOnly(
3116531099
3116631100 if (maybe_operand_val) |err_union| {
3116731101 if (err_union.isUndef(mod)) {
31168 return sema.addConstUndef(Type.bool);
31102 return mod.undefRef(Type.bool);
3116931103 }
3117031104 if (err_union.getErrorName(mod) == .none) {
3117131105 return .bool_true;
......@@ -31341,7 +31275,7 @@ fn analyzeSlice(
3134131275 break :e end;
3134231276 }
3134331277
31344 break :e try sema.addConstant(len_val);
31278 break :e Air.internedToRef(len_val.toIntern());
3134531279 } else if (slice_ty.isSlice(mod)) {
3134631280 if (!end_is_len) {
3134731281 const end = if (by_length) end: {
......@@ -31554,15 +31488,15 @@ fn analyzeSlice(
3155431488 };
3155531489
3155631490 if (!new_ptr_val.isUndef(mod)) {
31557 return sema.addConstant(try mod.getCoerced(
31491 return Air.internedToRef((try mod.getCoerced(
3155831492 (try new_ptr_val.intern(new_ptr_ty, mod)).toValue(),
3155931493 return_ty,
31560 ));
31494 )).toIntern());
3156131495 }
3156231496
3156331497 // Special case: @as([]i32, undefined)[x..x]
3156431498 if (new_len_int == 0) {
31565 return sema.addConstUndef(return_ty);
31499 return mod.undefRef(return_ty);
3156631500 }
3156731501
3156831502 return sema.fail(block, src, "non-zero length slice of undefined pointer", .{});
......@@ -31591,12 +31525,12 @@ fn analyzeSlice(
3159131525
3159231526 // requirement: end <= len
3159331527 const opt_len_inst = if (array_ty.zigTypeTag(mod) == .Array)
31594 try sema.addIntUnsigned(Type.usize, array_ty.arrayLenIncludingSentinel(mod))
31528 try mod.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(mod))
3159531529 else if (slice_ty.isSlice(mod)) blk: {
3159631530 if (try sema.resolveDefinedValue(block, src, ptr_or_slice)) |slice_val| {
3159731531 // we don't need to add one for sentinels because the
3159831532 // underlying value data includes the sentinel
31599 break :blk try sema.addIntUnsigned(Type.usize, slice_val.sliceLen(mod));
31533 break :blk try mod.intRef(Type.usize, slice_val.sliceLen(mod));
3160031534 }
3160131535
3160231536 const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice);
......@@ -31619,7 +31553,7 @@ fn analyzeSlice(
3161931553 const result = try block.addInst(.{
3162031554 .tag = .slice,
3162131555 .data = .{ .ty_pl = .{
31622 .ty = try sema.addType(return_ty),
31556 .ty = Air.internedToRef(return_ty.toIntern()),
3162331557 .payload = try sema.addExtra(Air.Bin{
3162431558 .lhs = new_ptr,
3162531559 .rhs = new_len,
......@@ -31683,7 +31617,7 @@ fn cmpNumeric(
3168331617 }
3168431618
3168531619 if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
31686 return sema.addConstUndef(Type.bool);
31620 return mod.undefRef(Type.bool);
3168731621 }
3168831622 if (lhs_val.isNan(mod) or rhs_val.isNan(mod)) {
3168931623 if (op == std.math.CompareOperator.neq) {
......@@ -31776,7 +31710,7 @@ fn cmpNumeric(
3177631710 var lhs_bits: usize = undefined;
3177731711 if (try sema.resolveMaybeUndefLazyVal(lhs)) |lhs_val| {
3177831712 if (lhs_val.isUndef(mod))
31779 return sema.addConstUndef(Type.bool);
31713 return mod.undefRef(Type.bool);
3178031714 if (lhs_val.isNan(mod)) switch (op) {
3178131715 .neq => return Air.Inst.Ref.bool_true,
3178231716 else => return Air.Inst.Ref.bool_false,
......@@ -31834,7 +31768,7 @@ fn cmpNumeric(
3183431768 var rhs_bits: usize = undefined;
3183531769 if (try sema.resolveMaybeUndefLazyVal(rhs)) |rhs_val| {
3183631770 if (rhs_val.isUndef(mod))
31837 return sema.addConstUndef(Type.bool);
31771 return mod.undefRef(Type.bool);
3183831772 if (rhs_val.isNan(mod)) switch (op) {
3183931773 .neq => return Air.Inst.Ref.bool_true,
3184031774 else => return Air.Inst.Ref.bool_false,
......@@ -32039,10 +31973,10 @@ fn cmpVector(
3203931973 if (try sema.resolveMaybeUndefVal(casted_lhs)) |lhs_val| {
3204031974 if (try sema.resolveMaybeUndefVal(casted_rhs)) |rhs_val| {
3204131975 if (lhs_val.isUndef(mod) or rhs_val.isUndef(mod)) {
32042 return sema.addConstUndef(result_ty);
31976 return mod.undefRef(result_ty);
3204331977 }
3204431978 const cmp_val = try sema.compareVector(lhs_val, op, rhs_val, resolved_ty);
32045 return sema.addConstant(cmp_val);
31979 return Air.internedToRef(cmp_val.toIntern());
3204631980 } else {
3204731981 break :src rhs_src;
3204831982 }
......@@ -32063,10 +31997,10 @@ fn wrapOptional(
3206331997 inst_src: LazySrcLoc,
3206431998) !Air.Inst.Ref {
3206531999 if (try sema.resolveMaybeUndefVal(inst)) |val| {
32066 return sema.addConstant((try sema.mod.intern(.{ .opt = .{
32000 return Air.internedToRef((try sema.mod.intern(.{ .opt = .{
3206732001 .ty = dest_ty.toIntern(),
3206832002 .val = val.toIntern(),
32069 } })).toValue());
32003 } })));
3207032004 }
3207132005
3207232006 try sema.requireRuntimeBlock(block, inst_src, null);
......@@ -32084,10 +32018,10 @@ fn wrapErrorUnionPayload(
3208432018 const dest_payload_ty = dest_ty.errorUnionPayload(mod);
3208532019 const coerced = try sema.coerceExtra(block, dest_payload_ty, inst, inst_src, .{ .report_err = false });
3208632020 if (try sema.resolveMaybeUndefVal(coerced)) |val| {
32087 return sema.addConstant((try mod.intern(.{ .error_union = .{
32021 return Air.internedToRef((try mod.intern(.{ .error_union = .{
3208832022 .ty = dest_ty.toIntern(),
3208932023 .val = .{ .payload = try val.intern(dest_payload_ty, mod) },
32090 } })).toValue());
32024 } })));
3209132025 }
3209232026 try sema.requireRuntimeBlock(block, inst_src, null);
3209332027 try sema.queueFullTypeResolution(dest_payload_ty);
......@@ -32145,10 +32079,10 @@ fn wrapErrorUnionSet(
3214532079 else => unreachable,
3214632080 },
3214732081 }
32148 return sema.addConstant((try mod.intern(.{ .error_union = .{
32082 return Air.internedToRef((try mod.intern(.{ .error_union = .{
3214932083 .ty = dest_ty.toIntern(),
3215032084 .val = .{ .err_name = expected_name },
32151 } })).toValue());
32085 } })));
3215232086 }
3215332087
3215432088 try sema.requireRuntimeBlock(block, inst_src, null);
......@@ -32165,10 +32099,10 @@ fn unionToTag(
3216532099) !Air.Inst.Ref {
3216632100 const mod = sema.mod;
3216732101 if ((try sema.typeHasOnePossibleValue(enum_ty))) |opv| {
32168 return sema.addConstant(opv);
32102 return Air.internedToRef(opv.toIntern());
3216932103 }
3217032104 if (try sema.resolveMaybeUndefVal(un)) |un_val| {
32171 return sema.addConstant(un_val.unionTag(mod));
32105 return Air.internedToRef(un_val.unionTag(mod).toIntern());
3217232106 }
3217332107 try sema.requireRuntimeBlock(block, un_src, null);
3217432108 return block.addTyOp(.get_union_tag, enum_ty, un);
......@@ -33510,7 +33444,7 @@ fn resolvePeerTypesInner(
3351033444 comptime_val = null;
3351133445 break;
3351233446 };
33513 const uncoerced_field = try sema.addConstant(uncoerced_field_val);
33447 const uncoerced_field = Air.internedToRef(uncoerced_field_val.toIntern());
3351433448 const coerced_inst = sema.coerceExtra(block, field_ty.toType(), uncoerced_field, src, .{ .report_err = false }) catch |err| switch (err) {
3351533449 // 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
3351633450 error.NotCoercible => {
......@@ -35977,27 +35911,6 @@ pub fn getTmpAir(sema: Sema) Air {
3597735911 };
3597835912}
3597935913
35980// TODO: make this non-fallible or remove it entirely
35981pub fn addType(sema: *Sema, ty: Type) !Air.Inst.Ref {
35982 _ = sema;
35983 return Air.internedToRef(ty.toIntern());
35984}
35985
35986fn addIntUnsigned(sema: *Sema, ty: Type, int: u64) CompileError!Air.Inst.Ref {
35987 const mod = sema.mod;
35988 return sema.addConstant(try mod.intValue(ty, int));
35989}
35990
35991fn addConstUndef(sema: *Sema, ty: Type) CompileError!Air.Inst.Ref {
35992 return sema.addConstant((try sema.mod.intern(.{ .undef = ty.toIntern() })).toValue());
35993}
35994
35995// TODO: make this non-fallible or remove it entirely
35996pub fn addConstant(sema: *Sema, val: Value) !Air.Inst.Ref {
35997 _ = sema;
35998 return Air.internedToRef(val.toIntern());
35999}
36000
3600135914pub fn addExtra(sema: *Sema, extra: anytype) Allocator.Error!u32 {
3600235915 const fields = std.meta.fields(@TypeOf(extra));
3600335916 try sema.air_extra.ensureUnusedCapacity(sema.gpa, fields.len);
......@@ -36075,13 +35988,13 @@ fn analyzeComptimeAlloc(
3607535988
3607635989 try sema.comptime_mutable_decls.append(decl_index);
3607735990 try mod.declareDeclDependency(sema.owner_decl_index, decl_index);
36078 return sema.addConstant((try mod.intern(.{ .ptr = .{
35991 return Air.internedToRef((try mod.intern(.{ .ptr = .{
3607935992 .ty = ptr_type.toIntern(),
3608035993 .addr = .{ .mut_decl = .{
3608135994 .decl = decl_index,
3608235995 .runtime_index = block.runtime_index,
3608335996 } },
36084 } })).toValue());
35997 } })));
3608535998}
3608635999
3608736000/// The places where a user can specify an address space attribute