refactor: clarify diagnostics and adopt ptrcast inference

std/io/file.hon

@@ -84,7 +84,7 @@ writer proc(file File) Writer {
         .read_write: flags = c.O_RDWR
     }
     while true {
-        fd c_int :: c.open(ptrcast!(c_char, path.ptr), flags)
+        fd c_int :: c.open(ptrcast!(path.ptr), flags)
         if (fd >= 0) return Handle{ file_desc = fd }
         if (c.__error()?^ != c.EINTR) return .open_failed
     }

std/io/io.hon

@@ -336,7 +336,7 @@ format_field_name proc($T type, index usize) []u8 {
 
 @hide:file
 distinct_value proc($Backing, $Distinct type, value Distinct) Backing {
-    return ptrcast!(Backing, &value)^
+    return ptrcast!(@Backing, &value)^
 }
 
 @hide:file
@@ -375,12 +375,12 @@ write_float proc(output Writer, $T type, value T, scientific bool) void ! WriteE
             buffer [64]mut u8 := undefined
             count := 0
             if sizeof!(T) == 4 {
-                if (scientific) count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.8e", value)
-                else count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.9g", value)
+                if (scientific) count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.8e", value)
+                else count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.9g", value)
             } else if scientific {
-                count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.16e", value)
+                count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.16e", value)
             } else {
-                count = c.snprintf(ptrcast!(c_char, (&buffer).ptr), c_ulong(buffer.len), "%.17g", value)
+                count = c.snprintf(ptrcast!((&buffer).ptr), c_ulong(buffer.len), "%.17g", value)
             }
             if (count < 0 or usize(count) >= buffer.len) return .write_failed
             try write_all(output, buffer[0..usize(count)])

std/mem/mem.hon

@@ -48,7 +48,7 @@ alloc proc($T type, allocator Allocator, count usize) []mut T ! AllocError {
 
     memory := raw_alloc(allocator, count * element_size, alignof!(T))
     if memory |bytes| {
-        pointer *mut T :: ptrcast!(T, bytes)
+        pointer *mut T :: ptrcast!(bytes)
         return pointer[..count]
     }
 
@@ -75,7 +75,7 @@ realloc proc($T type, allocator Allocator, memory []mut T, new_count usize) []mu
     old_memory ?*mut u8 := null
     old_size := 0
     if memory.len != 0 {
-        old_memory = ptrcast!(u8, memory.ptr)
+        old_memory = ptrcast!(memory.ptr)
         old_size = memory.len * element_size
     }
 
@@ -88,7 +88,7 @@ realloc proc($T type, allocator Allocator, memory []mut T, new_count usize) []mu
     )
 
     if resized |bytes| {
-        pointer *mut T :: ptrcast!(T, bytes)
+        pointer *mut T :: ptrcast!(bytes)
         return pointer[..new_count]
     }
 
@@ -100,7 +100,6 @@ realloc proc($T type, allocator Allocator, memory []mut T, new_count usize) []mu
 free proc($T type, allocator Allocator, memory []T) void {
     if (memory.len == 0 or sizeof!(T) == 0) return
     raw_free(allocator, ptrcast!(
-        u8,
         constcast!(memory).ptr),
         memory.len * sizeof!(T),
         alignof!(T),
@@ -112,7 +111,7 @@ free proc($T type, allocator Allocator, memory []T) void {
 #! exceeds its backing storage.
 @hide:file
 empty_slice proc($T type, count usize) []mut T {
-    pointer *mut T :: ptrcast!(T, (&empty_storage).ptr)
+    pointer *mut T :: ptrcast!((&empty_storage).ptr)
     return pointer[..count]
 }
 
@@ -142,13 +141,13 @@ power_of_two proc(value usize) bool {
 @hide:file
 c_alloc proc(_ ?@mut anyopaque, size usize, alignment usize) ?*mut u8 {
     if (power_of_two(alignment) == false) return null
-    if (alignment <= malloc_alignment) return ptrcast!(u8, c.malloc(c_ulong(size)))
+    if (alignment <= malloc_alignment) return ptrcast!(c.malloc(c_ulong(size)))
 
     memory [1]mut ?*mut anyopaque := [null]
     status := c.posix_memalign((&memory).ptr, c_ulong(alignment), c_ulong(size))
     if (status != 0) return null
 
-    return ptrcast!(u8, memory[0])
+    return ptrcast!(memory[0])
 }
 
 @hide:file
@@ -168,7 +167,7 @@ c_realloc proc(
 
     if memory |old_memory| {
         if alignment <= malloc_alignment {
-            return ptrcast!(u8, c.realloc(old_memory, c_ulong(new_size)))
+            return ptrcast!(c.realloc(old_memory, c_ulong(new_size)))
         }
 
         new_memory := c_alloc(null, new_size, alignment)