Commit e8bcdca044603fb5ea93fc94028dfd8bdd22fcf3 | zig

author	Jacob Young <jacobly@ziglang.org> 2023-06-01 21:03:53-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2023-06-10 20:47:58-07:00
log	e8bcdca044603fb5ea93fc94028dfd8bdd22fcf3
tree	fb7beba9bb2b2264b94369d7be9ad058462ae537
parent	dc18739a738adc7fd549f9d43db2314275c51c03

Sema: fix in-memory coercion during comptime load

2 files changed, 29 insertions(+), 16 deletions(-)

src
- Sema.zig
- value.zig

src/Sema.zig+28-16

 @@ -22472,9 +22472,7 @@ fn analyzeMinMax(
             if (std.debug.runtime_safety) {
                 assert(try sema.intFitsInType(val, refined_ty, null));
             }
-            cur_minmax = try sema.addConstant(refined_ty, (try sema.resolveMaybeUndefVal(
+            cur_minmax = try sema.coerceInMemory(block, val, orig_ty, refined_ty, src);
-                try sema.coerceInMemory(block, val, orig_ty, refined_ty, src),
-            )).?);
         }
         break :refined refined_ty;
 @@ -26659,16 +26657,16 @@ fn coerceExtra(
     return sema.failWithOwnedErrorMsg(msg);
 }
-fn coerceInMemory(
+fn coerceValueInMemory(
     sema: *Sema,
     block: *Block,
     val: Value,
     src_ty: Type,
     dst_ty: Type,
     dst_ty_src: LazySrcLoc,
-) CompileError!Air.Inst.Ref {
+) CompileError!Value {
     const mod = sema.mod;
-    switch (mod.intern_pool.indexToKey(val.toIntern())) {
+    return switch (mod.intern_pool.indexToKey(val.toIntern())) {
         .aggregate => |aggregate| {
             const dst_ty_key = mod.intern_pool.indexToKey(dst_ty.toIntern());
             const dest_len = try sema.usizeCast(
 @@ -26688,14 +26686,14 @@ fn coerceInMemory(
                     else => unreachable,
                 };
                 if (src_ty_child != dst_ty_child) break :direct;
-                return try sema.addConstant(dst_ty, (try mod.intern(.{ .aggregate = .{
+                return (try mod.intern(.{ .aggregate = .{
                     .ty = dst_ty.toIntern(),
                     .storage = switch (aggregate.storage) {
                         .bytes => |bytes| .{ .bytes = bytes[0..dest_len] },
                         .elems => |elems| .{ .elems = elems[0..dest_len] },
                         .repeated_elem => |elem| .{ .repeated_elem = elem },
                     },
-                } })).toValue());
+                } })).toValue();
             }
             const dest_elems = try sema.arena.alloc(InternPool.Index, dest_len);
             for (dest_elems, 0..) |*dest_elem, i| {
 @@ -26712,17 +26710,28 @@ fn coerceInMemory(
                     .repeated_elem => |elem| elem,
                 }, elem_ty);
             }
-            return sema.addConstant(dst_ty, (try mod.intern(.{ .aggregate = .{
+            return (try mod.intern(.{ .aggregate = .{
                 .ty = dst_ty.toIntern(),
                 .storage = .{ .elems = dest_elems },
-            } })).toValue());
+            } })).toValue();
         },
-        .float => |float| return sema.addConstant(dst_ty, (try mod.intern(.{ .float = .{
+        .float => |float| (try mod.intern(.{ .float = .{
             .ty = dst_ty.toIntern(),
             .storage = float.storage,
-        } })).toValue()),
+        } })).toValue(),
-        else => return sema.addConstant(dst_ty, try mod.getCoerced(val, dst_ty)),
+        else => try mod.getCoerced(val, dst_ty),
-    }
+    };
+}
+fn coerceInMemory(
+    sema: *Sema,
+    block: *Block,
+    val: Value,
+    src_ty: Type,
+    dst_ty: Type,
+    dst_ty_src: LazySrcLoc,
+) CompileError!Air.Inst.Ref {
+    return sema.addConstant(dst_ty, try sema.coerceValueInMemory(block, val, src_ty, dst_ty, dst_ty_src));
 }
 const InMemoryCoercionResult = union(enum) {
 @@ -33935,8 +33944,11 @@ fn pointerDerefExtra(sema: *Sema, block: *Block, src: LazySrcLoc, ptr_val: Value
         if (coerce_in_mem_ok) {
             // We have a Value that lines up in virtual memory exactly with what we want to load,
             // and it is in-memory coercible to load_ty. It may be returned without modifications.
-            // Move mutable decl values to the InternPool and assert other decls are already in the InternPool.
+            // Move mutable decl values to the InternPool and assert other decls are already in
-            return .{ .val = (if (deref.is_mutable) try tv.val.intern(tv.ty, mod) else tv.val.toIntern()).toValue() };
+            // the InternPool.
+            const uncoerced_val = if (deref.is_mutable) try tv.val.intern(tv.ty, mod) else tv.val.toIntern();
+            const coerced_val = try sema.coerceValueInMemory(block, uncoerced_val.toValue(), tv.ty, load_ty, src);
+            return .{ .val = coerced_val };
         }
     }

src/value.zig+1

...	@@ -1842,6 +1842,7 @@ pub const Value = struct {	...	@@ -1842,6 +1842,7 @@ pub const Value = struct {
1842	pub fn elemValue(val: Value, mod: *Module, index: usize) Allocator.Error!Value {	1842	pub fn elemValue(val: Value, mod: *Module, index: usize) Allocator.Error!Value {
1843	return switch (val.ip_index) {	1843	return switch (val.ip_index) {
1844	.none => switch (val.tag()) {	1844	.none => switch (val.tag()) {
		1845	.bytes => try mod.intValue(Type.u8, val.castTag(.bytes).?.data[index]),
1845	.repeated => val.castTag(.repeated).?.data,	1846	.repeated => val.castTag(.repeated).?.data,
1846	.aggregate => val.castTag(.aggregate).?.data[index],	1847	.aggregate => val.castTag(.aggregate).?.data[index],
1847	.slice => val.castTag(.slice).?.data.ptr.elemValue(mod, index),	1848	.slice => val.castTag(.slice).?.data.ptr.elemValue(mod, index),