added proc macros

Cargo.lock

···
 ]
 
 [[package]]
+name = "futures-compat"
+version = "0.1.0"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
 name = "futures-core"
 version = "0.1.0"
 
 [[package]]
+name = "futures-derive"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
 name = "futures-util"
 version = "0.1.0"
 dependencies = [
  "futures-core",
 ]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17b6f705963418cdb9927482fa304bc562ece2fdd4f616084c50b7023b435a40"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"

Cargo.toml

···
 [workspace]
 resolver = "3"
-members = [ "futures-combinators", "futures-core", "futures-util"]
+members = [ "futures-core", "futures-combinators", "futures-compat", "futures-derive", "futures-util"]
 
 [workspace.package]
 version = "0.1.0"

futures-combinators/src/join.rs

···
 pub trait JoinExt<'scope> {
     fn along_with<Fut>(self, other: Fut) -> Join2<'scope, Self, Fut>
     where
-        Self: Sized + 'scope + ScopedFuture<'scope>,
-        Fut: ScopedFuture<'scope> + 'scope,
+        Self: Sized + ScopedFuture<'scope>,
+        Fut: ScopedFuture<'scope>,
     {
         (self, other).join()
     }
···
             refs: $namespace::WakerRefs<'scope>,
         }
 
-        impl<'scope, $($F: ScopedFuture<'scope> + 'scope),+> ScopedFuture<'scope>
+        impl<'scope, $($F: ScopedFuture<'scope>),+> ScopedFuture<'scope>
             for $StructName<'scope, $($F),+>
         {
             type Output = ($($F::Output),+);
···
             }
         }
 
-        impl<'scope, $($F: ScopedFuture<'scope> + 'scope),+> Join<'scope> for ($($F),+) {
+        impl<'scope, $($F: ScopedFuture<'scope>),+> Join<'scope> for ($($F),+) {
             type Output = ($($F::Output),*);
             type Future = $StructName<'scope, $($F),+>;
 

futures-compat/Cargo.toml

···
+[package]
+name = "futures-compat"
+version.workspace = true
+rust-version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+
+[dependencies]
+futures-core = { path = "../futures-core" }

futures-core/src/compat.rs futures-compat/src/lib.rs

···
 //! unsoundness if a ScopedFuture internally registers the waker with something
 //! that expects it to live for 'scope, and then the ScopedFutureWrapper is
 //! dropped
+//!
+//!
+//! ## TRIGGER WARNING
+//!
+//! This code is not for the faint of heart. Read at your own risk.
 
-use crate::{ScopedFuture, Wake};
 use std::{
     cell::UnsafeCell,
     marker::PhantomData,
···
     pin::Pin,
     task::{Context, Poll, Waker},
 };
+
+use futures_core::{ScopedFuture, Wake};
 
 /// RawWaker: fat ptr (*const (), &'static RawWakerVTable)
 /// &'scope dyn Wake fat ptr: (&'scope (), &'scope WakeVTable)
···
         }
     }
 }
+
+fn test(a: &i32) -> impl ScopedFuture<'_> + '_ {
+    async fn inner(a: &i32) -> i32 {
+        a + 1
+    }
+
+    let x = inner(a);
+
+    unsafe { UnscopedFutureWrapper::from_future(inner(a)) }
+}

futures-core/src/lib.rs

···
 use std::task::Poll;
 
-mod compat;
 mod task;
 
 pub use crate::task::Wake;

futures-derive/Cargo.toml

···
+[lib]
+proc-macro = true
+
+[package]
+name = "futures-derive"
+version.workspace = true
+rust-version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "visit-mut" ] }

futures-derive/src/lib.rs

···
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    Expr, ExprAwait, FnArg, ItemFn, Pat, ReturnType, Signature,
+    parse_macro_input, visit_mut::VisitMut,
+};
+
+#[proc_macro_attribute]
+pub fn async_scoped(_: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input = parse_macro_input!(item as ItemFn);
+
+    // Wraps *every* async expression within the function block with
+    // `ScopedFutureWrapper`, 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 input);
+
+    // Wrap the function with `UnscopedFutureWrapper` to convert it back into
+    // a `ScopedFuture`.
+    wrap_async_with_scoped(&input).into()
+}
+
+/// Takes async fn that returns anonymous `Future` impl.
+/// Generates fn that returns `UnscopedFutureWrapper` wrapper for the the anonymous `Future` impl.
+///
+/// ```rust
+/// 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()) }
+/// }
+/// ```
+///
+/// see https://rust-lang.github.io/rfcs/2394-async_await.html#lifetime-capture-in-the-anonymous-future
+/// for more context on lifetime capture
+/// - resulting ScopedFuture needs to be constrained to not outlive the lifetimes of any references
+///
+/// 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
+fn wrap_async_with_scoped(
+    ItemFn {
+        attrs,
+        vis,
+        sig:
+            Signature {
+                constness,
+                unsafety,
+                ident,
+                generics,
+                inputs,
+                output,
+                ..
+            },
+        block,
+    }: &ItemFn,
+) -> proc_macro2::TokenStream {
+    let output = match output {
+        ReturnType::Default => quote! { () },
+        ReturnType::Type(_, ty) => quote! { #ty },
+    };
+
+    let inner_args: Vec<syn::Ident> = inputs
+        .iter()
+        .filter_map(|param| match param {
+            FnArg::Receiver(_) => Some(quote::format_ident!("self")),
+            FnArg::Typed(typed) => {
+                if let Pat::Ident(ident) = &*typed.pat {
+                    Some(ident.ident.to_owned())
+                } else {
+                    None
+                }
+            }
+        })
+        .collect();
+
+    quote! {
+        #(#attrs)* #vis #constness #unsafety fn #ident #generics (#inputs) -> impl ScopedFuture<'_, Output = #output> + '_ {
+            async fn #constness #unsafety fn __inner (#inputs) -> #output #block
+
+            let future = __inner(#(#inner_args),*);
+
+            unsafe { futures_compat::UnscopedFutureWrapper::from_future(future) }
+        }
+    }
+}
+
+/// Uses the `syn::visit_mut` api to wrap every `.await` expression in
+/// `ScopedFutureWrapper`.
+struct ScopedFutureWrappingVisitor;
+
+impl VisitMut for ScopedFutureWrappingVisitor {
+    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
+            };
+        }
+
+        syn::visit_mut::visit_expr_mut(self, expr);
+    }
+}

futures/Cargo.toml

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

futures/src/lib.rs

···
-mod combinators;
-mod future;
-mod utils;
-
-/// from yoshuawuyts/futures-concurrency
-/// Wait for all futures to complete.
-///
-/// Awaits multiple futures simultaneously, returning the output of the futures
-/// in the same container type they were created once all complete.
-
-// scoped future combinators:
-//
-// Join<N>
-// TryJoin
-// Race
-// RaceOk
-//
-// add Deadline(a, rest) (deadline_against())
-// also functionality like (a, b, c).join().race_against(d, e, f)
-//
-// UnorderedJoinQueueStream? is this VecJoinStream?
-// OrderedJoinQueueStream
-
-// pub trait ScopedStream<'scope> {
-//     type Item;
-
-//     fn poll_next(self: Pin<&mut Self>, cx: &'scope mut dyn ScopedWake) -> Poll<Option<Self::Item>>;
-// }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
+fn test() {}