Resolve peer types for array and tuple

Author: FnControlOption

src/analysis.zig

@@ -6298,6 +6298,35 @@ pub const ReferencedType = struct {
     };
 };
 
+const ArrayLike = struct {
+    len: u64,
+    /// `noreturn` indicates that this type is `struct{}` so can coerce to anything
+    elem_ty: Type,
+};
+fn arrayLikeFromStruct(analyser: *Analyser, ty: Type) ?ArrayLike {
+    std.debug.assert(ty.is_type_val);
+    return switch (ty.zigTypeTag(analyser).?) {
+        .@"struct" => {
+            if (ty.isNamespace()) return .{
+                .len = 0,
+                .elem_ty = Type.fromIP(analyser, .type_type, .noreturn_type),
+            };
+            if (ty.data != .tuple) return null;
+            const elem_ty = ty.data.tuple[0];
+            for (ty.data.tuple[1..]) |field_ty| {
+                if (!field_ty.eql(elem_ty)) {
+                    return null;
+                }
+            }
+            return .{
+                .len = ty.data.tuple.len,
+                .elem_ty = elem_ty,
+            };
+        },
+        else => null,
+    };
+}
+
 // Based on src/Sema.zig from the zig codebase
 // https://github.com/ziglang/zig/blob/master/src/Sema.zig
 fn resolvePeerTypesInner(analyser: *Analyser, peer_tys: []?Type) !?Type {
@@ -6423,7 +6452,78 @@ fn resolvePeerTypesInner(analyser: *Analyser, peer_tys: []?Type) !?Type {
             };
         },
 
-        .array => return null, // TODO
+        .array => {
+            var len: ?u64 = null;
+            var sentinel: InternPool.Index = .none;
+            var elem_ty: ?Type = null;
+
+            for (peer_tys) |*ty_ptr| {
+                const ty = ty_ptr.* orelse continue;
+
+                if (ty.data != .array) {
+                    const arr_like = analyser.arrayLikeFromStruct(ty) orelse {
+                        return null;
+                    };
+
+                    if (len) |cur_len| {
+                        if (arr_like.len != cur_len) return null;
+                    } else {
+                        len = arr_like.len;
+                    }
+
+                    sentinel = .none;
+
+                    continue;
+                }
+
+                const arr_info = ty.data.array;
+                const arr_len = arr_info.elem_count orelse {
+                    return null;
+                };
+
+                const cur_elem_ty = elem_ty orelse {
+                    if (len) |cur_len| {
+                        if (arr_len != cur_len) return null;
+                    } else {
+                        len = arr_len;
+                        sentinel = arr_info.sentinel;
+                    }
+                    elem_ty = arr_info.elem_ty.*;
+                    continue;
+                };
+
+                if (arr_info.elem_count != len) {
+                    return null;
+                }
+
+                const peer_elem_ty = arr_info.elem_ty.*;
+                if (!peer_elem_ty.eql(cur_elem_ty)) {
+                    // TODO: check if coercible
+                    return null;
+                }
+
+                if (sentinel != .none) {
+                    if (arr_info.sentinel != .none) {
+                        if (arr_info.sentinel != sentinel) sentinel = .none;
+                    } else {
+                        sentinel = .none;
+                    }
+                }
+            }
+
+            std.debug.assert(elem_ty != null);
+
+            return .{
+                .data = .{
+                    .array = .{
+                        .elem_count = len,
+                        .sentinel = sentinel,
+                        .elem_ty = try analyser.allocType(elem_ty.?),
+                    },
+                },
+                .is_type_val = true,
+            };
+        },
 
         .vector => return null, // TODO
 

tests/analysis/peer_type_resolution.zig

@@ -218,6 +218,14 @@ pub fn main() !void {
     _ = noreturn_1;
     //  ^^^^^^^^^^ (S)()
 
+    const coercible_array_0 = if (runtime_bool) [2]*const S{ &s, &s } else [2]?*const S{ &s, null };
+    _ = coercible_array_0;
+    //  ^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[2]?*const S`
+
+    const coercible_array_1 = if (runtime_bool) [2]?*const S{ &s, null } else [2]*const S{ &s, &s };
+    _ = coercible_array_1;
+    //  ^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[2]?*const S`
+
     // Use @compileLog to verify the expected type with the compiler:
     // @compileLog(error_union_0);
 
@@ -238,6 +246,18 @@ const comptime_float_error_union = if (comptime_bool) @as(error{A}!comptime_floa
 const null_error_union = if (comptime_bool) @as(error{A}!@TypeOf(null), null) else null;
 //    ^^^^^^^^^^^^^^^^ (error{A}!@TypeOf(null))()
 
+const array_2_and_array_3 = if (comptime_bool) [2]S{ s, s } else [3]S{ s, s, s };
+//    ^^^^^^^^^^^^^^^^^^^ (either type)()
+
+const tuple_2_and_array_3 = if (comptime_bool) @as(struct { S, S }, .{ s, s }) else [3]S{ s, s, s };
+//    ^^^^^^^^^^^^^^^^^^^ (either type)()
+
+const array_3_and_tuple_2 = if (comptime_bool) [3]S{ s, s, s } else @as(struct { S, S }, .{ s, s });
+//    ^^^^^^^^^^^^^^^^^^^ (either type)()
+
+const array_3_and_tuple_3 = if (comptime_bool) [3]S{ s, s, s } else @as(struct { S, S, S }, .{ s, s, s });
+//    ^^^^^^^^^^^^^^^^^^^ ([3]S)()
+
 const compile_error_0 = if (comptime_bool) s else @compileError("Foo");
 //    ^^^^^^^^^^^^^^^ (S)()