Resolve peer types for array and tuple

Author: FnControlOption

src/analysis.zig

@@ -6298,6 +6298,47 @@ 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 typeIsArrayLike(analyser: *Analyser, ty: Type) ?ArrayLike {
+    std.debug.assert(ty.is_type_val);
+    return switch (ty.data) {
+        .array => |info| .{
+            .len = info.elem_count orelse return null,
+            .elem_ty = info.elem_ty.*,
+        },
+        .ip_index => |payload| switch (payload.index orelse .unknown_type) {
+            .empty_struct_type => .{
+                .len = 0,
+                .elem_ty = Type.fromIP(analyser, .type_type, .noreturn_type),
+            },
+            else => |ip_index| switch (analyser.ip.indexToKey(ip_index)) {
+                .array_type => |info| .{
+                    .len = info.len,
+                    .elem_ty = Type.fromIP(analyser, .type_type, info.child),
+                },
+                else => null,
+            },
+        },
+        .tuple => |field_tys| {
+            const elem_ty = field_tys[0];
+            for (field_tys[1..]) |field_ty| {
+                if (!field_ty.eql(elem_ty)) {
+                    return null;
+                }
+            }
+            return .{
+                .len = field_tys.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 {
@@ -6544,7 +6585,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.typeIsArrayLike(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

@@ -7,9 +7,10 @@ const s: S = .{
     .float = 1.2,
 };
 
-pub fn main() !void {
-    var runtime_bool: bool = true;
+var runtime_bool: bool = true;
+var runtime_int: i32 = 0;
 
+pub fn main() !void {
     const widened_int_0 = if (runtime_bool) @as(i8, 0) else @as(i16, 0);
     _ = widened_int_0;
     //  ^^^^^^^^^^^^^ (i16)()
@@ -218,10 +219,16 @@ pub fn main() !void {
     _ = noreturn_1;
     //  ^^^^^^^^^^ (S)()
 
+    const coercible_array_0 = if (runtime_bool) [2]*i32{ &runtime_int, &runtime_int } else [2]?*i32{ &runtime_int, null };
+    _ = coercible_array_0;
+    //  ^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[2]?*i32`
+
+    const coercible_array_1 = if (runtime_bool) [2]?*i32{ &runtime_int, null } else [2]*i32{ &runtime_int, &runtime_int };
+    _ = coercible_array_1;
+    //  ^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[2]?*i32`
+
     // Use @compileLog to verify the expected type with the compiler:
     // @compileLog(error_union_0);
-
-    _ = &runtime_bool;
 }
 
 const comptime_bool: bool = true;
@@ -244,6 +251,18 @@ const f32_and_u32 = if (comptime_bool) @as(f32, 0) else @as(i32, 0);
 const u32_and_f32 = if (comptime_bool) @as(u32, 0) else @as(f32, 0);
 //    ^^^^^^^^^^^ (either type)()
 
+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)()