Clarify cast rules (RFC 401) wrt. fat pointers

[arielb1]

The RFC 401 cast rules are (my comments in italic):

A cast e as U is valid if one of the following holds:

• e has type T and T coerces to U; coerce-cast
• e has type *T and U is *U_0 (i.e., between any raw pointers); ptr-ptr-cast
• e has type *T and U is uint , or vice versa; ptr-addr-cast
• e has type T and T and U are any numeric types; numeric-cast
• e is a C-like enum and U is any integer type, bool; enum-cast
• e has type T and T == u8 and U == char; char-cast
• e has type T and T == &[V, ..n] or T == &V and U == *const V, and
  similarly for the mutable variants to either *const V or *mut V. ptr-ref-cast

The raw pointer casts (ptr-ptr-cast, ptr-addr-cast) don't make sense when only one of the pointers involved is fat (i.e. 0xb8000 as *mut [u8], let v=5; let u=&⁠v; u as *const [Vec<u32>]) – where does the vtable come from?

The casts also don't make much sense if the vtables have distinct types (say, casting *const [u8] → *const fmt::Write – does the length turn into a vtable pointer? while this does make some sense, it is still somewhat weird).

Currently, rustc ICEs in all these casts. Some (but not all) of these ICEs are fixed in rust-lang/rust#24158.

[nrc]

I believe the rules should be:

• ptr-ptr casts are only allowed between the same kind of pointer, where the kinds are: thin pointer, fat pointer to trait, fat pointer to array (which includes strings);
• any cast to a pointer, may only be a cast to a thin pointer;
• any cast from a pointer is valid. A cast from a fat pointer should ignore the vtable part and just use the pointer part.

I think these rules satisfy the cases in the OP. Do they make sense in a wider context?

[arielb1]

This means that ptr-ptr-cast is allowed, between, say, a *const fmt::Write and a *const fmt::Display (which reinterprets the vtable)? A cast between *const fmt::Write and *const u8 (which drops the vtable)?

Anyway, ptr-ref-cast can create fat pointers (say, casting &fmt::Write to *const fmt::Write), so "may only be cast to thin pointer" is false (but it does look like a good rule for ptr-ptr-cast).

[arielb1]

Should we amend the RFC, then?

[bluss]

This was fixed by the RFC I think.