Commit 98c7aec4e4ae7deac5e802a8c592c2d91b6b77af | zig

author	Andrew Kelley <andrew@ziglang.org> 2023-07-23 22:57:11-07:00
committer	GitHub <noreply@github.com> 2023-07-23 22:57:11-07:00
log	98c7aec4e4ae7deac5e802a8c592c2d91b6b77af
tree	bfd94bd10785c542396a8c341b9bca8614719133
parent	23a806102a5a3d5b28b2e5ab5ec30e191daea6f4
parent	d92cca9324e71705af9134de70e1e995ba8aa57a
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #16518 from ziglang/fix-func-body

InternPool: fix handling of coerced function bodies

2 files changed, 56 insertions(+), 4 deletions(-)

src
- InternPool.zig
test
- behavior
  - generics.zig

src/InternPool.zig+36-4

 @@ -594,6 +594,13 @@ pub const Key = union(enum) {
         /// In the case of a generic function, this type will potentially have fewer parameters
         /// than the generic owner's type, because the comptime parameters will be deleted.
         ty: Index,
+        /// If this is a function body that has been coerced to a different type, for example
+        /// ```
+        /// fn f2() !void {}
+        /// const f: fn()anyerror!void = f2;
+        /// ```
+        /// then it contains the original type of the function body.
+        uncoerced_ty: Index,
         /// Index into extra array of the `FuncAnalysis` corresponding to this function.
         /// Used for mutating that data.
         analysis_extra_index: u32,
 @@ -990,11 +997,15 @@ pub const Key = union(enum) {
                 // otherwise we would get false negatives for interning generic
                 // function instances which have inferred error sets.
-                if (func.generic_owner == .none and func.resolved_error_set_extra_index == 0)
+                if (func.generic_owner == .none and func.resolved_error_set_extra_index == 0) {
-                    return Hash.hash(seed, asBytes(&func.owner_decl) ++ asBytes(&func.ty));
+                    const bytes = asBytes(&func.owner_decl) ++ asBytes(&func.ty) ++
+                        [1]u8{@intFromBool(func.uncoerced_ty == func.ty)};
+                    return Hash.hash(seed, bytes);
+                }
                 var hasher = Hash.init(seed);
                 std.hash.autoHash(&hasher, func.generic_owner);
+                std.hash.autoHash(&hasher, func.uncoerced_ty == func.ty);
                 for (func.comptime_args.get(ip)) |arg| std.hash.autoHash(&hasher, arg);
                 if (func.resolved_error_set_extra_index == 0) {
                     std.hash.autoHash(&hasher, func.ty);
 @@ -1122,6 +1133,12 @@ pub const Key = union(enum) {
                     )) return false;
                 }
+                if ((a_info.ty == a_info.uncoerced_ty) !=
+                    (b_info.ty == b_info.uncoerced_ty))
+                {
+                    return false;
+                }
                 if (a_info.ty == b_info.ty)
                     return true;
 @@ -3371,6 +3388,7 @@ fn extraFuncDecl(ip: *const InternPool, extra_index: u32) Key.Func {
     const func_decl = ip.extraDataTrail(P, extra_index);
     return .{
         .ty = func_decl.data.ty,
+        .uncoerced_ty = func_decl.data.ty,
         .analysis_extra_index = extra_index + std.meta.fieldIndex(P, "analysis").?,
         .zir_body_inst_extra_index = extra_index + std.meta.fieldIndex(P, "zir_body_inst").?,
         .resolved_error_set_extra_index = if (func_decl.data.analysis.inferred_error_set) func_decl.end else 0,
 @@ -3392,6 +3410,7 @@ fn extraFuncInstance(ip: *const InternPool, extra_index: u32) Key.Func {
     const func_decl = ip.funcDeclInfo(fi.data.generic_owner);
     return .{
         .ty = fi.data.ty,
+        .uncoerced_ty = fi.data.ty,
         .analysis_extra_index = extra_index + std.meta.fieldIndex(P, "analysis").?,
         .zir_body_inst_extra_index = func_decl.zir_body_inst_extra_index,
         .resolved_error_set_extra_index = if (fi.data.analysis.inferred_error_set) fi.end else 0,
 @@ -4800,6 +4819,8 @@ pub fn getFuncInstanceIes(
     assert(arg.bare_return_type != .none);
     for (arg.param_types) |param_type| assert(param_type != .none);
+    const generic_owner = unwrapCoercedFunc(ip, arg.generic_owner);
     // The strategy here is to add the function decl unconditionally, then to
     // ask if it already exists, and if so, revert the lengths of the mutated
     // arrays. This is similar to what `getOrPutTrailingString` does.
 @@ -4835,7 +4856,7 @@ pub fn getFuncInstanceIes(
         .owner_decl = undefined,
         .ty = func_ty,
         .branch_quota = 0,
-        .generic_owner = arg.generic_owner,
+        .generic_owner = generic_owner,
     });
     ip.extra.appendAssumeCapacity(@intFromEnum(Index.none)); // resolved error set
     ip.extra.appendSliceAssumeCapacity(@ptrCast(arg.comptime_args));
 @@ -4908,7 +4929,7 @@ pub fn getFuncInstanceIes(
     return finishFuncInstance(
         ip,
         gpa,
-        arg.generic_owner,
+        generic_owner,
         func_index,
         func_extra_index,
         arg.generation,
 @@ -7050,6 +7071,17 @@ pub fn funcIesResolved(ip: *const InternPool, func_index: Index) *Index {
     const extra_index = switch (tags[@intFromEnum(func_index)]) {
         .func_decl => func_start + @typeInfo(Tag.FuncDecl).Struct.fields.len,
         .func_instance => func_start + @typeInfo(Tag.FuncInstance).Struct.fields.len,
+        .func_coerced => i: {
+            const uncoerced_func_index: Index = @enumFromInt(ip.extra.items[
+                func_start + std.meta.fieldIndex(Tag.FuncCoerced, "func").?
+            ]);
+            const uncoerced_func_start = datas[@intFromEnum(uncoerced_func_index)];
+            break :i switch (tags[@intFromEnum(uncoerced_func_index)]) {
+                .func_decl => uncoerced_func_start + @typeInfo(Tag.FuncDecl).Struct.fields.len,
+                .func_instance => uncoerced_func_start + @typeInfo(Tag.FuncInstance).Struct.fields.len,
+                else => unreachable,
+            };
+        },
         else => unreachable,
     };
     return @ptrCast(&ip.extra.items[extra_index]);

test/behavior/generics.zig+20

...	@@ -456,3 +456,23 @@ test "return type of generic function is function pointer" {	...	@@ -456,3 +456,23 @@ test "return type of generic function is function pointer" {
456		456
457	try expect(null == S.b(void));	457	try expect(null == S.b(void));
458	}	458	}
		459
		460	test "coerced function body has inequal value with its uncoerced body" {
		461	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
		462	if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
		463
		464	const S = struct {
		465	const A = B(i32, c);
		466	fn c() !i32 {
		467	return 1234;
		468	}
		469	fn B(comptime T: type, comptime d: ?fn () anyerror!T) type {
		470	return struct {
		471	fn do() T {
		472	return d.?() catch @panic("fail");
		473	}
		474	};
		475	}
		476	};
		477	try expect(S.A.do() == 1234);
		478	}