idk

Cargo.lock

···
 version = 4
 
 [[package]]
+name = "futures"
+version = "0.1.0"
+dependencies = [
+ "futures-combinators",
+ "futures-compat",
+ "futures-core",
+ "futures-derive",
+ "futures-util",
+]
+
+[[package]]
 name = "futures-combinators"
 version = "0.1.0"
 dependencies = [

Cargo.toml

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

futures-compat/src/lib.rs

···
         }
     }
 }
-
-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

···
 /// The waker is no longer tied to the actual future's lifetime, making it
 /// unsound to not have either static tasks or reference counting.
 /// To avoid this, we want to use a &'scope waker instead, with 1 waker / task.
+#[diagnostic::on_unimplemented(
+    message = "The type `{Self}` must implement the `ScopedFuture` trait.",
+    label = "Missing `ScopedFuture` implementation",
+    note = "If you are trying to await a `task::Future` from within a `ScopedFuture`, note that the systems are incompatible."
+)]
 pub trait ScopedFuture<'scope> {
     type Output;
 

futures-derive/src/lib.rs

···
         })
         .collect();
 
+    // let has_refs = inputs
+
     quote! {
-        #(#attrs)* #vis #constness #unsafety fn #ident #generics (#inputs) -> impl ScopedFuture<'_, Output = #output> + '_ {
-            async fn #constness #unsafety fn __inner (#inputs) -> #output #block
+        #(#attrs)* #vis #constness #unsafety fn #ident #generics (#inputs) -> impl futures_core::ScopedFuture<'_, Output = #output> + '_ {
+            async #constness #unsafety fn __inner (#inputs) -> #output #block
 
             let future = __inner(#(#inner_args),*);
 

futures/src/lib.rs

···
-fn test() {}
+#![no_std]
+
+pub use futures_combinators;
+pub use futures_core;
+pub use futures_derive::async_scoped;
+pub use futures_util;
+
+async fn evil() {}
+
+#[async_scoped]
+fn test<'a>(a: i32, b: &i32) {
+    // evil().await
+}
+
+fn test2<'a>(a: i32) {}