Resolve peer function types

Author: FnControlOption

src/analysis.zig

@@ -2279,6 +2279,7 @@ fn resolveTypeOfNodeUncached(analyser: *Analyser, options: ResolveOptions) error
             var buf: [1]Ast.Node.Index = undefined;
             const fn_proto = tree.fullFnProto(&buf, node).?;
 
+            // TODO: should we avoid calling innermostContainer if this is a function type?
             const container_type = options.container_type orelse try analyser.innermostContainer(handle, tree.tokenStart(fn_proto.ast.fn_token));
             const doc_comments = try getDocComments(analyser.arena, tree, node);
             const name = if (fn_proto.name_token) |t| tree.tokenSlice(t) else null;
@@ -3097,8 +3098,6 @@ pub const Type = struct {
                     }
                 },
                 .function => |info| {
-                    std.hash.autoHash(hasher, info.fn_token);
-                    hasher.update(info.handle.uri);
                     info.container_type.hashWithHasher(hasher);
                     for (info.parameters) |param| {
                         param.type.hashWithHasher(hasher);
@@ -3178,8 +3177,6 @@ pub const Type = struct {
                 },
                 .function => |a_info| {
                     const b_info = b.function;
-                    if (a_info.fn_token != b_info.fn_token) return false;
-                    if (!std.mem.eql(u8, a_info.handle.uri, b_info.handle.uri)) return false;
                     if (!a_info.container_type.eql(b_info.container_type.*)) return false;
                     if (a_info.parameters.len != b_info.parameters.len) return false;
                     for (a_info.parameters, b_info.parameters) |a_param, b_param| {
@@ -6962,7 +6959,25 @@ fn resolvePeerTypesInner(analyser: *Analyser, peer_tys: []?Type) !?Type {
             };
         },
 
-        .func => return null, // TODO
+        .func => {
+            var opt_cur_ty: ?Type = null;
+            for (peer_tys) |opt_ty| {
+                const ty = opt_ty orelse continue;
+                const cur_ty = opt_cur_ty orelse {
+                    opt_cur_ty = ty;
+                    continue;
+                };
+                if (ty.zigTypeTag(analyser).? != .@"fn") {
+                    return null;
+                }
+                if (cur_ty.eql(ty)) {
+                    continue;
+                }
+                // TODO: coerce function types
+                return null;
+            }
+            return opt_cur_ty.?;
+        },
 
         .enum_or_union => return null, // TODO
 

tests/analysis/peer_type_resolution.zig

@@ -221,6 +221,37 @@ pub fn main() !void {
     _ = noreturn_1;
     //  ^^^^^^^^^^ (S)()
 
+    const FnCoerce = struct {
+        fn errorsA() [2]error{A} {
+            return .{ error.A, error.A };
+        }
+        fn errorsAB() [2]error{ A, B } {
+            return .{ error.A, error.A };
+        }
+        fn pointers() [2]*const S {
+            return .{ &s, &s };
+        }
+        fn optionalPointers() [2]?*const S {
+            return .{ &s, null };
+        }
+    };
+
+    const fn_coerce_0 = if (runtime_bool) &FnCoerce.errorsA else &FnCoerce.errorsAB;
+    _ = fn_coerce_0;
+    //  ^^^^^^^^^^^ (either type)() TODO this should be `*const fn () [2]error{A,B}`
+
+    const fn_coerce_1 = if (runtime_bool) &FnCoerce.errorsAB else &FnCoerce.errorsA;
+    _ = fn_coerce_1;
+    //  ^^^^^^^^^^^ (either type)() TODO this should be `*const fn () [2]error{A,B}`
+
+    const fn_coerce_2 = if (runtime_bool) &FnCoerce.pointers else &FnCoerce.optionalPointers;
+    _ = fn_coerce_2;
+    //  ^^^^^^^^^^^ (either type)() TODO this should be `*const fn () [2]?*const S`
+
+    const fn_coerce_3 = if (runtime_bool) &FnCoerce.optionalPointers else &FnCoerce.pointers;
+    _ = fn_coerce_3;
+    //  ^^^^^^^^^^^ (either type)() TODO this should be `*const fn () [2]?*const S`
+
     // Use @compileLog to verify the expected type with the compiler:
     // @compileLog(error_union_0);
 
@@ -241,6 +272,11 @@ const optional_comptime_float = if (comptime_bool) @as(?comptime_float, 0) else
 const null_error_union = if (comptime_bool) @as(error{A}!@TypeOf(null), null) else null;
 //    ^^^^^^^^^^^^^^^^ (error{A}!@TypeOf(null))()
 
+fn void_fn() void {}
+
+const optional_fn = if (comptime_bool) @as(?fn () void, void_fn) else void_fn;
+//    ^^^^^^^^^^^ (?fn () void)()
+
 const f32_and_u32 = if (comptime_bool) @as(f32, 0) else @as(i32, 0);
 //    ^^^^^^^^^^^ (either type)()