scope-lock 0.3.1

Safely extend lifetimes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use core::future::Future;
use core::marker::PhantomData;
use core::pin::Pin;
use core::ptr;
use core::task;

use crate::Extender;
use crate::extended::sync::Reference;
use crate::pointer_like::PointerPinUnforgotten;
use crate::pointer_like::erased_static::{fn_drop, fn_poll_unforgotten};

impl<'scope, 'env> Extender<'scope, 'env> {
    // TODO: pointer width extended value like extend_future_box
    pub fn future<'extended, P, O>(
        &'scope self,
        f: P,
    ) -> impl Future<Output = O> + Send + Sync + 'extended
    where
        'extended: 'scope,
        P: PointerPinUnforgotten + Send + 'scope,
        P::Pointee: Future<Output = O>,
        O: Send + 'extended,
    {
        let reference_guard = unsafe { self.rc.acquire() };

        struct Fut<T> {
            inner: T,
            // drop last
            _reference_guard: Reference,
        }
        unsafe impl<T> Send for Fut<T> {}
        unsafe impl<T> Sync for Fut<T> {}
        impl<T: Future> Future for Fut<T> {
            type Output = T::Output;

            fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
                unsafe { Pin::new_unchecked(&mut self.get_unchecked_mut().inner).poll(cx) }
            }
        }

        // It is sync since there's no way to interact with a reference to returned type
        Fut {
            inner: unsafe { extend_future_unchecked(f) },
            _reference_guard: reference_guard,
        }
    }
}

pub unsafe fn extend_future_unchecked<'a, F, O>(f: F) -> impl Future<Output = O> + 'a
where
    F: PointerPinUnforgotten,
    F::Pointee: Future<Output = O>,
    O: 'a,
{
    unsafe {
        ErasedFuture {
            ptr: ptr::NonNull::new_unchecked(f.into_ptr() as *mut ()),
            poll: fn_poll_unforgotten::<F, O>(),
            drop: fn_drop::<F>(),
            _marker: PhantomData,
        }
    }
}

struct ErasedFuture<P, O, D: Fn(*mut ())> {
    ptr: ptr::NonNull<()>,
    drop: D,
    poll: P,
    _marker: PhantomData<fn() -> task::Poll<O>>,
}

impl<P, O, D: Fn(*mut ())> Future for ErasedFuture<P, O, D>
where
    P: Fn(*mut (), &mut task::Context<'_>) -> task::Poll<O>,
{
    type Output = O;

    fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
        (self.poll)(self.ptr.as_ptr(), cx)
    }
}

impl<P, O, D: Fn(*mut ())> Drop for ErasedFuture<P, O, D> {
    fn drop(&mut self) {
        (self.drop)(self.ptr.as_ptr())
    }
}

pub mod legacy {
    use core::future::Future;
    use core::pin::Pin;
    use core::ptr;
    use core::task;

    #[doc(hidden)]
    pub struct ExtendedFuture<O> {
        // TODO: Could make a single dynamically sized struct
        pub(crate) func: ptr::NonNull<dyn Future<Output = O> + Send>,
    }

    impl<O> Future for ExtendedFuture<O> {
        type Output = O;

        fn poll(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
            unsafe { Pin::new_unchecked(self.get_unchecked_mut().func.as_mut()) }.poll(cx)
        }
    }

    unsafe impl<O> Send for ExtendedFuture<O> where O: Send {}
}