vuot 0.0.1

Run recursive async functions without overflowing the stack
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

use std::cell::Cell;
use std::future::Future;
use std::pin::Pin;
use std::ptr::NonNull;
use std::task::{Context, Poll};

use crate::side_channel::SideChannelFuture;

pub(crate) struct Sender<T, Fut> {
    future: Fut,
    result: Cell<Option<T>>,
}

impl<T, Fut> Sender<T, Fut> {
    /// # Safety
    ///
    /// The result pointer must be written to a pointer that is valid for the
    /// type `Cell<Option<T>>` before this future is polled.
    pub unsafe fn new(future: Fut) -> Self {
        let result = Cell::new(None);
        Self { future, result }
    }
}

impl<T, Fut> Future for Sender<T, Fut>
where
    Fut: Future<Output = T>,
{
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // Safety: `self.future` is only ever accessed pinned.
        let future = unsafe { self.as_mut().map_unchecked_mut(|this| &mut this.future) };

        match future.poll(cx) {
            Poll::Pending => Poll::Pending,
            Poll::Ready(value) => {
                self.result.set(Some(value));
                Poll::Ready(())
            }
        }
    }
}

impl<T, Fut> SideChannelFuture for Sender<T, Fut>
where
    Fut: Future<Output = T>,
{
    unsafe fn get_result_pointer(&self) -> NonNull<Cell<Option<()>>> {
        let result = &self.result;

        // Safety: we're turning a normal mutable reference into a pointer, so
        // this is never null
        let ptr: NonNull<Cell<Option<T>>> =
            unsafe { NonNull::new_unchecked(result as *const _ as *mut _) };

        // Safety: it is up to the caller to transmute this back to the correct
        // pointer type before using it.
        let ptr: NonNull<Cell<Option<()>>> = unsafe { std::mem::transmute(ptr) };

        ptr
    }
}