Resolve peer types for functions

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;
@@ -3094,8 +3095,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);
@@ -3175,8 +3174,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| {
@@ -7014,7 +7011,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

@@ -230,6 +230,23 @@ pub fn main() !void {
     _ = coercible_array_1;
     //  ^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[2]?*i32`
 
+    const CoercibleFunctions = struct {
+        fn a() [2]*const S {
+            return .{ &s, &s };
+        }
+        fn b() [2]?*const S {
+            return .{ &s, null };
+        }
+    };
+
+    const coercible_function_0 = if (runtime_bool) &CoercibleFunctions.a else &CoercibleFunctions.b;
+    _ = coercible_function_0;
+    //  ^^^^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `*const fn () [2]?*const S`
+
+    const coercible_function_1 = if (runtime_bool) &CoercibleFunctions.b else &CoercibleFunctions.a;
+    _ = coercible_function_1;
+    //  ^^^^^^^^^^^^^^^^^^^^ (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);
 }
@@ -248,6 +265,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)()