Compiler Explorer

Source code

#![feature(specialization)]
#![allow(incomplete_features)]
#![allow(coherence_leak_check)] // irrelevant
#![allow(unused)] // too shameful
#![feature(negative_impls)]
#![feature(coerce_unsized)]

mod core {
    #![allow(unused_imports)]
    pub use ::core::*;
    pub mod pin {
        pub use ::core::pin::*;

pub mod sealed {
            use core::ops::Deref;
        
            pub trait MaybeDeref {
                type Target : ?Sized;
            }
        
            // Specialization Safety:
            //   - this impl never leaks to user/third-party code, in any way,
            //     but for the subtyping of `Pin` itself.
            //   - `()` is a subtype of `()` only, so there is no "modulo lifetimes"
            //     exploit of this specialization that could ever be visible
            //     subtyping-wise.
            impl<Ptr> MaybeDeref for Ptr {
                default
                type Target = ();
            }

pub trait MaybeUnpin {}
            
            pub trait IsItUnpin {
                type T : ?Sized;
            }
            impl<T: ?Sized> IsItUnpin for T {
                default
                type T = dyn MaybeUnpin;
            }

impl<T: ?Sized + Unpin> IsItUnpin for T {
                type T = dyn Unpin;
            }
        
            impl<Ptr: Deref<Target: >> MaybeDeref for Ptr {
                type Target = <Ptr::Target as IsItUnpin>::T;
            }
        }
        
        pub struct Pin<
            Ptr: sealed::MaybeDeref<Target = Pointee>,
            Pointee: ?Sized = <Ptr as sealed::MaybeDeref>::Target,
        > {
            _phantom: ::core::marker::PhantomData<fn(&()) -> &Pointee>,
            ptr: Ptr,
        }

impl<T, U> core::ops::CoerceUnsized<Pin<U>> for Pin<T>
        where
            T: core::ops::CoerceUnsized<U>,
            // U: ?Sized,
        {}
        
        impl<Ptr: ::core::ops::Deref> Pin<Ptr> {
            pub unsafe fn new_unchecked(ptr: Ptr) -> Self {
                Self {
                    _phantom: <_>::default(),
                    ptr,
                }
            }
    
            pub fn new(ptr: Ptr) -> Self
            where
                Ptr::Target : Unpin,
            {
                unsafe {
                    Self::new_unchecked(ptr)
                }
            }
            
            pub fn as_ref(&self) -> Pin<&Ptr::Target> {
                unsafe { Pin::new_unchecked(&*self.ptr) }
            }
        }
    }
}

/* toggle the comments to see the difference */
use self::core::{
// use ::core::{
    marker::PhantomData,
    ops::Deref,
    pin::Pin,
};

struct S<T, Marker>(T, PhantomData<Marker>);

impl<T> Unpin for S<T, Marker1> {}

type Marker1 = for<'a> fn(&'a ());
type Marker2 = fn(&'static ());

// obviously a “working” function with this signature is problematic
pub fn unsound_pin<T>(x: T) -> T {
    let x = S(x, PhantomData);
    let ps: Pin<&S<T, Marker1>> = Pin::new(&x);
    let ps: Pin<&S<T, Marker2>> = ps; // subtyping coercion; but now Target = T
    // api(ps); // etc.
    x.0
}

const _: () = {
    /// Covariance over `Ptr` is preserved
    fn still_works<'a>(p: Pin<&'static ()>) -> Pin<&'a ()> {
        p
    }
    /// Covariance over `<T>` given `SmartPointer<T>` is preserved
    fn still_works_too<'a>(p: Pin<Box<&'static ()>>) -> Pin<Box<&'a ()>> {
        p
    }
};

const _: () = {
    fn still_works<'a>(p: Pin<&'static [(); 1]>) -> Pin<&'static [()]> {
        p
    }
};

const _: () = {
    struct S<T> {
        p: Pin<Box<T>>,
    }

/// Covariance over `<T>` given `SmartPointer<T>` is preserved
    fn still_works_too<'a>(p: S<&'static ()>) -> S<&'a ()> {
        p // oh no :(
    }
};