Resolve peer types for C pointers

Author: FnControlOption

src/analysis.zig

@@ -3134,6 +3134,7 @@ pub const Type = struct {
                     const b_type = b.pointer;
                     if (a_type.size != b_type.size) return false;
                     if (a_type.sentinel != b_type.sentinel) return false;
+                    if (a_type.is_const != b_type.is_const) return false;
                     if (!a_type.elem_ty.eql(b_type.elem_ty.*)) return false;
                 },
                 .array => |a_type| {
@@ -4057,6 +4058,62 @@ pub const Type = struct {
         };
     }
 
+    const PointerInfo = struct {
+        elem_ty: Type,
+        sentinel: InternPool.Index,
+        flags: InternPool.Key.Pointer.Flags,
+    };
+
+    fn pointerInfo(ty: Type, analyser: *Analyser) ?PointerInfo {
+        if (!ty.is_type_val) return null;
+        return blk: switch (ty.data) {
+            .pointer => |info| .{
+                .elem_ty = info.elem_ty.*,
+                .sentinel = info.sentinel,
+                .flags = .{
+                    .size = info.size,
+                    .is_const = info.is_const,
+                },
+            },
+            .ip_index => |payload| switch (analyser.ip.indexToKey(payload.index orelse return null)) {
+                .pointer_type => |info| .{
+                    .elem_ty = Type.fromIP(analyser, .type_type, info.elem_type),
+                    .sentinel = info.sentinel,
+                    .flags = info.flags,
+                },
+                else => null,
+            },
+            .optional => |child| switch (child.data) {
+                .pointer => continue :blk child.data,
+                .ip_index => |payload| switch (analyser.ip.indexToKey(payload.index orelse return null)) {
+                    .pointer_type => continue :blk child.data,
+                    else => null,
+                },
+                else => null,
+            },
+            else => null,
+        };
+    }
+
+    fn isPointerAtRuntime(ty: Type, analyser: *Analyser) bool {
+        switch (ty.data) {
+            .optional => |child| {
+                const p = child.pointerInfo(analyser) orelse return false;
+                return switch (p.flags.size) {
+                    .slice, .c => false,
+                    .many, .one => !p.flags.is_allowzero,
+                };
+            },
+            else => {
+                const info = ty.pointerInfo(analyser) orelse return false;
+                return switch (info.flags.size) {
+                    .slice => false,
+                    .one, .many, .c => true,
+                };
+            },
+        }
+    }
+
     pub fn stringifyTypeOf(ty: Type, analyser: *Analyser, options: FormatOptions) error{OutOfMemory}![]const u8 {
         const typeof = try ty.typeOf(analyser);
         var aw: std.io.Writer.Allocating = .init(analyser.arena);
@@ -6648,7 +6705,64 @@ fn resolvePeerTypesInner(analyser: *Analyser, peer_tys: []?Type) !?Type {
 
         .vector => return null, // TODO
 
-        .c_ptr => return null, // TODO
+        .c_ptr => {
+            var opt_ptr_info: ?Type.PointerInfo = null;
+            for (peer_tys) |opt_ty| {
+                const ty = opt_ty orelse continue;
+                switch (ty.zigTypeTag(analyser).?) {
+                    .comptime_int => continue,
+                    .int => {
+                        const ptr_bits = builtin.target.ptrBitWidth();
+                        const bits = analyser.ip.intInfo(ty.data.ip_index.index.?, builtin.target).bits;
+                        if (bits >= ptr_bits) continue;
+                    },
+                    .null => continue,
+                    else => {},
+                }
+
+                if (!ty.isPointerAtRuntime(analyser)) {
+                    return null;
+                }
+
+                const peer_info = ty.pointerInfo(analyser).?;
+
+                var ptr_info = opt_ptr_info orelse {
+                    opt_ptr_info = peer_info;
+                    continue;
+                };
+
+                if (!ptr_info.elem_ty.eql(peer_info.elem_ty)) {
+                    // TODO: coerce C pointer element types
+                    return null;
+                }
+
+                if (ptr_info.flags.alignment != ptr_info.flags.alignment) {
+                    // TODO: find minimum C pointer alignment
+                    return null;
+                }
+
+                if (ptr_info.flags.address_space != peer_info.flags.address_space) {
+                    return null;
+                }
+
+                ptr_info.flags.is_const = ptr_info.flags.is_const or peer_info.flags.is_const;
+                ptr_info.flags.is_volatile = ptr_info.flags.is_volatile or peer_info.flags.is_volatile;
+
+                opt_ptr_info = ptr_info;
+            }
+            const info = opt_ptr_info.?;
+            return .{
+                .data = .{
+                    .pointer = .{
+                        .elem_ty = try analyser.allocType(info.elem_ty),
+                        .sentinel = .none,
+                        .size = .c,
+                        .is_const = info.flags.is_const,
+                    },
+                },
+                .is_type_val = true,
+            };
+        },
 
         .ptr => return null, // TODO
 

tests/analysis/peer_type_resolution.zig

@@ -226,6 +226,22 @@ pub fn main() !void {
     _ = coercible_array_1;
     //  ^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[2]?*const S`
 
+    const coercible_c_pointer_0 = if (runtime_bool) @as([*c]bool, &runtime_bool) else @as([*c]const bool, &comptime_bool);
+    _ = coercible_c_pointer_0;
+    //  ^^^^^^^^^^^^^^^^^^^^^ ([*c]const bool)()
+
+    const coercible_c_pointer_1 = if (runtime_bool) @as([*c]const bool, &comptime_bool) else @as([*c]bool, &runtime_bool);
+    _ = coercible_c_pointer_1;
+    //  ^^^^^^^^^^^^^^^^^^^^^ ([*c]const bool)()
+
+    const coercible_c_pointer_2 = if (runtime_bool) @as([*c]const *const u8, &&0) else @as([*c]const ?*const u8, &&0);
+    _ = coercible_c_pointer_2;
+    //  ^^^^^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[*c]const ?*const u8`
+
+    const coercible_c_pointer_3 = if (runtime_bool) @as([*c]const ?*const u8, &&0) else @as([*c]const *const u8, &&0);
+    _ = coercible_c_pointer_3;
+    //  ^^^^^^^^^^^^^^^^^^^^^ (either type)() TODO this should be `[*c]const ?*const u8`
+
     // Use @compileLog to verify the expected type with the compiler:
     // @compileLog(error_union_0);