convert `toType` and `toValue` to `Type.fromInterned` and `Value.fromInterned`

1 files changed, 163 insertions, 158 deletions

diff --git a/src/type.zig b/src/type.zig
index 43de38b905..b914432793 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -185,8 +185,8 @@ pub const Type = struct {
 
                 if (info.sentinel != .none) switch (info.flags.size) {
                     .One, .C => unreachable,
-                    .Many => try writer.print("[*:{}]", .{info.sentinel.toValue().fmtValue(info.child.toType(), mod)}),
-                    .Slice => try writer.print("[:{}]", .{info.sentinel.toValue().fmtValue(info.child.toType(), mod)}),
+                    .Many => try writer.print("[*:{}]", .{Value.fromInterned(info.sentinel).fmtValue(Type.fromInterned(info.child), mod)}),
+                    .Slice => try writer.print("[:{}]", .{Value.fromInterned(info.sentinel).fmtValue(Type.fromInterned(info.child), mod)}),
                 } else switch (info.flags.size) {
                     .One => try writer.writeAll("*"),
                     .Many => try writer.writeAll("[*]"),
@@ -200,7 +200,7 @@ pub const Type = struct {
                     const alignment = if (info.flags.alignment != .none)
                         info.flags.alignment
                     else
-                        info.child.toType().abiAlignment(mod);
+                        Type.fromInterned(info.child).abiAlignment(mod);
                     try writer.print("align({d}", .{alignment.toByteUnits(0)});
 
                     if (info.packed_offset.bit_offset != 0 or info.packed_offset.host_size != 0) {
@@ -222,36 +222,36 @@ pub const Type = struct {
                 if (info.flags.is_volatile) try writer.writeAll("volatile ");
                 if (info.flags.is_allowzero and info.flags.size != .C) try writer.writeAll("allowzero ");
 
-                try print(info.child.toType(), writer, mod);
+                try print(Type.fromInterned(info.child), writer, mod);
                 return;
             },
             .array_type => |array_type| {
                 if (array_type.sentinel == .none) {
                     try writer.print("[{d}]", .{array_type.len});
-                    try print(array_type.child.toType(), writer, mod);
+                    try print(Type.fromInterned(array_type.child), writer, mod);
                 } else {
                     try writer.print("[{d}:{}]", .{
                         array_type.len,
-                        array_type.sentinel.toValue().fmtValue(array_type.child.toType(), mod),
+                        Value.fromInterned(array_type.sentinel).fmtValue(Type.fromInterned(array_type.child), mod),
                     });
-                    try print(array_type.child.toType(), writer, mod);
+                    try print(Type.fromInterned(array_type.child), writer, mod);
                 }
                 return;
             },
             .vector_type => |vector_type| {
                 try writer.print("@Vector({d}, ", .{vector_type.len});
-                try print(vector_type.child.toType(), writer, mod);
+                try print(Type.fromInterned(vector_type.child), writer, mod);
                 try writer.writeAll(")");
                 return;
             },
             .opt_type => |child| {
                 try writer.writeByte('?');
-                return print(child.toType(), writer, mod);
+                return print(Type.fromInterned(child), writer, mod);
             },
             .error_union_type => |error_union_type| {
-                try print(error_union_type.error_set_type.toType(), writer, mod);
+                try print(Type.fromInterned(error_union_type.error_set_type), writer, mod);
                 try writer.writeByte('!');
-                try print(error_union_type.payload_type.toType(), writer, mod);
+                try print(Type.fromInterned(error_union_type.payload_type), writer, mod);
                 return;
             },
             .inferred_error_set_type => |func_index| {
@@ -342,10 +342,10 @@ pub const Type = struct {
                         try writer.print("{}: ", .{anon_struct.names.get(ip)[i].fmt(&mod.intern_pool)});
                     }
 
-                    try print(field_ty.toType(), writer, mod);
+                    try print(Type.fromInterned(field_ty), writer, mod);
 
                     if (val != .none) {
-                        try writer.print(" = {}", .{val.toValue().fmtValue(field_ty.toType(), mod)});
+                        try writer.print(" = {}", .{Value.fromInterned(val).fmtValue(Type.fromInterned(field_ty), mod)});
                     }
                 }
                 try writer.writeAll("}");
@@ -382,7 +382,7 @@ pub const Type = struct {
                     if (param_ty == .generic_poison_type) {
                         try writer.writeAll("anytype");
                     } else {
-                        try print(param_ty.toType(), writer, mod);
+                        try print(Type.fromInterned(param_ty), writer, mod);
                     }
                 }
                 if (fn_info.is_var_args) {
@@ -403,13 +403,13 @@ pub const Type = struct {
                 if (fn_info.return_type == .generic_poison_type) {
                     try writer.writeAll("anytype");
                 } else {
-                    try print(fn_info.return_type.toType(), writer, mod);
+                    try print(Type.fromInterned(fn_info.return_type), writer, mod);
                 }
             },
             .anyframe_type => |child| {
                 if (child == .none) return writer.writeAll("anyframe");
                 try writer.writeAll("anyframe->");
-                return print(child.toType(), writer, mod);
+                return print(Type.fromInterned(child), writer, mod);
             },
 
             // values, not types
@@ -435,13 +435,18 @@ pub const Type = struct {
         }
     }
 
+    pub fn fromInterned(i: InternPool.Index) Type {
+        assert(i != .none);
+        return .{ .ip_index = i };
+    }
+
     pub fn toIntern(ty: Type) InternPool.Index {
         assert(ty.ip_index != .none);
         return ty.ip_index;
     }
 
     pub fn toValue(self: Type) Value {
-        return self.toIntern().toValue();
+        return Value.fromInterned(self.toIntern());
     }
 
     const RuntimeBitsError = Module.CompileError || error{NeedLazy};
@@ -482,18 +487,18 @@ pub const Type = struct {
                 .anyframe_type => true,
                 .array_type => |array_type| {
                     if (array_type.sentinel != .none) {
-                        return array_type.child.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
+                        return Type.fromInterned(array_type.child).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
                     } else {
                         return array_type.len > 0 and
-                            try array_type.child.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
+                            try Type.fromInterned(array_type.child).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
                     }
                 },
                 .vector_type => |vector_type| {
                     return vector_type.len > 0 and
-                        try vector_type.child.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
+                        try Type.fromInterned(vector_type.child).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat);
                 },
                 .opt_type => |child| {
-                    const child_ty = child.toType();
+                    const child_ty = Type.fromInterned(child);
                     if (child_ty.isNoReturn(mod)) {
                         // Then the optional is comptime-known to be null.
                         return false;
@@ -577,7 +582,7 @@ pub const Type = struct {
                     }
                     for (0..struct_type.field_types.len) |i| {
                         if (struct_type.comptime_bits.getBit(ip, i)) continue;
-                        const field_ty = struct_type.field_types.get(ip)[i].toType();
+                        const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
                         if (try field_ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
                             return true;
                     } else {
@@ -587,7 +592,7 @@ pub const Type = struct {
                 .anon_struct_type => |tuple| {
                     for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
                         if (val != .none) continue; // comptime field
-                        if (try field_ty.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat)) return true;
+                        if (try Type.fromInterned(field_ty).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat)) return true;
                     }
                     return false;
                 },
@@ -607,7 +612,7 @@ pub const Type = struct {
                             // tag_ty will be `none` if this union's tag type is not resolved yet,
                             // in which case we want control flow to continue down below.
                             if (tag_ty != .none and
-                                try tag_ty.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
+                                try Type.fromInterned(tag_ty).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
                             {
                                 return true;
                             }
@@ -621,7 +626,7 @@ pub const Type = struct {
                     }
                     const union_obj = ip.loadUnionType(union_type);
                     for (0..union_obj.field_types.len) |field_index| {
-                        const field_ty = union_obj.field_types.get(ip)[field_index].toType();
+                        const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);
                         if (try field_ty.hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat))
                             return true;
                     } else {
@@ -630,7 +635,7 @@ pub const Type = struct {
                 },
 
                 .opaque_type => true,
-                .enum_type => |enum_type| enum_type.tag_ty.toType().hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
+                .enum_type => |enum_type| Type.fromInterned(enum_type.tag_ty).hasRuntimeBitsAdvanced(mod, ignore_comptime_only, strat),
 
                 // values, not types
                 .undef,
@@ -676,7 +681,7 @@ pub const Type = struct {
             .func_type,
             => false,
 
-            .array_type => |array_type| array_type.child.toType().hasWellDefinedLayout(mod),
+            .array_type => |array_type| Type.fromInterned(array_type.child).hasWellDefinedLayout(mod),
             .opt_type => ty.isPtrLikeOptional(mod),
             .ptr_type => |ptr_type| ptr_type.flags.size != .Slice,
 
@@ -783,7 +788,7 @@ pub const Type = struct {
         if (fn_info.is_generic) return false;
         if (fn_info.is_var_args) return true;
         if (fn_info.cc == .Inline) return false;
-        return !try fn_info.return_type.toType().comptimeOnlyAdvanced(mod, opt_sema);
+        return !try Type.fromInterned(fn_info.return_type).comptimeOnlyAdvanced(mod, opt_sema);
     }
 
     pub fn isFnOrHasRuntimeBits(ty: Type, mod: *Module) bool {
@@ -817,13 +822,13 @@ pub const Type = struct {
                     return ptr_type.flags.alignment;
 
                 if (opt_sema) |sema| {
-                    const res = try ptr_type.child.toType().abiAlignmentAdvanced(mod, .{ .sema = sema });
+                    const res = try Type.fromInterned(ptr_type.child).abiAlignmentAdvanced(mod, .{ .sema = sema });
                     return res.scalar;
                 }
 
-                return (ptr_type.child.toType().abiAlignmentAdvanced(mod, .eager) catch unreachable).scalar;
+                return (Type.fromInterned(ptr_type.child).abiAlignmentAdvanced(mod, .eager) catch unreachable).scalar;
             },
-            .opt_type => |child| child.toType().ptrAlignmentAdvanced(mod, opt_sema),
+            .opt_type => |child| Type.fromInterned(child).ptrAlignmentAdvanced(mod, opt_sema),
             else => unreachable,
         };
     }
@@ -891,10 +896,10 @@ pub const Type = struct {
                     return .{ .scalar = Alignment.fromByteUnits(@divExact(target.ptrBitWidth(), 8)) };
                 },
                 .array_type => |array_type| {
-                    return array_type.child.toType().abiAlignmentAdvanced(mod, strat);
+                    return Type.fromInterned(array_type.child).abiAlignmentAdvanced(mod, strat);
                 },
                 .vector_type => |vector_type| {
-                    const bits_u64 = try bitSizeAdvanced(vector_type.child.toType(), mod, opt_sema);
+                    const bits_u64 = try bitSizeAdvanced(Type.fromInterned(vector_type.child), mod, opt_sema);
                     const bits: u32 = @intCast(bits_u64);
                     const bytes = ((bits * vector_type.len) + 7) / 8;
                     const alignment = std.math.ceilPowerOfTwoAssert(u32, bytes);
@@ -902,7 +907,7 @@ pub const Type = struct {
                 },
 
                 .opt_type => return abiAlignmentAdvancedOptional(ty, mod, strat),
-                .error_union_type => |info| return abiAlignmentAdvancedErrorUnion(ty, mod, strat, info.payload_type.toType()),
+                .error_union_type => |info| return abiAlignmentAdvancedErrorUnion(ty, mod, strat, Type.fromInterned(info.payload_type)),
 
                 .error_set_type, .inferred_error_set_type => {
                     const bits = mod.errorSetBits();
@@ -992,14 +997,14 @@ pub const Type = struct {
                         switch (strat) {
                             .sema => |sema| try sema.resolveTypeLayout(ty),
                             .lazy => if (struct_type.backingIntType(ip).* == .none) return .{
-                                .val = (try mod.intern(.{ .int = .{
+                                .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                     .ty = .comptime_int_type,
                                     .storage = .{ .lazy_align = ty.toIntern() },
-                                } })).toValue(),
+                                } }))),
                             },
                             .eager => {},
                         }
-                        return .{ .scalar = struct_type.backingIntType(ip).toType().abiAlignment(mod) };
+                        return .{ .scalar = Type.fromInterned(struct_type.backingIntType(ip).*).abiAlignment(mod) };
                     }
 
                     const flags = struct_type.flagsPtr(ip).*;
@@ -1010,25 +1015,25 @@ pub const Type = struct {
                         .sema => |sema| .{
                             .scalar = try sema.resolveStructAlignment(ty.toIntern(), struct_type),
                         },
-                        .lazy => .{ .val = (try mod.intern(.{ .int = .{
+                        .lazy => .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                             .ty = .comptime_int_type,
                             .storage = .{ .lazy_align = ty.toIntern() },
-                        } })).toValue() },
+                        } }))) },
                     };
                 },
                 .anon_struct_type => |tuple| {
                     var big_align: Alignment = .@"1";
                     for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
                         if (val != .none) continue; // comptime field
-                        switch (try field_ty.toType().abiAlignmentAdvanced(mod, strat)) {
+                        switch (try Type.fromInterned(field_ty).abiAlignmentAdvanced(mod, strat)) {
                             .scalar => |field_align| big_align = big_align.max(field_align),
                             .val => switch (strat) {
                                 .eager => unreachable, // field type alignment not resolved
                                 .sema => unreachable, // passed to abiAlignmentAdvanced above
-                                .lazy => return .{ .val = (try mod.intern(.{ .int = .{
+                                .lazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                     .ty = .comptime_int_type,
                                     .storage = .{ .lazy_align = ty.toIntern() },
-                                } })).toValue() },
+                                } }))) },
                             },
                         }
                     }
@@ -1041,17 +1046,17 @@ pub const Type = struct {
                     if (!union_type.haveLayout(ip)) switch (strat) {
                         .eager => unreachable, // union layout not resolved
                         .sema => |sema| return .{ .scalar = try sema.resolveUnionAlignment(ty, union_type) },
-                        .lazy => return .{ .val = (try mod.intern(.{ .int = .{
+                        .lazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                             .ty = .comptime_int_type,
                             .storage = .{ .lazy_align = ty.toIntern() },
-                        } })).toValue() },
+                        } }))) },
                     };
 
                     return .{ .scalar = union_type.flagsPtr(ip).alignment };
                 },
                 .opaque_type => return .{ .scalar = .@"1" },
                 .enum_type => |enum_type| return .{
-                    .scalar = enum_type.tag_ty.toType().abiAlignment(mod),
+                    .scalar = Type.fromInterned(enum_type.tag_ty).abiAlignment(mod),
                 },
 
                 // values, not types
@@ -1090,10 +1095,10 @@ pub const Type = struct {
         switch (strat) {
             .eager, .sema => {
                 if (!(payload_ty.hasRuntimeBitsAdvanced(mod, false, strat) catch |err| switch (err) {
-                    error.NeedLazy => return .{ .val = (try mod.intern(.{ .int = .{
+                    error.NeedLazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                         .ty = .comptime_int_type,
                         .storage = .{ .lazy_align = ty.toIntern() },
-                    } })).toValue() },
+                    } }))) },
                     else => |e| return e,
                 })) {
                     return .{ .scalar = code_align };
@@ -1107,10 +1112,10 @@ pub const Type = struct {
                     .scalar => |payload_align| return .{ .scalar = code_align.max(payload_align) },
                     .val => {},
                 }
-                return .{ .val = (try mod.intern(.{ .int = .{
+                return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                     .ty = .comptime_int_type,
                     .storage = .{ .lazy_align = ty.toIntern() },
-                } })).toValue() };
+                } }))) };
             },
         }
     }
@@ -1135,10 +1140,10 @@ pub const Type = struct {
         switch (strat) {
             .eager, .sema => {
                 if (!(child_type.hasRuntimeBitsAdvanced(mod, false, strat) catch |err| switch (err) {
-                    error.NeedLazy => return .{ .val = (try mod.intern(.{ .int = .{
+                    error.NeedLazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                         .ty = .comptime_int_type,
                         .storage = .{ .lazy_align = ty.toIntern() },
-                    } })).toValue() },
+                    } }))) },
                     else => |e| return e,
                 })) {
                     return .{ .scalar = .@"1" };
@@ -1147,10 +1152,10 @@ pub const Type = struct {
             },
             .lazy => switch (try child_type.abiAlignmentAdvanced(mod, strat)) {
                 .scalar => |x| return .{ .scalar = x.max(.@"1") },
-                .val => return .{ .val = (try mod.intern(.{ .int = .{
+                .val => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                     .ty = .comptime_int_type,
                     .storage = .{ .lazy_align = ty.toIntern() },
-                } })).toValue() },
+                } }))) },
             },
         }
     }
@@ -1205,14 +1210,14 @@ pub const Type = struct {
                 .array_type => |array_type| {
                     const len = array_type.len + @intFromBool(array_type.sentinel != .none);
                     if (len == 0) return .{ .scalar = 0 };
-                    switch (try array_type.child.toType().abiSizeAdvanced(mod, strat)) {
+                    switch (try Type.fromInterned(array_type.child).abiSizeAdvanced(mod, strat)) {
                         .scalar => |elem_size| return .{ .scalar = len * elem_size },
                         .val => switch (strat) {
                             .sema, .eager => unreachable,
-                            .lazy => return .{ .val = (try mod.intern(.{ .int = .{
+                            .lazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                 .ty = .comptime_int_type,
                                 .storage = .{ .lazy_size = ty.toIntern() },
-                            } })).toValue() },
+                            } }))) },
                         },
                     }
                 },
@@ -1220,20 +1225,20 @@ pub const Type = struct {
                     const opt_sema = switch (strat) {
                         .sema => |sema| sema,
                         .eager => null,
-                        .lazy => return .{ .val = (try mod.intern(.{ .int = .{
+                        .lazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                             .ty = .comptime_int_type,
                             .storage = .{ .lazy_size = ty.toIntern() },
-                        } })).toValue() },
+                        } }))) },
                     };
-                    const elem_bits = try vector_type.child.toType().bitSizeAdvanced(mod, opt_sema);
+                    const elem_bits = try Type.fromInterned(vector_type.child).bitSizeAdvanced(mod, opt_sema);
                     const total_bits = elem_bits * vector_type.len;
                     const total_bytes = (total_bits + 7) / 8;
                     const alignment = switch (try ty.abiAlignmentAdvanced(mod, strat)) {
                         .scalar => |x| x,
-                        .val => return .{ .val = (try mod.intern(.{ .int = .{
+                        .val => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                             .ty = .comptime_int_type,
                             .storage = .{ .lazy_size = ty.toIntern() },
-                        } })).toValue() },
+                        } }))) },
                     };
                     return AbiSizeAdvanced{ .scalar = alignment.forward(total_bytes) };
                 },
@@ -1247,15 +1252,15 @@ pub const Type = struct {
                 },
 
                 .error_union_type => |error_union_type| {
-                    const payload_ty = error_union_type.payload_type.toType();
+                    const payload_ty = Type.fromInterned(error_union_type.payload_type);
                     // This code needs to be kept in sync with the equivalent switch prong
                     // in abiAlignmentAdvanced.
                     const code_size = abiSize(Type.anyerror, mod);
                     if (!(payload_ty.hasRuntimeBitsAdvanced(mod, false, strat) catch |err| switch (err) {
-                        error.NeedLazy => return .{ .val = (try mod.intern(.{ .int = .{
+                        error.NeedLazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                             .ty = .comptime_int_type,
                             .storage = .{ .lazy_size = ty.toIntern() },
-                        } })).toValue() },
+                        } }))) },
                         else => |e| return e,
                     })) {
                         // Same as anyerror.
@@ -1268,10 +1273,10 @@ pub const Type = struct {
                         .val => switch (strat) {
                             .sema => unreachable,
                             .eager => unreachable,
-                            .lazy => return .{ .val = (try mod.intern(.{ .int = .{
+                            .lazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                 .ty = .comptime_int_type,
                                 .storage = .{ .lazy_size = ty.toIntern() },
-                            } })).toValue() },
+                            } }))) },
                         },
                     };
 
@@ -1358,18 +1363,18 @@ pub const Type = struct {
                         .lazy => switch (struct_type.layout) {
                             .Packed => {
                                 if (struct_type.backingIntType(ip).* == .none) return .{
-                                    .val = (try mod.intern(.{ .int = .{
+                                    .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                         .ty = .comptime_int_type,
                                         .storage = .{ .lazy_size = ty.toIntern() },
-                                    } })).toValue(),
+                                    } }))),
                                 };
                             },
                             .Auto, .Extern => {
                                 if (!struct_type.haveLayout(ip)) return .{
-                                    .val = (try mod.intern(.{ .int = .{
+                                    .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                         .ty = .comptime_int_type,
                                         .storage = .{ .lazy_size = ty.toIntern() },
-                                    } })).toValue(),
+                                    } }))),
                                 };
                             },
                         },
@@ -1377,7 +1382,7 @@ pub const Type = struct {
                     }
                     return switch (struct_type.layout) {
                         .Packed => .{
-                            .scalar = struct_type.backingIntType(ip).toType().abiSize(mod),
+                            .scalar = Type.fromInterned(struct_type.backingIntType(ip).*).abiSize(mod),
                         },
                         .Auto, .Extern => .{ .scalar = struct_type.size(ip).* },
                     };
@@ -1398,10 +1403,10 @@ pub const Type = struct {
                     switch (strat) {
                         .sema => |sema| try sema.resolveTypeLayout(ty),
                         .lazy => if (!union_type.flagsPtr(ip).status.haveLayout()) return .{
-                            .val = (try mod.intern(.{ .int = .{
+                            .val = Value.fromInterned((try mod.intern(.{ .int = .{
                                 .ty = .comptime_int_type,
                                 .storage = .{ .lazy_size = ty.toIntern() },
-                            } })).toValue(),
+                            } }))),
                         },
                         .eager => {},
                     }
@@ -1409,7 +1414,7 @@ pub const Type = struct {
                     return .{ .scalar = union_type.size(ip).* };
                 },
                 .opaque_type => unreachable, // no size available
-                .enum_type => |enum_type| return AbiSizeAdvanced{ .scalar = enum_type.tag_ty.toType().abiSize(mod) },
+                .enum_type => |enum_type| return AbiSizeAdvanced{ .scalar = Type.fromInterned(enum_type.tag_ty).abiSize(mod) },
 
                 // values, not types
                 .undef,
@@ -1447,10 +1452,10 @@ pub const Type = struct {
         }
 
         if (!(child_ty.hasRuntimeBitsAdvanced(mod, false, strat) catch |err| switch (err) {
-            error.NeedLazy => return .{ .val = (try mod.intern(.{ .int = .{
+            error.NeedLazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                 .ty = .comptime_int_type,
                 .storage = .{ .lazy_size = ty.toIntern() },
-            } })).toValue() },
+            } }))) },
             else => |e| return e,
         })) return AbiSizeAdvanced{ .scalar = 1 };
 
@@ -1463,10 +1468,10 @@ pub const Type = struct {
             .val => switch (strat) {
                 .sema => unreachable,
                 .eager => unreachable,
-                .lazy => return .{ .val = (try mod.intern(.{ .int = .{
+                .lazy => return .{ .val = Value.fromInterned((try mod.intern(.{ .int = .{
                     .ty = .comptime_int_type,
                     .storage = .{ .lazy_size = ty.toIntern() },
-                } })).toValue() },
+                } }))) },
             },
         };
 
@@ -1518,7 +1523,7 @@ pub const Type = struct {
             .array_type => |array_type| {
                 const len = array_type.len + @intFromBool(array_type.sentinel != .none);
                 if (len == 0) return 0;
-                const elem_ty = array_type.child.toType();
+                const elem_ty = Type.fromInterned(array_type.child);
                 const elem_size = @max(
                     (try elem_ty.abiAlignmentAdvanced(mod, strat)).scalar.toByteUnits(0),
                     (try elem_ty.abiSizeAdvanced(mod, strat)).scalar,
@@ -1528,7 +1533,7 @@ pub const Type = struct {
                 return (len - 1) * 8 * elem_size + elem_bit_size;
             },
             .vector_type => |vector_type| {
-                const child_ty = vector_type.child.toType();
+                const child_ty = Type.fromInterned(vector_type.child);
                 const elem_bit_size = try bitSizeAdvanced(child_ty, mod, opt_sema);
                 return elem_bit_size * vector_type.len;
             },
@@ -1600,7 +1605,7 @@ pub const Type = struct {
             .struct_type => |struct_type| {
                 if (struct_type.layout == .Packed) {
                     if (opt_sema) |sema| try sema.resolveTypeLayout(ty);
-                    return try struct_type.backingIntType(ip).*.toType().bitSizeAdvanced(mod, opt_sema);
+                    return try Type.fromInterned(struct_type.backingIntType(ip).*).bitSizeAdvanced(mod, opt_sema);
                 }
                 return (try ty.abiSizeAdvanced(mod, strat)).scalar * 8;
             },
@@ -1625,13 +1630,13 @@ pub const Type = struct {
                 var size: u64 = 0;
                 for (0..union_obj.field_types.len) |field_index| {
                     const field_ty = union_obj.field_types.get(ip)[field_index];
-                    size = @max(size, try bitSizeAdvanced(field_ty.toType(), mod, opt_sema));
+                    size = @max(size, try bitSizeAdvanced(Type.fromInterned(field_ty), mod, opt_sema));
                 }
 
                 return size;
             },
             .opaque_type => unreachable,
-            .enum_type => |enum_type| return bitSizeAdvanced(enum_type.tag_ty.toType(), mod, opt_sema),
+            .enum_type => |enum_type| return bitSizeAdvanced(Type.fromInterned(enum_type.tag_ty), mod, opt_sema),
 
             // values, not types
             .undef,
@@ -1665,10 +1670,10 @@ pub const Type = struct {
             .union_type => |union_type| union_type.haveLayout(ip),
             .array_type => |array_type| {
                 if ((array_type.len + @intFromBool(array_type.sentinel != .none)) == 0) return true;
-                return array_type.child.toType().layoutIsResolved(mod);
+                return Type.fromInterned(array_type.child).layoutIsResolved(mod);
             },
-            .opt_type => |child| child.toType().layoutIsResolved(mod),
-            .error_union_type => |k| k.payload_type.toType().layoutIsResolved(mod),
+            .opt_type => |child| Type.fromInterned(child).layoutIsResolved(mod),
+            .error_union_type => |k| Type.fromInterned(k.payload_type).layoutIsResolved(mod),
             else => true,
         };
     }
@@ -1701,7 +1706,7 @@ pub const Type = struct {
     }
 
     pub fn slicePtrFieldType(ty: Type, mod: *const Module) Type {
-        return mod.intern_pool.slicePtrType(ty.toIntern()).toType();
+        return Type.fromInterned(mod.intern_pool.slicePtrType(ty.toIntern()));
     }
 
     pub fn isConstPtr(ty: Type, mod: *const Module) bool {
@@ -1801,7 +1806,7 @@ pub const Type = struct {
     }
 
     pub fn childTypeIp(ty: Type, ip: *const InternPool) Type {
-        return ip.childType(ty.toIntern()).toType();
+        return Type.fromInterned(ip.childType(ty.toIntern()));
     }
 
     /// For *[N]T,       returns T.
@@ -1816,16 +1821,16 @@ pub const Type = struct {
     pub fn elemType2(ty: Type, mod: *const Module) Type {
         return switch (mod.intern_pool.indexToKey(ty.toIntern())) {
             .ptr_type => |ptr_type| switch (ptr_type.flags.size) {
-                .One => ptr_type.child.toType().shallowElemType(mod),
-                .Many, .C, .Slice => ptr_type.child.toType(),
+                .One => Type.fromInterned(ptr_type.child).shallowElemType(mod),
+                .Many, .C, .Slice => Type.fromInterned(ptr_type.child),
             },
             .anyframe_type => |child| {
                 assert(child != .none);
-                return child.toType();
+                return Type.fromInterned(child);
             },
-            .vector_type => |vector_type| vector_type.child.toType(),
-            .array_type => |array_type| array_type.child.toType(),
-            .opt_type => |child| mod.intern_pool.childType(child).toType(),
+            .vector_type => |vector_type| Type.fromInterned(vector_type.child),
+            .array_type => |array_type| Type.fromInterned(array_type.child),
+            .opt_type => |child| Type.fromInterned(mod.intern_pool.childType(child)),
             else => unreachable,
         };
     }
@@ -1849,7 +1854,7 @@ pub const Type = struct {
     /// Note that for C pointers this returns the type unmodified.
     pub fn optionalChild(ty: Type, mod: *const Module) Type {
         return switch (mod.intern_pool.indexToKey(ty.toIntern())) {
-            .opt_type => |child| child.toType(),
+            .opt_type => |child| Type.fromInterned(child),
             .ptr_type => |ptr_type| b: {
                 assert(ptr_type.flags.size == .C);
                 break :b ty;
@@ -1866,7 +1871,7 @@ pub const Type = struct {
             .union_type => |union_type| switch (union_type.flagsPtr(ip).runtime_tag) {
                 .tagged => {
                     assert(union_type.flagsPtr(ip).status.haveFieldTypes());
-                    return union_type.enum_tag_ty.toType();
+                    return Type.fromInterned(union_type.enum_tag_ty);
                 },
                 else => null,
             },
@@ -1882,7 +1887,7 @@ pub const Type = struct {
             .union_type => |union_type| {
                 if (!union_type.hasTag(ip)) return null;
                 assert(union_type.haveFieldTypes(ip));
-                return union_type.enum_tag_ty.toType();
+                return Type.fromInterned(union_type.enum_tag_ty);
             },
             else => null,
         };
@@ -1892,7 +1897,7 @@ pub const Type = struct {
     /// not be stored at runtime.
     pub fn unionTagTypeHypothetical(ty: Type, mod: *Module) Type {
         const union_obj = mod.typeToUnion(ty).?;
-        return union_obj.enum_tag_ty.toType();
+        return Type.fromInterned(union_obj.enum_tag_ty);
     }
 
     pub fn unionFieldType(ty: Type, enum_tag: Value, mod: *Module) ?Type {
@@ -1900,7 +1905,7 @@ pub const Type = struct {
         const union_obj = mod.typeToUnion(ty).?;
         const union_fields = union_obj.field_types.get(ip);
         const index = mod.unionTagFieldIndex(union_obj, enum_tag) orelse return null;
-        return union_fields[index].toType();
+        return Type.fromInterned(union_fields[index]);
     }
 
     pub fn unionTagFieldIndex(ty: Type, enum_tag: Value, mod: *Module) ?u32 {
@@ -1912,7 +1917,7 @@ pub const Type = struct {
         const ip = &mod.intern_pool;
         const union_obj = mod.typeToUnion(ty).?;
         for (union_obj.field_types.get(ip)) |field_ty| {
-            if (field_ty.toType().hasRuntimeBits(mod)) return false;
+            if (Type.fromInterned(field_ty).hasRuntimeBits(mod)) return false;
         }
         return true;
     }
@@ -1946,12 +1951,12 @@ pub const Type = struct {
 
     /// Asserts that the type is an error union.
     pub fn errorUnionPayload(ty: Type, mod: *Module) Type {
-        return mod.intern_pool.indexToKey(ty.toIntern()).error_union_type.payload_type.toType();
+        return Type.fromInterned(mod.intern_pool.indexToKey(ty.toIntern()).error_union_type.payload_type);
     }
 
     /// Asserts that the type is an error union.
     pub fn errorUnionSet(ty: Type, mod: *Module) Type {
-        return mod.intern_pool.errorUnionSet(ty.toIntern()).toType();
+        return Type.fromInterned(mod.intern_pool.errorUnionSet(ty.toIntern()));
     }
 
     /// Returns false for unresolved inferred error sets.
@@ -2077,8 +2082,8 @@ pub const Type = struct {
             .anon_struct_type,
             => null,
 
-            .array_type => |t| if (t.sentinel != .none) t.sentinel.toValue() else null,
-            .ptr_type => |t| if (t.sentinel != .none) t.sentinel.toValue() else null,
+            .array_type => |t| if (t.sentinel != .none) Value.fromInterned(t.sentinel) else null,
+            .ptr_type => |t| if (t.sentinel != .none) Value.fromInterned(t.sentinel) else null,
 
             else => unreachable,
         };
@@ -2146,9 +2151,9 @@ pub const Type = struct {
             .c_ulonglong_type => return .{ .signedness = .unsigned, .bits = target.c_type_bit_size(.ulonglong) },
             else => switch (ip.indexToKey(ty.toIntern())) {
                 .int_type => |int_type| return int_type,
-                .struct_type => |t| ty = t.backingIntType(ip).*.toType(),
-                .enum_type => |enum_type| ty = enum_type.tag_ty.toType(),
-                .vector_type => |vector_type| ty = vector_type.child.toType(),
+                .struct_type => |t| ty = Type.fromInterned(t.backingIntType(ip).*),
+                .enum_type => |enum_type| ty = Type.fromInterned(enum_type.tag_ty),
+                .vector_type => |vector_type| ty = Type.fromInterned(vector_type.child),
 
                 .error_set_type, .inferred_error_set_type => {
                     return .{ .signedness = .unsigned, .bits = mod.errorSetBits() };
@@ -2259,7 +2264,7 @@ pub const Type = struct {
 
     /// Asserts the type is a function or a function pointer.
     pub fn fnReturnType(ty: Type, mod: *Module) Type {
-        return mod.intern_pool.funcTypeReturnType(ty.toIntern()).toType();
+        return Type.fromInterned(mod.intern_pool.funcTypeReturnType(ty.toIntern()));
     }
 
     /// Asserts the type is a function.
@@ -2343,15 +2348,15 @@ pub const Type = struct {
 
                 inline .array_type, .vector_type => |seq_type, seq_tag| {
                     const has_sentinel = seq_tag == .array_type and seq_type.sentinel != .none;
-                    if (seq_type.len + @intFromBool(has_sentinel) == 0) return (try mod.intern(.{ .aggregate = .{
+                    if (seq_type.len + @intFromBool(has_sentinel) == 0) return Value.fromInterned((try mod.intern(.{ .aggregate = .{
                         .ty = ty.toIntern(),
                         .storage = .{ .elems = &.{} },
-                    } })).toValue();
-                    if (try seq_type.child.toType().onePossibleValue(mod)) |opv| {
-                        return (try mod.intern(.{ .aggregate = .{
+                    } })));
+                    if (try Type.fromInterned(seq_type.child).onePossibleValue(mod)) |opv| {
+                        return Value.fromInterned((try mod.intern(.{ .aggregate = .{
                             .ty = ty.toIntern(),
                             .storage = .{ .repeated_elem = opv.toIntern() },
-                        } })).toValue();
+                        } })));
                     }
                     return null;
                 },
@@ -2422,7 +2427,7 @@ pub const Type = struct {
                             field_val.* = struct_type.field_inits.get(ip)[i];
                             continue;
                         }
-                        const field_ty = struct_type.field_types.get(ip)[i].toType();
+                        const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[i]);
                         if (try field_ty.onePossibleValue(mod)) |field_opv| {
                             field_val.* = try field_opv.intern(field_ty, mod);
                         } else return null;
@@ -2430,10 +2435,10 @@ pub const Type = struct {
 
                     // In this case the struct has no runtime-known fields and
                     // therefore has one possible value.
-                    return (try mod.intern(.{ .aggregate = .{
+                    return Value.fromInterned((try mod.intern(.{ .aggregate = .{
                         .ty = ty.toIntern(),
                         .storage = .{ .elems = field_vals },
-                    } })).toValue();
+                    } })));
                 },
 
                 .anon_struct_type => |tuple| {
@@ -2445,52 +2450,52 @@ pub const Type = struct {
                     // TODO: write something like getCoercedInts to avoid needing to dupe
                     const duped_values = try mod.gpa.dupe(InternPool.Index, tuple.values.get(ip));
                     defer mod.gpa.free(duped_values);
-                    return (try mod.intern(.{ .aggregate = .{
+                    return Value.fromInterned((try mod.intern(.{ .aggregate = .{
                         .ty = ty.toIntern(),
                         .storage = .{ .elems = duped_values },
-                    } })).toValue();
+                    } })));
                 },
 
                 .union_type => |union_type| {
                     const union_obj = ip.loadUnionType(union_type);
-                    const tag_val = (try union_obj.enum_tag_ty.toType().onePossibleValue(mod)) orelse
+                    const tag_val = (try Type.fromInterned(union_obj.enum_tag_ty).onePossibleValue(mod)) orelse
                         return null;
                     if (union_obj.field_names.len == 0) {
                         const only = try mod.intern(.{ .empty_enum_value = ty.toIntern() });
-                        return only.toValue();
+                        return Value.fromInterned(only);
                     }
                     const only_field_ty = union_obj.field_types.get(ip)[0];
-                    const val_val = (try only_field_ty.toType().onePossibleValue(mod)) orelse
+                    const val_val = (try Type.fromInterned(only_field_ty).onePossibleValue(mod)) orelse
                         return null;
                     const only = try mod.intern(.{ .un = .{
                         .ty = ty.toIntern(),
                         .tag = tag_val.toIntern(),
                         .val = val_val.toIntern(),
                     } });
-                    return only.toValue();
+                    return Value.fromInterned(only);
                 },
                 .opaque_type => return null,
                 .enum_type => |enum_type| switch (enum_type.tag_mode) {
                     .nonexhaustive => {
                         if (enum_type.tag_ty == .comptime_int_type) return null;
 
-                        if (try enum_type.tag_ty.toType().onePossibleValue(mod)) |int_opv| {
+                        if (try Type.fromInterned(enum_type.tag_ty).onePossibleValue(mod)) |int_opv| {
                             const only = try mod.intern(.{ .enum_tag = .{
                                 .ty = ty.toIntern(),
                                 .int = int_opv.toIntern(),
                             } });
-                            return only.toValue();
+                            return Value.fromInterned(only);
                         }
 
                         return null;
                     },
                     .auto, .explicit => {
-                        if (enum_type.tag_ty.toType().hasRuntimeBits(mod)) return null;
+                        if (Type.fromInterned(enum_type.tag_ty).hasRuntimeBits(mod)) return null;
 
                         switch (enum_type.names.len) {
                             0 => {
                                 const only = try mod.intern(.{ .empty_enum_value = ty.toIntern() });
-                                return only.toValue();
+                                return Value.fromInterned(only);
                             },
                             1 => {
                                 if (enum_type.values.len == 0) {
@@ -2501,9 +2506,9 @@ pub const Type = struct {
                                             .storage = .{ .u64 = 0 },
                                         } }),
                                     } });
-                                    return only.toValue();
+                                    return Value.fromInterned(only);
                                 } else {
-                                    return enum_type.values.get(ip)[0].toValue();
+                                    return Value.fromInterned(enum_type.values.get(ip)[0]);
                                 }
                             },
                             else => return null,
@@ -2552,7 +2557,7 @@ pub const Type = struct {
             else => switch (ip.indexToKey(ty.toIntern())) {
                 .int_type => false,
                 .ptr_type => |ptr_type| {
-                    const child_ty = ptr_type.child.toType();
+                    const child_ty = Type.fromInterned(ptr_type.child);
                     switch (child_ty.zigTypeTag(mod)) {
                         .Fn => return !try child_ty.fnHasRuntimeBitsAdvanced(mod, opt_sema),
                         .Opaque => return false,
@@ -2561,12 +2566,12 @@ pub const Type = struct {
                 },
                 .anyframe_type => |child| {
                     if (child == .none) return false;
-                    return child.toType().comptimeOnlyAdvanced(mod, opt_sema);
+                    return Type.fromInterned(child).comptimeOnlyAdvanced(mod, opt_sema);
                 },
-                .array_type => |array_type| return array_type.child.toType().comptimeOnlyAdvanced(mod, opt_sema),
-                .vector_type => |vector_type| return vector_type.child.toType().comptimeOnlyAdvanced(mod, opt_sema),
-                .opt_type => |child| return child.toType().comptimeOnlyAdvanced(mod, opt_sema),
-                .error_union_type => |error_union_type| return error_union_type.payload_type.toType().comptimeOnlyAdvanced(mod, opt_sema),
+                .array_type => |array_type| return Type.fromInterned(array_type.child).comptimeOnlyAdvanced(mod, opt_sema),
+                .vector_type => |vector_type| return Type.fromInterned(vector_type.child).comptimeOnlyAdvanced(mod, opt_sema),
+                .opt_type => |child| return Type.fromInterned(child).comptimeOnlyAdvanced(mod, opt_sema),
+                .error_union_type => |error_union_type| return Type.fromInterned(error_union_type.payload_type).comptimeOnlyAdvanced(mod, opt_sema),
 
                 .error_set_type,
                 .inferred_error_set_type,
@@ -2647,7 +2652,7 @@ pub const Type = struct {
                                 const i: u32 = @intCast(i_usize);
                                 if (struct_type.fieldIsComptime(ip, i)) continue;
                                 const field_ty = struct_type.field_types.get(ip)[i];
-                                if (try field_ty.toType().comptimeOnlyAdvanced(mod, opt_sema)) {
+                                if (try Type.fromInterned(field_ty).comptimeOnlyAdvanced(mod, opt_sema)) {
                                     // Note that this does not cause the layout to
                                     // be considered resolved. Comptime-only types
                                     // still maintain a layout of their
@@ -2666,7 +2671,7 @@ pub const Type = struct {
                 .anon_struct_type => |tuple| {
                     for (tuple.types.get(ip), tuple.values.get(ip)) |field_ty, val| {
                         const have_comptime_val = val != .none;
-                        if (!have_comptime_val and try field_ty.toType().comptimeOnlyAdvanced(mod, opt_sema)) return true;
+                        if (!have_comptime_val and try Type.fromInterned(field_ty).comptimeOnlyAdvanced(mod, opt_sema)) return true;
                     }
                     return false;
                 },
@@ -2689,7 +2694,7 @@ pub const Type = struct {
                         const union_obj = ip.loadUnionType(union_type);
                         for (0..union_obj.field_types.len) |field_idx| {
                             const field_ty = union_obj.field_types.get(ip)[field_idx];
-                            if (try field_ty.toType().comptimeOnlyAdvanced(mod, opt_sema)) {
+                            if (try Type.fromInterned(field_ty).comptimeOnlyAdvanced(mod, opt_sema)) {
                                 union_obj.flagsPtr(ip).requires_comptime = .yes;
                                 return true;
                             }
@@ -2702,7 +2707,7 @@ pub const Type = struct {
 
                 .opaque_type => false,
 
-                .enum_type => |enum_type| return enum_type.tag_ty.toType().comptimeOnlyAdvanced(mod, opt_sema),
+                .enum_type => |enum_type| return Type.fromInterned(enum_type.tag_ty).comptimeOnlyAdvanced(mod, opt_sema),
 
                 // values, not types
                 .undef,
@@ -2792,10 +2797,10 @@ pub const Type = struct {
     // Works for vectors and vectors of integers.
     pub fn minInt(ty: Type, mod: *Module, dest_ty: Type) !Value {
         const scalar = try minIntScalar(ty.scalarType(mod), mod, dest_ty.scalarType(mod));
-        return if (ty.zigTypeTag(mod) == .Vector) (try mod.intern(.{ .aggregate = .{
+        return if (ty.zigTypeTag(mod) == .Vector) Value.fromInterned((try mod.intern(.{ .aggregate = .{
             .ty = dest_ty.toIntern(),
             .storage = .{ .repeated_elem = scalar.toIntern() },
-        } })).toValue() else scalar;
+        } }))) else scalar;
     }
 
     /// Asserts that the type is an integer.
@@ -2821,10 +2826,10 @@ pub const Type = struct {
     /// The returned Value will have type dest_ty.
     pub fn maxInt(ty: Type, mod: *Module, dest_ty: Type) !Value {
         const scalar = try maxIntScalar(ty.scalarType(mod), mod, dest_ty.scalarType(mod));
-        return if (ty.zigTypeTag(mod) == .Vector) (try mod.intern(.{ .aggregate = .{
+        return if (ty.zigTypeTag(mod) == .Vector) Value.fromInterned((try mod.intern(.{ .aggregate = .{
             .ty = dest_ty.toIntern(),
             .storage = .{ .repeated_elem = scalar.toIntern() },
-        } })).toValue() else scalar;
+        } }))) else scalar;
     }
 
     /// The returned Value will have type dest_ty.
@@ -2865,8 +2870,8 @@ pub const Type = struct {
     /// Asserts the type is an enum or a union.
     pub fn intTagType(ty: Type, mod: *Module) Type {
         return switch (mod.intern_pool.indexToKey(ty.toIntern())) {
-            .union_type => |union_type| union_type.enum_tag_ty.toType().intTagType(mod),
-            .enum_type => |enum_type| enum_type.tag_ty.toType(),
+            .union_type => |union_type| Type.fromInterned(union_type.enum_tag_ty).intTagType(mod),
+            .enum_type => |enum_type| Type.fromInterned(enum_type.tag_ty),
             else => unreachable,
         };
     }
@@ -2965,12 +2970,12 @@ pub const Type = struct {
     pub fn structFieldType(ty: Type, index: usize, mod: *Module) Type {
         const ip = &mod.intern_pool;
         return switch (ip.indexToKey(ty.toIntern())) {
-            .struct_type => |struct_type| struct_type.field_types.get(ip)[index].toType(),
+            .struct_type => |struct_type| Type.fromInterned(struct_type.field_types.get(ip)[index]),
             .union_type => |union_type| {
                 const union_obj = ip.loadUnionType(union_type);
-                return union_obj.field_types.get(ip)[index].toType();
+                return Type.fromInterned(union_obj.field_types.get(ip)[index]);
             },
-            .anon_struct_type => |anon_struct| anon_struct.types.get(ip)[index].toType(),
+            .anon_struct_type => |anon_struct| Type.fromInterned(anon_struct.types.get(ip)[index]),
             else => unreachable,
         };
     }
@@ -2981,11 +2986,11 @@ pub const Type = struct {
             .struct_type => |struct_type| {
                 assert(struct_type.layout != .Packed);
                 const explicit_align = struct_type.fieldAlign(ip, index);
-                const field_ty = struct_type.field_types.get(ip)[index].toType();
+                const field_ty = Type.fromInterned(struct_type.field_types.get(ip)[index]);
                 return mod.structFieldAlignment(explicit_align, field_ty, struct_type.layout);
             },
             .anon_struct_type => |anon_struct| {
-                return anon_struct.types.get(ip)[index].toType().abiAlignment(mod);
+                return Type.fromInterned(anon_struct.types.get(ip)[index]).abiAlignment(mod);
             },
             .union_type => |union_type| {
                 const union_obj = ip.loadUnionType(union_type);
@@ -3002,13 +3007,13 @@ pub const Type = struct {
                 const val = struct_type.fieldInit(ip, index);
                 // TODO: avoid using `unreachable` to indicate this.
                 if (val == .none) return Value.@"unreachable";
-                return val.toValue();
+                return Value.fromInterned(val);
             },
             .anon_struct_type => |anon_struct| {
                 const val = anon_struct.values.get(ip)[index];
                 // TODO: avoid using `unreachable` to indicate this.
                 if (val == .none) return Value.@"unreachable";
-                return val.toValue();
+                return Value.fromInterned(val);
             },
             else => unreachable,
         }
@@ -3020,17 +3025,17 @@ pub const Type = struct {
             .struct_type => |struct_type| {
                 assert(struct_type.haveFieldInits(ip));
                 if (struct_type.fieldIsComptime(ip, index)) {
-                    return struct_type.field_inits.get(ip)[index].toValue();
+                    return Value.fromInterned(struct_type.field_inits.get(ip)[index]);
                 } else {
-                    return struct_type.field_types.get(ip)[index].toType().onePossibleValue(mod);
+                    return Type.fromInterned(struct_type.field_types.get(ip)[index]).onePossibleValue(mod);
                 }
             },
             .anon_struct_type => |tuple| {
                 const val = tuple.values.get(ip)[index];
                 if (val == .none) {
-                    return tuple.types.get(ip)[index].toType().onePossibleValue(mod);
+                    return Type.fromInterned(tuple.types.get(ip)[index]).onePossibleValue(mod);
                 } else {
-                    return val.toValue();
+                    return Value.fromInterned(val);
                 }
             },
             else => unreachable,
@@ -3066,17 +3071,17 @@ pub const Type = struct {
                 var big_align: Alignment = .none;
 
                 for (tuple.types.get(ip), tuple.values.get(ip), 0..) |field_ty, field_val, i| {
-                    if (field_val != .none or !field_ty.toType().hasRuntimeBits(mod)) {
+                    if (field_val != .none or !Type.fromInterned(field_ty).hasRuntimeBits(mod)) {
                         // comptime field
                         if (i == index) return offset;
                         continue;
                     }
 
-                    const field_align = field_ty.toType().abiAlignment(mod);
+                    const field_align = Type.fromInterned(field_ty).abiAlignment(mod);
                     big_align = big_align.max(field_align);
                     offset = field_align.forward(offset);
                     if (i == index) return offset;
-                    offset += field_ty.toType().abiSize(mod);
+                    offset += Type.fromInterned(field_ty).abiSize(mod);
                 }
                 offset = big_align.max(.@"1").forward(offset);
                 return offset;