Commit b6abe1dbf7b5ad14ad1b0a011f109694fd5f36a8 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2025-01-16 10:09:41+00:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2025-01-16 12:49:48+00:00
log	b6abe1dbf7b5ad14ad1b0a011f109694fd5f36a8
tree	5dc848161f3765e7af2923d67bc3b1e0eb070a83
parent	d00e05f18609921c1a051a637c24e47cfa304243
signature	Commit is signed but in an unrecognized format.

compiler: make it easier to apply breaking changes to `std.builtin`

Documentation for this will be on the wiki shortly.

Resolves: #21842

6 files changed, 151 insertions(+), 67 deletions(-)

bootstrap.c
build.zig
src
stage1
- config.zig.in

bootstrap.c+1

...	@@ -141,6 +141,7 @@ int main(int argc, char **argv) {	...	@@ -141,6 +141,7 @@ int main(int argc, char **argv) {
141	"pub const skip_non_native = false;\n"	141	"pub const skip_non_native = false;\n"
142	"pub const force_gpa = false;\n"	142	"pub const force_gpa = false;\n"
143	"pub const dev = .core;\n"	143	"pub const dev = .core;\n"
		144	"pub const value_interpret_mode = .direct;\n"
144	, zig_version);	145	, zig_version);
145	if (written < 100)	146	if (written < 100)
146	panic("unable to write to config.zig file");	147	panic("unable to write to config.zig file");

build.zig+20

 @@ -9,6 +9,7 @@ const fs = std.fs;
 const InstallDirectoryOptions = std.Build.InstallDirectoryOptions;
 const assert = std.debug.assert;
 const DevEnv = @import("src/dev.zig").Env;
+const ValueInterpretMode = enum { direct, by_name };
 const zig_version: std.SemanticVersion = .{ .major = 0, .minor = 14, .patch = 0 };
 const stack_size = 46 * 1024 * 1024;
 @@ -177,6 +178,7 @@ pub fn build(b: *std.Build) !void {
     const strip = b.option(bool, "strip", "Omit debug information");
     const valgrind = b.option(bool, "valgrind", "Enable valgrind integration");
     const pie = b.option(bool, "pie", "Produce a Position Independent Executable");
+    const value_interpret_mode = b.option(ValueInterpretMode, "value-interpret-mode", "How the compiler translates between 'std.builtin' types and its internal datastructures") orelse .direct;
     const value_tracing = b.option(bool, "value-tracing", "Enable extra state tracking to help troubleshoot bugs in the compiler (using the std.debug.Trace API)") orelse false;
     const mem_leak_frames: u32 = b.option(u32, "mem-leak-frames", "How many stack frames to print when a memory leak occurs. Tests get 2x this amount.") orelse blk: {
 @@ -234,6 +236,7 @@ pub fn build(b: *std.Build) !void {
     exe_options.addOption(bool, "llvm_has_xtensa", llvm_has_xtensa);
     exe_options.addOption(bool, "force_gpa", force_gpa);
     exe_options.addOption(DevEnv, "dev", b.option(DevEnv, "dev", "Build a compiler with a reduced feature set for development of specific features") orelse if (only_c) .bootstrap else .full);
+    exe_options.addOption(ValueInterpretMode, "value_interpret_mode", value_interpret_mode);
     if (link_libc) {
         exe.root_module.link_libc = true;
 @@ -620,6 +623,23 @@ fn addWasiUpdateStep(b: *std.Build, version: [:0]const u8) !void {
     exe_options.addOption(bool, "value_tracing", false);
     exe_options.addOption(DevEnv, "dev", .bootstrap);
+    // zig1 chooses to interpret values by name. The tradeoff is as follows:
+    //
+    // * We lose a small amount of performance. This is essentially irrelevant for zig1.
+    //
+    // * We lose the ability to perform trivial renames on certain `std.builtin` types without
+    //   zig1.wasm updates. For instance, we cannot rename an enum from PascalCase fields to
+    //   snake_case fields without an update.
+    //
+    // * We gain the ability to add and remove fields to and from `std.builtin` types without
+    //   zig1.wasm updates. For instance, we can add a new tag to `CallingConvention` without
+    //   an update.
+    //
+    // Because field renames only happen when we apply a breaking change to the language (which
+    // is becoming progressively rarer), but tags may be added to or removed from target-dependent
+    // types over time in response to new targets coming into use, we gain more than we lose here.
+    exe_options.addOption(ValueInterpretMode, "value_interpret_mode", .by_name);
     const run_opt = b.addSystemCommand(&.{
         "wasm-opt",
         "-Oz",

src/Sema.zig+29-40

 @@ -2713,8 +2713,18 @@ fn analyzeValueAsCallconv(
     src: LazySrcLoc,
     unresolved_val: Value,
 ) !std.builtin.CallingConvention {
+    return interpretBuiltinType(sema, block, src, unresolved_val, std.builtin.CallingConvention);
+}
+fn interpretBuiltinType(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    unresolved_val: Value,
+    comptime T: type,
+) !T {
     const resolved_val = try sema.resolveLazyValue(unresolved_val);
-    return resolved_val.interpret(std.builtin.CallingConvention, sema.pt) catch |err| switch (err) {
+    return resolved_val.interpret(T, sema.pt) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
         error.UndefinedValue => return sema.failWithUseOfUndef(block, src),
         error.TypeMismatch => @panic("std.builtin is corrupt"),
 @@ -21536,19 +21546,8 @@ fn zirReify(
         .@"anyframe" => return sema.failWithUseOfAsync(block, src),
         .enum_literal => return .enum_literal_type,
         .int => {
-            const struct_type = ip.loadStructType(ip.typeOf(union_val.val));
+            const int = try sema.interpretBuiltinType(block, operand_src, .fromInterned(union_val.val), std.builtin.Type.Int);
-            const signedness_val = try Value.fromInterned(union_val.val).fieldValue(
+            const ty = try pt.intType(int.signedness, int.bits);
-                pt,
-                struct_type.nameIndex(ip, try ip.getOrPutString(gpa, pt.tid, "signedness", .no_embedded_nulls)).?,
-            );
-            const bits_val = try Value.fromInterned(union_val.val).fieldValue(
-                pt,
-                struct_type.nameIndex(ip, try ip.getOrPutString(gpa, pt.tid, "bits", .no_embedded_nulls)).?,
-            );
-            const signedness = zcu.toEnum(std.builtin.Signedness, signedness_val);
-            const bits: u16 = @intCast(try bits_val.toUnsignedIntSema(pt));
-            const ty = try pt.intType(signedness, bits);
             return Air.internedToRef(ty.toIntern());
         },
         .vector => {
 @@ -21574,20 +21573,15 @@ fn zirReify(
             return Air.internedToRef(ty.toIntern());
         },
         .float => {
-            const struct_type = ip.loadStructType(ip.typeOf(union_val.val));
+            const float = try sema.interpretBuiltinType(block, operand_src, .fromInterned(union_val.val), std.builtin.Type.Float);
-            const bits_val = try Value.fromInterned(union_val.val).fieldValue(pt, struct_type.nameIndex(
-                ip,
-                try ip.getOrPutString(gpa, pt.tid, "bits", .no_embedded_nulls),
-            ).?);
-            const bits: u16 = @intCast(try bits_val.toUnsignedIntSema(pt));
+            const ty = switch (float.bits) {
-            const ty = switch (bits) {
                 16 => Type.f16,
                 32 => Type.f32,
                 64 => Type.f64,
                 80 => Type.f80,
                 128 => Type.f128,
-                else => return sema.fail(block, src, "{}-bit float unsupported", .{bits}),
+                else => return sema.fail(block, src, "{}-bit float unsupported", .{float.bits}),
             };
             return Air.internedToRef(ty.toIntern());
         },
 @@ -21641,7 +21635,7 @@ fn zirReify(
                 try elem_ty.resolveLayout(pt);
             }
-            const ptr_size = zcu.toEnum(std.builtin.Type.Pointer.Size, size_val);
+            const ptr_size = try sema.interpretBuiltinType(block, operand_src, size_val, std.builtin.Type.Pointer.Size);
             const actual_sentinel: InternPool.Index = s: {
                 if (!sentinel_val.isNull(zcu)) {
 @@ -21691,7 +21685,7 @@ fn zirReify(
                     .is_const = is_const_val.toBool(),
                     .is_volatile = is_volatile_val.toBool(),
                     .alignment = abi_align,
-                    .address_space = zcu.toEnum(std.builtin.AddressSpace, address_space_val),
+                    .address_space = try sema.interpretBuiltinType(block, operand_src, address_space_val, std.builtin.AddressSpace),
                     .is_allowzero = is_allowzero_val.toBool(),
                 },
             });
 @@ -21813,7 +21807,7 @@ fn zirReify(
                 try ip.getOrPutString(gpa, pt.tid, "is_tuple", .no_embedded_nulls),
             ).?);
-            const layout = zcu.toEnum(std.builtin.Type.ContainerLayout, layout_val);
+            const layout = try sema.interpretBuiltinType(block, operand_src, layout_val, std.builtin.Type.ContainerLayout);
             // Decls
             if (try decls_val.sliceLen(pt) > 0) {
 @@ -21929,7 +21923,7 @@ fn zirReify(
             if (try decls_val.sliceLen(pt) > 0) {
                 return sema.fail(block, src, "reified unions must have no decls", .{});
             }
-            const layout = zcu.toEnum(std.builtin.Type.ContainerLayout, layout_val);
+            const layout = try sema.interpretBuiltinType(block, operand_src, layout_val, std.builtin.Type.ContainerLayout);
             const fields_arr = try sema.derefSliceAsArray(block, operand_src, fields_val, .{ .simple = .union_fields });
 @@ -24456,7 +24450,7 @@ fn resolveExportOptions(
     const linkage_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "linkage", .no_embedded_nulls), linkage_src);
     const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_operand, .{ .simple = .export_options });
-    const linkage = zcu.toEnum(std.builtin.GlobalLinkage, linkage_val);
+    const linkage = try sema.interpretBuiltinType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage);
     const section_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "section", .no_embedded_nulls), section_src);
     const section_opt_val = try sema.resolveConstDefinedValue(block, section_src, section_operand, .{ .simple = .export_options });
 @@ -24467,7 +24461,7 @@ fn resolveExportOptions(
     const visibility_operand = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "visibility", .no_embedded_nulls), visibility_src);
     const visibility_val = try sema.resolveConstDefinedValue(block, visibility_src, visibility_operand, .{ .simple = .export_options });
-    const visibility = zcu.toEnum(std.builtin.SymbolVisibility, visibility_val);
+    const visibility = try sema.interpretBuiltinType(block, visibility_src, visibility_val, std.builtin.SymbolVisibility);
     if (name.len < 1) {
         return sema.fail(block, name_src, "exported symbol name cannot be empty", .{});
 @@ -24495,12 +24489,11 @@ fn resolveBuiltinEnum(
     comptime name: Zcu.BuiltinDecl,
     reason: ComptimeReason,
 ) CompileError!@field(std.builtin, @tagName(name)) {
-    const pt = sema.pt;
     const ty = try sema.getBuiltinType(src, name);
     const air_ref = try sema.resolveInst(zir_ref);
     const coerced = try sema.coerce(block, ty, air_ref, src);
     const val = try sema.resolveConstDefinedValue(block, src, coerced, reason);
-    return pt.zcu.toEnum(@field(std.builtin, @tagName(name)), val);
+    return sema.interpretBuiltinType(block, src, val, @field(std.builtin, @tagName(name)));
 }
 fn resolveAtomicOrder(
 @@ -25293,7 +25286,7 @@ fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
     const air_ref = try sema.resolveInst(extra.modifier);
     const modifier_ref = try sema.coerce(block, modifier_ty, air_ref, modifier_src);
     const modifier_val = try sema.resolveConstDefinedValue(block, modifier_src, modifier_ref, .{ .simple = .call_modifier });
-    var modifier = zcu.toEnum(std.builtin.CallModifier, modifier_val);
+    var modifier = try sema.interpretBuiltinType(block, modifier_src, modifier_val, std.builtin.CallModifier);
     switch (modifier) {
         // These can be upgraded to comptime or nosuspend calls.
         .auto, .never_tail, .no_async => {
 @@ -26468,9 +26461,9 @@ fn resolvePrefetchOptions(
     const cache_val = try sema.resolveConstDefinedValue(block, cache_src, cache, .{ .simple = .prefetch_options });
     return std.builtin.PrefetchOptions{
-        .rw = zcu.toEnum(std.builtin.PrefetchOptions.Rw, rw_val),
+        .rw = try sema.interpretBuiltinType(block, rw_src, rw_val, std.builtin.PrefetchOptions.Rw),
         .locality = @intCast(try locality_val.toUnsignedIntSema(pt)),
-        .cache = zcu.toEnum(std.builtin.PrefetchOptions.Cache, cache_val),
+        .cache = try sema.interpretBuiltinType(block, cache_src, cache_val, std.builtin.PrefetchOptions.Cache),
     };
 }
 @@ -26536,7 +26529,7 @@ fn resolveExternOptions(
     const linkage_ref = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "linkage", .no_embedded_nulls), linkage_src);
     const linkage_val = try sema.resolveConstDefinedValue(block, linkage_src, linkage_ref, .{ .simple = .extern_options });
-    const linkage = zcu.toEnum(std.builtin.GlobalLinkage, linkage_val);
+    const linkage = try sema.interpretBuiltinType(block, linkage_src, linkage_val, std.builtin.GlobalLinkage);
     const is_thread_local = try sema.fieldVal(block, src, options, try ip.getOrPutString(gpa, pt.tid, "is_thread_local", .no_embedded_nulls), thread_local_src);
     const is_thread_local_val = try sema.resolveConstDefinedValue(block, thread_local_src, is_thread_local, .{ .simple = .extern_options });
 @@ -26770,9 +26763,6 @@ fn zirInplaceArithResultTy(sema: *Sema, extended: Zir.Inst.Extended.InstData) Co
 }
 fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
     const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data;
     const uncoerced_hint = try sema.resolveInst(extra.operand);
     const operand_src = block.builtinCallArgSrc(extra.node, 0);
 @@ -26784,7 +26774,7 @@ fn zirBranchHint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat
     // We only apply the first hint in a branch.
     // This allows user-provided hints to override implicit cold hints.
     if (sema.branch_hint == null) {
-        sema.branch_hint = zcu.toEnum(std.builtin.BranchHint, hint_val);
+        sema.branch_hint = try sema.interpretBuiltinType(block, operand_src, hint_val, std.builtin.BranchHint);
     }
 }
 @@ -37136,11 +37126,10 @@ pub fn analyzeAsAddressSpace(
     ctx: AddressSpaceContext,
 ) !std.builtin.AddressSpace {
     const pt = sema.pt;
-    const zcu = pt.zcu;
     const addrspace_ty = try sema.getBuiltinType(src, .AddressSpace);
     const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
     const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{ .simple = .@"addrspace" });
-    const address_space = zcu.toEnum(std.builtin.AddressSpace, addrspace_val);
+    const address_space = try sema.interpretBuiltinType(block, src, addrspace_val, std.builtin.AddressSpace);
     const target = pt.zcu.getTarget();
     const arch = target.cpu.arch;

src/Value.zig+100-23

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	const std = @import("std");	1	const std = @import("std");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
		3	const build_options = @import("build_options");
3	const Type = @import("Type.zig");	4	const Type = @import("Type.zig");
4	const assert = std.debug.assert;	5	const assert = std.debug.assert;
5	const BigIntConst = std.math.big.int.Const;	6	const BigIntConst = std.math.big.int.Const;
...	@@ -4531,6 +4532,20 @@ pub fn resolveLazy(	...	@@ -4531,6 +4532,20 @@ pub fn resolveLazy(
4531	}	4532	}
4532	}	4533	}
4533		4534
		4535	const InterpretMode = enum {
		4536	/// In this mode, types are assumed to match what the compiler was built with in terms of field
		4537	/// order, field types, etc. This improves compiler performance. However, it means that certain
		4538	/// modifications to `std.builtin` will result in compiler crashes.
		4539	direct,
		4540	/// In this mode, various details of the type are allowed to differ from what the compiler was built
		4541	/// with. Fields are matched by name rather than index; added struct fields are ignored, and removed
		4542	/// struct fields use their default value if one exists. This is slower than `.direct`, but permits
		4543	/// making certain changes to `std.builtin` (in particular reordering/adding/removing fields), so it
		4544	/// is useful when applying breaking changes.
		4545	by_name,
		4546	};
		4547	const interpret_mode: InterpretMode = @field(InterpretMode, @tagName(build_options.value_interpret_mode));
		4548
4534	/// Given a `Value` representing a comptime-known value of type `T`, unwrap it into an actual `T` known to the compiler.	4549	/// Given a `Value` representing a comptime-known value of type `T`, unwrap it into an actual `T` known to the compiler.
4535	/// This is useful for accessing `std.builtin` structures received from comptime logic.	4550	/// This is useful for accessing `std.builtin` structures received from comptime logic.
4536	/// `val` must be fully resolved.	4551	/// `val` must be fully resolved.
...	@@ -4583,11 +4598,20 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe	...	@@ -4583,11 +4598,20 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe
4583	else	4598	else
4584	null,	4599	null,
4585		4600
4586	.@"enum" => zcu.toEnum(T, val),	4601	.@"enum" => switch (interpret_mode) {
		4602	.direct => {
		4603	const int = val.getUnsignedInt(zcu) orelse return error.TypeMismatch;
		4604	return std.meta.intToEnum(T, int) catch error.TypeMismatch;
		4605	},
		4606	.by_name => {
		4607	const field_index = ty.enumTagFieldIndex(val, zcu) orelse return error.TypeMismatch;
		4608	const field_name = ty.enumFieldName(field_index, zcu);
		4609	return std.meta.stringToEnum(T, field_name.toSlice(ip)) orelse error.TypeMismatch;
		4610	},
		4611	},
4587		4612
4588	.@"union" => \|@"union"\| {	4613	.@"union" => \|@"union"\| {
4589	const union_obj = zcu.typeToUnion(ty) orelse return error.TypeMismatch;	4614	// No need to handle `interpret_mode`, because the `.@"enum"` handling already deals with it.
4590	if (union_obj.field_types.len != @"union".fields.len) return error.TypeMismatch;
4591	const tag_val = val.unionTag(zcu) orelse return error.TypeMismatch;	4615	const tag_val = val.unionTag(zcu) orelse return error.TypeMismatch;
4592	const tag = try tag_val.interpret(@"union".tag_type.?, pt);	4616	const tag = try tag_val.interpret(@"union".tag_type.?, pt);
4593	return switch (tag) {	4617	return switch (tag) {
...	@@ -4599,14 +4623,31 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe	...	@@ -4599,14 +4623,31 @@ pub fn interpret(val: Value, comptime T: type, pt: Zcu.PerThread) error{ OutOfMe
4599	};	4623	};
4600	},	4624	},
4601		4625
4602	.@"struct" => \|@"struct"\| {	4626	.@"struct" => \|@"struct"\| switch (interpret_mode) {
4603	if (ty.structFieldCount(zcu) != @"struct".fields.len) return error.TypeMismatch;	4627	.direct => {
4604	var result: T = undefined;	4628	if (ty.structFieldCount(zcu) != @"struct".fields.len) return error.TypeMismatch;
4605	inline for (@"struct".fields, 0..) \|field, field_idx\| {	4629	var result: T = undefined;
4606	const field_val = try val.fieldValue(pt, field_idx);	4630	inline for (@"struct".fields, 0..) \|field, field_idx\| {
4607	@field(result, field.name) = try field_val.interpret(field.type, pt);	4631	const field_val = try val.fieldValue(pt, field_idx);
4608	}	4632	@field(result, field.name) = try field_val.interpret(field.type, pt);
4609	return result;	4633	}
		4634	return result;
		4635	},
		4636	.by_name => {
		4637	const struct_obj = zcu.typeToStruct(ty) orelse return error.TypeMismatch;
		4638	var result: T = undefined;
		4639	inline for (@"struct".fields) \|field\| {
		4640	const field_name_ip = try ip.getOrPutString(zcu.gpa, pt.tid, field.name, .no_embedded_nulls);
		4641	@field(result, field.name) = if (struct_obj.nameIndex(ip, field_name_ip)) \|field_idx\| f: {
		4642	const field_val = try val.fieldValue(pt, field_idx);
		4643	break :f try field_val.interpret(field.type, pt);
		4644	} else if (field.default_value) \|ptr\| f: {
		4645	const typed_ptr: *const field.type = @ptrCast(@alignCast(ptr));
		4646	break :f typed_ptr.*;
		4647	} else return error.TypeMismatch;
		4648	}
		4649	return result;
		4650	},
4610	},	4651	},
4611	};	4652	};
4612	}	4653	}
...	@@ -4618,6 +4659,7 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory	...	@@ -4618,6 +4659,7 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory
4618	const T = @TypeOf(val);	4659	const T = @TypeOf(val);
4619		4660
4620	const zcu = pt.zcu;	4661	const zcu = pt.zcu;
		4662	const ip = &zcu.intern_pool;
4621	if (ty.zigTypeTag(zcu) != @typeInfo(T)) return error.TypeMismatch;	4663	if (ty.zigTypeTag(zcu) != @typeInfo(T)) return error.TypeMismatch;
4622		4664
4623	return switch (@typeInfo(T)) {	4665	return switch (@typeInfo(T)) {
...	@@ -4657,9 +4699,17 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory	...	@@ -4657,9 +4699,17 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory
4657	else	4699	else
4658	try pt.nullValue(ty),	4700	try pt.nullValue(ty),
4659		4701
4660	.@"enum" => try pt.enumValue(ty, (try uninterpret(@intFromEnum(val), ty.intTagType(zcu), pt)).toIntern()),	4702	.@"enum" => switch (interpret_mode) {
		4703	.direct => try pt.enumValue(ty, (try uninterpret(@intFromEnum(val), ty.intTagType(zcu), pt)).toIntern()),
		4704	.by_name => {
		4705	const field_name_ip = try ip.getOrPutString(zcu.gpa, pt.tid, @tagName(val), .no_embedded_nulls);
		4706	const field_idx = ty.enumFieldIndex(field_name_ip, zcu) orelse return error.TypeMismatch;
		4707	return pt.enumValueFieldIndex(ty, field_idx);
		4708	},
		4709	},
4661		4710
4662	.@"union" => \|@"union"\| {	4711	.@"union" => \|@"union"\| {
		4712	// No need to handle `interpret_mode`, because the `.@"enum"` handling already deals with it.
4663	const tag: @"union".tag_type.? = val;	4713	const tag: @"union".tag_type.? = val;
4664	const tag_val = try uninterpret(tag, ty.unionTagType(zcu).?, pt);	4714	const tag_val = try uninterpret(tag, ty.unionTagType(zcu).?, pt);
4665	const field_ty = ty.unionFieldType(tag_val, zcu) orelse return error.TypeMismatch;	4715	const field_ty = ty.unionFieldType(tag_val, zcu) orelse return error.TypeMismatch;
...	@@ -4672,17 +4722,44 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory	...	@@ -4672,17 +4722,44 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory
4672	};	4722	};
4673	},	4723	},
4674		4724
4675	.@"struct" => \|@"struct"\| {	4725	.@"struct" => \|@"struct"\| switch (interpret_mode) {
4676	if (ty.structFieldCount(zcu) != @"struct".fields.len) return error.TypeMismatch;	4726	.direct => {
4677	var field_vals: [@"struct".fields.len]InternPool.Index = undefined;	4727	if (ty.structFieldCount(zcu) != @"struct".fields.len) return error.TypeMismatch;
4678	inline for (&field_vals, @"struct".fields, 0..) \|*field_val, field, field_idx\| {	4728	var field_vals: [@"struct".fields.len]InternPool.Index = undefined;
4679	const field_ty = ty.fieldType(field_idx, zcu);	4729	inline for (&field_vals, @"struct".fields, 0..) \|*field_val, field, field_idx\| {
4680	field_val.* = (try uninterpret(@field(val, field.name), field_ty, pt)).toIntern();	4730	const field_ty = ty.fieldType(field_idx, zcu);
4681	}	4731	field_val.* = (try uninterpret(@field(val, field.name), field_ty, pt)).toIntern();
4682	return .fromInterned(try pt.intern(.{ .aggregate = .{	4732	}
4683	.ty = ty.toIntern(),	4733	return .fromInterned(try pt.intern(.{ .aggregate = .{
4684	.storage = .{ .elems = &field_vals },	4734	.ty = ty.toIntern(),
4685	} }));	4735	.storage = .{ .elems = &field_vals },
		4736	} }));
		4737	},
		4738	.by_name => {
		4739	const struct_obj = zcu.typeToStruct(ty) orelse return error.TypeMismatch;
		4740	const want_fields_len = struct_obj.field_types.len;
		4741	const field_vals = try zcu.gpa.alloc(InternPool.Index, want_fields_len);
		4742	defer zcu.gpa.free(field_vals);
		4743	@memset(field_vals, .none);
		4744	inline for (@"struct".fields) \|field\| {
		4745	const field_name_ip = try ip.getOrPutString(zcu.gpa, pt.tid, field.name, .no_embedded_nulls);
		4746	if (struct_obj.nameIndex(ip, field_name_ip)) \|field_idx\| {
		4747	const field_ty = ty.fieldType(field_idx, zcu);
		4748	field_vals[field_idx] = (try uninterpret(@field(val, field.name), field_ty, pt)).toIntern();
		4749	}
		4750	}
		4751	for (field_vals, 0..) \|*field_val, field_idx\| {
		4752	if (field_val.* == .none) {
		4753	const default_init = struct_obj.field_inits.get(ip)[field_idx];
		4754	if (default_init == .none) return error.TypeMismatch;
		4755	field_val.* = default_init;
		4756	}
		4757	}
		4758	return .fromInterned(try pt.intern(.{ .aggregate = .{
		4759	.ty = ty.toIntern(),
		4760	.storage = .{ .elems = field_vals },
		4761	} }));
		4762	},
4686	},	4763	},
4687	};	4764	};
4688	}	4765	}

src/Zcu.zig-4

 @@ -3486,10 +3486,6 @@ pub fn funcInfo(zcu: *const Zcu, func_index: InternPool.Index) InternPool.Key.Fu
     return zcu.intern_pool.toFunc(func_index);
 }
-pub fn toEnum(zcu: *const Zcu, comptime E: type, val: Value) E {
-    return zcu.intern_pool.toEnum(E, val.toIntern());
-}
 pub const UnionLayout = struct {
     abi_size: u64,
     abi_align: Alignment,

stage1/config.zig.in+1

...	@@ -13,3 +13,4 @@ pub const value_tracing = false;	...	@@ -13,3 +13,4 @@ pub const value_tracing = false;
13	pub const skip_non_native = false;	13	pub const skip_non_native = false;
14	pub const force_gpa = false;	14	pub const force_gpa = false;
15	pub const dev = .core;	15	pub const dev = .core;
		16	pub const value_interpret_mode = .direct;