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
111
112
113
114
115
116
use core::cell::Cell;
use core::marker::Unpin;
use core::pin::PinMut;
use core::option::Option;
use core::ptr::NonNull;
use core::task::{self, Poll};
use core::ops::{Drop, Generator, GeneratorState};
#[doc(inline)]
pub use core::future::*;
#[unstable(feature = "gen_future", issue = "50547")]
pub fn from_generator<T: Generator<Yield = ()>>(x: T) -> impl Future<Output = T::Return> {
    GenFuture(x)
}
#[unstable(feature = "gen_future", issue = "50547")]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
struct GenFuture<T: Generator<Yield = ()>>(T);
impl<T: Generator<Yield = ()>> !Unpin for GenFuture<T> {}
#[unstable(feature = "gen_future", issue = "50547")]
impl<T: Generator<Yield = ()>> Future for GenFuture<T> {
    type Output = T::Return;
    fn poll(self: PinMut<Self>, cx: &mut task::Context) -> Poll<Self::Output> {
        set_task_cx(cx, || match unsafe { PinMut::get_mut_unchecked(self).0.resume() } {
            GeneratorState::Yielded(()) => Poll::Pending,
            GeneratorState::Complete(x) => Poll::Ready(x),
        })
    }
}
thread_local! {
    static TLS_CX: Cell<Option<NonNull<task::Context<'static>>>> = Cell::new(None);
}
struct SetOnDrop(Option<NonNull<task::Context<'static>>>);
impl Drop for SetOnDrop {
    fn drop(&mut self) {
        TLS_CX.with(|tls_cx| {
            tls_cx.set(self.0.take());
        });
    }
}
#[unstable(feature = "gen_future", issue = "50547")]
pub fn set_task_cx<F, R>(cx: &mut task::Context, f: F) -> R
where
    F: FnOnce() -> R
{
    let old_cx = TLS_CX.with(|tls_cx| {
        tls_cx.replace(NonNull::new(
            cx
                as *mut task::Context
                as *mut ()
                as *mut task::Context<'static>
        ))
    });
    let _reset_cx = SetOnDrop(old_cx);
    f()
}
#[unstable(feature = "gen_future", issue = "50547")]
pub fn get_task_cx<F, R>(f: F) -> R
where
    F: FnOnce(&mut task::Context) -> R
{
    let cx_ptr = TLS_CX.with(|tls_cx| {
        
        
        tls_cx.replace(None)
    });
    let _reset_cx = SetOnDrop(cx_ptr);
    let mut cx_ptr = cx_ptr.expect(
        "TLS task::Context not set. This is a rustc bug. \
        Please file an issue on https://github.com/rust-lang/rust.");
    unsafe { f(cx_ptr.as_mut()) }
}
#[unstable(feature = "gen_future", issue = "50547")]
pub fn poll_in_task_cx<F>(f: PinMut<F>) -> Poll<F::Output>
where
    F: Future
{
    get_task_cx(|cx| f.poll(cx))
}