tests pass again

Cargo.lock

···
 dependencies = [
  "futures-combinators",
  "futures-compat",
+ "futures-core",
  "futures-derive",
 ]
 

futures-combinators/src/join.rs

···
     #![no_std]
 
     use futures_core::Future;
+    use futures_util::{dummy_guard, poll_fn};
 
-    use crate::wake::{dummy_guard, local_wake, poll_fn};
+    use crate::wake::local_wake;
 
     use super::*;
 

futures-combinators/src/race.rs

···
     use std::pin;
 
     use futures_core::Future;
+    use futures_util::{dummy_guard, poll_fn};
 
-    use crate::wake::{dummy_guard, local_wake, poll_fn};
+    use crate::wake::local_wake;
 
     use super::*;
 

futures-combinators/src/wake.rs

···
-use std::{
-    array, cell::Cell, marker::PhantomPinned, pin::Pin, ptr::NonNull,
-    task::Poll,
-};
+use std::{array, cell::Cell, marker::PhantomPinned, pin::Pin, ptr::NonNull};
 
 use futures_compat::{LocalWaker, WakePtr};
 use futures_core::Wake;
···
 //         }
 //     }
 // }
-
-pub struct PollFn<F, T>(F)
-where
-    F: FnMut(&LocalWaker) -> Poll<T>;
-
-impl<F, T> futures_core::Future<LocalWaker> for PollFn<F, T>
-where
-    F: FnMut(&LocalWaker) -> Poll<T>,
-{
-    type Output = T;
-
-    fn poll(
-        self: Pin<&mut Self>,
-        waker: Pin<&LocalWaker>,
-    ) -> Poll<Self::Output> {
-        (unsafe { &mut self.get_unchecked_mut().0 })(&waker)
-    }
-}
-
-pub fn poll_fn<F, T>(f: F) -> impl futures_core::Future<LocalWaker, Output = T>
-where
-    F: FnMut(&LocalWaker) -> Poll<T>,
-{
-    PollFn(f)
-}
-
-pub struct DummyWaker;
-
-impl Wake for DummyWaker {
-    fn wake(&self) {
-        dbg!("awake!");
-    }
-}
-
-pub fn dummy_guard() -> ValueGuard<WakePtr> {
-    ValueGuard::new(NonNull::new(&mut DummyWaker as *mut dyn Wake))
-}

futures-compat/src/lib.rs

···
     }
 }
 
-// impl<F> core::future::Future for F
-// where
-//     F: for<'a> futures_core::Future<Context<'a>>,
-// {
-//     type Output = F::Output;
-
-//     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-//         self.poll(cx.waker())
-//     }
-// }
-
 #[cfg(test)]
 mod test {
     use std::pin;
···
         let waker = unsafe { guard_to_waker(guard.as_ref()) };
         let guard = unsafe { waker_to_guard(&waker) };
         assert_eq!(
-            guard.get().unwrap().as_ptr(),
-            &dummy as *const dyn Wake as *mut dyn Wake
+            guard.get().unwrap().as_ptr() as *const () as usize,
+            &dummy as *const _ as *const () as usize
         );
     }
 }

futures-derive/src/lib.rs

···
 use proc_macro::TokenStream;
 use quote::{ToTokens, quote};
 use syn::{
-    Expr, ExprAwait, FnArg, GenericArgument, ItemFn, ReturnType,
-    parse_macro_input, parse_quote, parse2, visit_mut::VisitMut,
+    Expr, ExprAwait, ItemFn, ReturnType, parse_macro_input, parse_quote,
+    parse2, visit_mut::VisitMut,
 };
 
 /// Takes async fn that returns anonymous `Future` impl.
 /// Generates fn that returns `UnscopedFutureWrapper` wrapper for the the anonymous `Future` impl.
 ///
-/// ```rust
-/// fn my_func<'a, 'b>(a: &'a A, b: &'b B) -> impl ScopedFuture<'a + 'b, Output = T> + 'a + 'b {
+/// ```rust,ignore
+/// fn my_func<'a, 'b>(a: &'a A, b: &'b B) -> impl ScopedFuture<LifetimeGuard, Output = Output> {
 ///   let output = async move { [body] } // compilers turns this into -> impl Future<Output = T> + 'a + 'b
-///   unsafe { UnscopedFutureWrapper::from_future(output) }
+///   unsafe { futures_compat::std_future_to_bespoke(output) }
 /// }
 /// ```
 ///
···
 /// to actually implement this (capture all lifetimes) we use `ScopedFuture<'_> + '_` so the compiler can infer
 /// lifetimes from the anonymous future impl returned by the actual inner async fn
 #[proc_macro_attribute]
-pub fn async_scoped(_: TokenStream, item: TokenStream) -> TokenStream {
+pub fn async_function(_: TokenStream, item: TokenStream) -> TokenStream {
     let mut item_fn = parse_macro_input!(item as ItemFn);
     // Wraps *every* async expression within the function block with
-    // `ScopedFutureWrapper`, allowing them to be treated as regular `Future`
+    // `BespokeFutureWrapper`, allowing them to be treated as regular `Future`
     // impls.
     //
     // This will cause a compiler error if any expression being awaited is not
     // a `ScopedFuture`, which is intentional because the `Future` and
     // `ScopedFuture` systems are incompatible.
-    ScopedFutureWrappingVisitor.visit_item_fn_mut(&mut item_fn);
+    BespokeFutureWrappingVisitor.visit_item_fn_mut(&mut item_fn);
 
     // disable async since it is moved to the block
     item_fn.sig.asyncness = None;
···
     *item_fn.block = parse_quote! {
         {
             let future = async move #block;
-            unsafe { futures_compat::UnscopedFutureWrapper::from_future(future) }
+            unsafe { futures_compat::std_future_to_bespoke(future) }
         }
     };
 
-    let output = match &item_fn.sig.output {
+    let output_type = match &item_fn.sig.output {
         ReturnType::Default => quote! { () },
         ReturnType::Type(_, ty) => quote! { #ty },
     };
 
-    let has_lifetime_dependency =
-        item_fn.sig.inputs.iter().any(|param| match param {
-            FnArg::Receiver(receiver) => receiver.reference.is_some(),
-            FnArg::Typed(pat) => has_lifetime_dependency(&pat.ty),
-        });
+    item_fn.sig.output = parse_quote! { -> impl futures_core::Future<LocalWaker, Output = #output_type> };
 
-    // set outer fn output to ScopedFuture<'_/'static, Output = #output>
-    item_fn.sig.output = if has_lifetime_dependency {
-        parse_quote! { -> impl futures_core::ScopedFuture<'_, Output = #output> + '_ }
-    } else {
-        parse_quote! { -> impl futures_core::ScopedFuture<'static, Output = #output> }
-    };
+    // let has_lifetime_dependency =
+    //     item_fn.sig.inputs.iter().any(|param| match param {
+    //         FnArg::Receiver(receiver) => receiver.reference.is_some(),
+    //         FnArg::Typed(pat) => has_lifetime_dependency(&pat.ty),
+    //     });
+
+    // // set outer fn output to ScopedFuture<'_/'static, Output = #output>
+    // item_fn.sig.output = if has_lifetime_dependency {
+    //     parse_quote! { -> impl futures_core::ScopedFuture<'_, Output = #output> + '_ }
+    // } else {
+    //     parse_quote! { -> impl futures_core::ScopedFuture<'static, Output = #output> }
+    // };
 
     item_fn.to_token_stream().into()
 }
···
 /// Takes async fn that returns anonymous `Future` impl.
 /// Generates fn that returns `UnscopedFutureWrapper` wrapper for the the anonymous `Future` impl.
 ///
-/// ```rust
+/// ```rust,ignore
 /// fn [original name]<'a, 'b>(a: &'a A, b: &'b B) -> impl ScopedFuture<'a + 'b, Output = T> + 'a + 'b {
 ///   async fn [__inner]<'a, 'b>(a: &'a A, b: &'b B) -> T { [body] } // compilers turns this into -> impl Future<Output = T> + 'a + 'b
 ///   unsafe { UnscopedFutureWrapper::from_future(__inner()) }
···
 ///
 /// This generates a modified block of the form:
 ///
-/// ```rust
+/// ```rust,ignore
 /// {
 ///   let output = async { <original block, mapped to convert all `ScopedFuture` to `Future`> };
 ///   unsafe { futures_compat::UnscopedFutureWrapper::from_future(output) }
 /// }
 /// ```
 #[proc_macro]
-pub fn block(input: TokenStream) -> TokenStream {
+pub fn async_block(input: TokenStream) -> TokenStream {
     // block is formed { **expr/stmt }, so we need to surround the inputs in {}
     let input = proc_macro2::TokenStream::from(input);
     let block_input = quote! { { #input } };
 
     let mut block = parse2(block_input).expect("Failed to parse as block.");
 
-    ScopedFutureWrappingVisitor.visit_block_mut(&mut block);
+    BespokeFutureWrappingVisitor.visit_block_mut(&mut block);
 
     quote! {
         {
             let output = async #block;
-            unsafe { futures_compat::UnscopedFutureWrapper::from_future(output) }
+            unsafe { futures_compat::std_future_to_bespoke(output) }
         }
     }
     .into()
···
 
 /// Determines if typed pattern contains a reference or dependency on a
 /// lifetime (used for deciding between '_ and 'static ScopedFuture).
-fn has_lifetime_dependency(ty: &syn::Type) -> bool {
-    match ty {
-        syn::Type::Reference(_) => true,
-        syn::Type::Path(type_path) => {
-            type_path.path.segments.iter().any(|segment| {
-                if let syn::PathArguments::AngleBracketed(args) =
-                    &segment.arguments
-                {
-                    args.args.iter().any(|arg| match arg {
-                        GenericArgument::Type(ty) => {
-                            has_lifetime_dependency(ty)
-                        }
-                        syn::GenericArgument::Lifetime(_) => true,
-                        _ => false,
-                    })
-                } else {
-                    false
-                }
-            })
-        }
-        syn::Type::Tuple(tuple) => {
-            tuple.elems.iter().any(has_lifetime_dependency)
-        }
-        syn::Type::Slice(slice) => has_lifetime_dependency(&slice.elem),
-        syn::Type::Array(array) => has_lifetime_dependency(&array.elem),
-        syn::Type::Ptr(ptr) => has_lifetime_dependency(&ptr.elem),
-        syn::Type::Group(group) => has_lifetime_dependency(&group.elem),
-        syn::Type::Paren(paren) => has_lifetime_dependency(&paren.elem),
-        syn::Type::BareFn(bare_fn) => {
-            bare_fn
-                .inputs
-                .iter()
-                .any(|input| has_lifetime_dependency(&input.ty))
-                || match &bare_fn.output {
-                    ReturnType::Default => false,
-                    ReturnType::Type(_, ty) => has_lifetime_dependency(ty),
-                }
-        }
+// fn has_lifetime_dependency(ty: &syn::Type) -> bool {
+//     match ty {
+//         syn::Type::Reference(_) => true,
+//         syn::Type::Path(type_path) => {
+//             type_path.path.segments.iter().any(|segment| {
+//                 if let syn::PathArguments::AngleBracketed(args) =
+//                     &segment.arguments
+//                 {
+//                     args.args.iter().any(|arg| match arg {
+//                         GenericArgument::Type(ty) => {
+//                             has_lifetime_dependency(ty)
+//                         }
+//                         syn::GenericArgument::Lifetime(_) => true,
+//                         _ => false,
+//                     })
+//                 } else {
+//                     false
+//                 }
+//             })
+//         }
+//         syn::Type::Tuple(tuple) => {
+//             tuple.elems.iter().any(has_lifetime_dependency)
+//         }
+//         syn::Type::Slice(slice) => has_lifetime_dependency(&slice.elem),
+//         syn::Type::Array(array) => has_lifetime_dependency(&array.elem),
+//         syn::Type::Ptr(ptr) => has_lifetime_dependency(&ptr.elem),
+//         syn::Type::Group(group) => has_lifetime_dependency(&group.elem),
+//         syn::Type::Paren(paren) => has_lifetime_dependency(&paren.elem),
+//         syn::Type::BareFn(bare_fn) => {
+//             bare_fn
+//                 .inputs
+//                 .iter()
+//                 .any(|input| has_lifetime_dependency(&input.ty))
+//                 || match &bare_fn.output {
+//                     ReturnType::Default => false,
+//                     ReturnType::Type(_, ty) => has_lifetime_dependency(ty),
+//                 }
+//         }
 
-        _ => false,
-    }
-}
+//         _ => false,
+//     }
+// }
 
 /// Uses the `syn::visit_mut` api to wrap every `.await` expression in
 /// `ScopedFutureWrapper`.
-struct ScopedFutureWrappingVisitor;
+struct BespokeFutureWrappingVisitor;
 
-impl VisitMut for ScopedFutureWrappingVisitor {
+impl VisitMut for BespokeFutureWrappingVisitor {
     fn visit_expr_mut(&mut self, expr: &mut syn::Expr) {
         if let Expr::Await(ExprAwait { attrs, base, .. }) = expr {
             *expr = syn::parse_quote! {
-                unsafe { futures_compat::ScopedFutureWrapper::from_scoped(#(#attrs)* #base) }.await
+                unsafe { futures_compat::bespoke_future_to_std(#(#attrs)* #base) }.await
             };
         }
 

futures-util/src/block_on.rs

···
+use std::{
+    pin::{self, Pin},
+    task::Poll,
+};
+
+use crate::{LocalWaker, dummy_guard};
+
+pub fn block_on<F: futures_core::Future<LocalWaker>>(
+    mut f: Pin<&mut F>,
+) -> F::Output {
+    let dummy_guard = pin::pin!(dummy_guard());
+    loop {
+        if let Poll::Ready(out) = f.as_mut().poll(dummy_guard.as_ref()) {
+            return out;
+        }
+    }
+}

futures-util/src/lib.rs

···
-use std::ptr::NonNull;
+use std::{pin::Pin, ptr::NonNull, task::Poll};
 
 use futures_core::{Future, Wake};
 use lifetime_guard::{atomic_guard::AtomicValueGuard, guard::ValueGuard};
 
+pub mod block_on;
 pub mod maybe_done;
 
 pub type WakePtr = Option<NonNull<dyn Wake>>;
···
 {
     future
 }
+
+pub struct PollFn<F, T>(F)
+where
+    F: FnMut(&LocalWaker) -> Poll<T>;
+
+impl<F, T> futures_core::Future<LocalWaker> for PollFn<F, T>
+where
+    F: FnMut(&LocalWaker) -> Poll<T>,
+{
+    type Output = T;
+
+    fn poll(
+        self: Pin<&mut Self>,
+        waker: Pin<&LocalWaker>,
+    ) -> Poll<Self::Output> {
+        (unsafe { &mut self.get_unchecked_mut().0 })(&waker)
+    }
+}
+
+pub fn poll_fn<F, T>(f: F) -> impl futures_core::Future<LocalWaker, Output = T>
+where
+    F: FnMut(&LocalWaker) -> Poll<T>,
+{
+    PollFn(f)
+}
+
+pub struct DummyWaker;
+
+impl Wake for DummyWaker {
+    fn wake(&self) {
+        dbg!("awake!");
+    }
+}
+
+pub fn dummy_guard() -> ValueGuard<WakePtr> {
+    ValueGuard::new(NonNull::new(&mut DummyWaker as *mut dyn Wake))
+}

futures-util/src/maybe_done.rs

···
 ///
 /// This is created by the [`maybe_done()`] function.
 #[derive(Debug)]
-pub enum MaybeDone<Fut: Future<LocalWaker>> {
+pub enum MaybeDone<Fut: futures_core::Future<LocalWaker>> {
     /// A not-yet-completed future
     Future(/* #[pin] */ Fut),
     /// The output of the completed future
···
 impl<Fut: Future<LocalWaker> + Unpin> Unpin for MaybeDone<Fut> {}
 
 /// Wraps a future into a `MaybeDone`
-///
-/// # Examples
-///
-/// ```
-/// # futures::executor::block_on(async {
-/// use core::pin::pin;
-///
-/// use futures::future;
-///
-/// let future = future::maybe_done(async { 5 });
-/// let mut future = pin!(future);
-/// assert_eq!(future.as_mut().take_output(), None);
-/// let () = future.as_mut().await;
-/// assert_eq!(future.as_mut().take_output(), Some(5));
-/// assert_eq!(future.as_mut().take_output(), None);
-/// # });
-/// ```
-pub fn maybe_done<Fut: Future<LocalWaker>>(future: Fut) -> MaybeDone<Fut> {
+pub fn maybe_done<Fut: futures_core::Future<LocalWaker>>(
+    future: Fut,
+) -> MaybeDone<Fut> {
     assert_future::<(), _>(MaybeDone::Future(future))
 }
 
···
     }
 }
 
-impl<Fut: Future<LocalWaker>> Future<LocalWaker> for MaybeDone<Fut> {
+impl<Fut: Future<LocalWaker>> futures_core::Future<LocalWaker>
+    for MaybeDone<Fut>
+{
     type Output = ();
 
     fn poll(

futures/Cargo.toml

···
 homepage.workspace = true
 
 [dependencies]
+futures-core = { workspace = true }
 futures-combinators = { workspace = true }
 futures-compat  = { workspace = true }
 futures-derive  = { workspace = true }

futures/src/lib.rs

···
 #![no_std]
 
-pub use futures_combinators;
-pub use futures_core;
-use futures_core::ScopedFuture;
-pub use futures_derive::async_scoped;
-pub use futures_util;
+use futures_compat::LocalWaker;
+use futures_derive::async_function;
 
 async fn evil() {}
 
-#[async_scoped]
+#[async_function]
 fn inner(a: i32, b: &i32) -> i32 {
     // evil().await;
     1
 }
 
-#[async_scoped]
+#[async_function]
 fn test(a: i32, b: &i32) -> i32 {
-    futures_derive::block! { 1 + *b; 2 }.await
+    futures_derive::async_block! { let _ = 1 + *b; 2 }.await
 }
 
-fn test2<'a>(a: i32) {}
+// fn test2<'a>(a: i32) {}