Compiler Explorer

Source code

#![feature(type_alias_impl_trait)]

use core::future::{ready, Future, Ready};

pub struct Stuff(pub u8);

trait StuffProvider {
    type ProvideStuff<'c>: Future<Output = Stuff> + 'c where Self: 'c;
    fn provide_stuff(&mut self) -> Self::ProvideStuff<'_>;
}

async fn do_stuff<P: StuffProvider>(mut provider: P) -> Stuff {
    let mut stuff = provider.provide_stuff().await;
    stuff.0 += 1;
    stuff
}

struct SyncStuffProvider;

impl StuffProvider for SyncStuffProvider {
    type ProvideStuff<'c> = Ready<Stuff>;

fn provide_stuff(&mut self) -> Self::ProvideStuff<'_> {
        ready(Stuff(41))
    }
}

pub fn do_stuff_sync() -> Stuff {
    let fut = do_stuff(SyncStuffProvider);
    ready_or_diverge::block_on(fut)
}

#[test]
fn does_stuff_sync() {
    let stuff = do_stuff_sync();
    assert_eq!(stuff.0, 42);
}

mod ready_or_diverge {
    use core::future::Future;
    use core::pin::Pin;
    use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};

// copy-pasted from https://docs.rs/futures/0.3.17/futures/task/fn.noop_waker.html
    unsafe fn noop_clone(_data: *const ()) -> RawWaker {
        noop_raw_waker()
    }

unsafe fn noop(_data: *const ()) {}

const NOOP_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(noop_clone, noop, noop, noop);

const fn noop_raw_waker() -> RawWaker {
        RawWaker::new(core::ptr::null(), &NOOP_WAKER_VTABLE)
    }

pub fn block_on<O, F: Future<Output = O>>(mut fut: F) -> O {
        let waker = unsafe { Waker::from_raw(noop_raw_waker()) };
        let mut context = Context::from_waker(&waker);
        let pinned = unsafe { Pin::new_unchecked(&mut fut) };
        match pinned.poll(&mut context) {
            Poll::Ready(res) => return res,
            _ => loop {}, // diverge
        }
    }
}