[pointer][invariant] Remove AliasingMapping

We previously used these to model `UnsafeCell` agreement, but that only
works when we support an `Inaccessible` aliasing invariant, which we
don't anymore. Future commits will use a different mechanism to model
`UnsafeCell` agreement. There is no other circumstance under which a
pointer can change its aliasing model.

While we're here, make `Read` slightly more permissive, implemented for
`A: Aliasing, T: Immutable` rather than just `A: Reference, T:
Immutable`.

Makes progress on #1122, #1866

gherrit-pr-id: I1ac2ae177a235083e33b09fc848423220d3da042

src/pointer/invariant.rs

@@ -55,6 +55,9 @@ impl<A: Aliasing, AA: Alignment, V: Validity> Invariants for (A, AA, V) {
 }
 
 /// The aliasing invariant of a [`Ptr`][super::Ptr].
+///
+/// All aliasing invariants must permit reading from the bytes of a pointer's
+/// referent which are not covered by [`UnsafeCell`]s.
 pub trait Aliasing: Sealed {
     /// Is `Self` [`Exclusive`]?
     #[doc(hidden)]
@@ -65,9 +68,6 @@ pub trait Aliasing: Sealed {
     /// Aliasing>::Variance<'a, T>` to inherit this variance.
     #[doc(hidden)]
     type Variance<'a, T: 'a + ?Sized>;
-
-    #[doc(hidden)]
-    type MappedTo<M: AliasingMapping>: Aliasing;
 }
 
 /// The alignment invariant of a [`Ptr`][super::Ptr].
@@ -113,7 +113,6 @@ impl Aliasing for Inaccessible {
     //
     // [1] https://doc.rust-lang.org/1.81.0/reference/subtyping.html#variance
     type Variance<'a, T: 'a + ?Sized> = &'a T;
-    type MappedTo<M: AliasingMapping> = M::FromInaccessible;
 }
 
 /// The `Ptr<'a, T>` adheres to the aliasing rules of a `&'a T`.
@@ -128,7 +127,6 @@ pub enum Shared {}
 impl Aliasing for Shared {
     const IS_EXCLUSIVE: bool = false;
     type Variance<'a, T: 'a + ?Sized> = &'a T;
-    type MappedTo<M: AliasingMapping> = M::FromShared;
 }
 impl Reference for Shared {}
 
@@ -141,7 +139,6 @@ pub enum Exclusive {}
 impl Aliasing for Exclusive {
     const IS_EXCLUSIVE: bool = true;
     type Variance<'a, T: 'a + ?Sized> = &'a mut T;
-    type MappedTo<M: AliasingMapping> = M::FromExclusive;
 }
 impl Reference for Exclusive {}
 
@@ -230,7 +227,7 @@ define_because!(
     pub BecauseImmutable
 );
 // SAFETY: `T: Immutable`.
-unsafe impl<A: Reference, T: ?Sized + crate::Immutable> Read<A, BecauseImmutable> for T {}
+unsafe impl<A: Aliasing, T: ?Sized + crate::Immutable> Read<A, BecauseImmutable> for T {}
 
 use sealed::Sealed;
 mod sealed {
@@ -257,23 +254,6 @@ pub use mapping::*;
 mod mapping {
     use super::*;
 
-    /// A mapping from one [`Aliasing`] type to another.
-    ///
-    /// An `AliasingMapping` is a type-level map which maps one `Aliasing` type
-    /// to another. It is always "total" in the sense of having a mapping for
-    /// any `A: Aliasing`.
-    ///
-    /// Given `A: Aliasing` and `M: AliasingMapping`, `M` can be applied to `A`
-    /// as [`MappedAliasing<A, M>`](MappedAliasing).
-    ///
-    /// Mappings are used by [`Ptr`](crate::Ptr) conversion methods to preserve
-    /// or modify invariants as required by each method's semantics.
-    pub trait AliasingMapping {
-        type FromInaccessible: Aliasing;
-        type FromShared: Aliasing;
-        type FromExclusive: Aliasing;
-    }
-
     /// A mapping from one [`Alignment`] type to another.
     ///
     /// An `AlignmentMapping` is a type-level map which maps one `Alignment`
@@ -308,10 +288,6 @@ mod mapping {
         type FromValid: Validity;
     }
 
-    /// The application of the [`AliasingMapping`] `M` to the [`Aliasing`] `A`.
-    #[allow(type_alias_bounds)]
-    pub type MappedAliasing<A: Aliasing, M: AliasingMapping> = A::MappedTo<M>;
-
     /// The application of the [`AlignmentMapping`] `M` to the [`Alignment`] `A`.
     #[allow(type_alias_bounds)]
     pub type MappedAlignment<A: Alignment, M: AlignmentMapping> = A::MappedTo<M>;
@@ -320,14 +296,6 @@ mod mapping {
     #[allow(type_alias_bounds)]
     pub type MappedValidity<V: Validity, M: ValidityMapping> = V::MappedTo<M>;
 
-    impl<FromInaccessible: Aliasing, FromShared: Aliasing, FromExclusive: Aliasing> AliasingMapping
-        for ((Inaccessible, FromInaccessible), (Shared, FromShared), (Exclusive, FromExclusive))
-    {
-        type FromInaccessible = FromInaccessible;
-        type FromShared = FromShared;
-        type FromExclusive = FromExclusive;
-    }
-
     impl<FromUnknown: Alignment, FromAligned: Alignment> AlignmentMapping
         for ((Unknown, FromUnknown), (Shared, FromAligned))
     {