rewrote futures-core and futures-compat

reference to AtomicValueGuard is stored in RawWaker.data, custom
bcsc::Future clone of core::future::Future is needed to ensure
incompatibility between the two systems since the custom RawWaker is
a "broken" waker that panics when used normally

Cargo.lock

···
 dependencies = [
  "futures-combinators",
  "futures-compat",
- "futures-core",
  "futures-derive",
  "futures-util",
 ]
···
 name = "futures-combinators"
 version = "0.0.2"
 dependencies = [
- "futures-core",
  "futures-util",
 ]
 
···
 version = "0.0.2"
 dependencies = [
  "futures-core",
+ "lifetime-guard",
 ]
 
 [[package]]
···
 [[package]]
 name = "futures-util"
 version = "0.0.2"
-dependencies = [
- "futures-core",
-]
 
 [[package]]
 name = "generator"

Cargo.toml

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

futures-combinators/Cargo.toml

···
 homepage.workspace = true
 
 [dependencies]
-futures-core = { workspace = true }
 futures-util = { workspace = true }

futures-combinators/src/join.rs

···
-use futures_core::{ScopedFuture, Wake};
+use futures_comp
 use futures_util::WakeStore;
 use futures_util::{MaybeDone, maybe_done};
 use std::{cell::Cell, task::Poll};
···
 ///
 /// Awaits multiple futures simultaneously, returning the output of the futures
 /// in the same container type they were created once all complete.
-pub trait Join<'scope> {
+pub trait Join {
     /// The resulting output type.
     type Output;
 
     /// The [`ScopedFuture`] implementation returned by this method.
-    type Future: ScopedFuture<'scope, Output = Self::Output>;
+    type Future: Future<Output = Self::Output>;
 
     /// Waits for multiple futures to complete.
     ///
···
 pub trait JoinExt<'scope> {
     fn along_with<Fut>(self, other: Fut) -> Join2<'scope, Self, Fut>
     where
-        Self: Sized + ScopedFuture<'scope>,
-        Fut: ScopedFuture<'scope>,
+        Self: Sized + Future<'scope>,
+        Fut: Future<'scope>,
     {
         (self, other).join()
     }
 }
 
-impl<'scope, T> JoinExt<'scope> for T where T: ScopedFuture<'scope> {}
+impl<'scope, T> JoinExt<'scope> for T where T: Future<'scope> {}
 
 macro_rules! impl_join_tuple {
     ($namespace:ident $StructName:ident $($F:ident)+) => {
···
         let x1 = Cell::new(0);
         let x2 = Cell::new(0);
         let f1 = poll_fn(|wake| {
-            wake.wake();
+            wake.register();
             x1.set(x1.get() + 1);
             if x1.get() == 4 {
                 Poll::Ready(x1.get())
···
             }
         });
         let f2 = poll_fn(|wake| {
-            wake.wake();
+            wake.register();
             x2.set(x2.get() + 1);
             if x2.get() == 5 {
                 Poll::Ready(x2.get())

futures-compat/Cargo.toml

···
 
 [dependencies]
 futures-core = { workspace = true }
+lifetime-guard = { workspace = true }

futures-compat/src/lib.rs

···
-//! Any interaction between the real Future ecosystem and ScopedFuture
-//! ecosystem is strictly unsound
-//!
-//! ScopedFutures cannot poll Futures because they can't guarantee they
-//! will outlive *const () ptrs they supply to the futures, leading to
-//! dangling pointers if the futures register the waker with something that
-//! assumes assumes it is valid for 'static and then the ScopedFuture goes
-//! out of scope
-//!
-//! Futures cannot poll ScopedFutures because they cannot guarantee their
-//! Waker will be valid for 'scope (due to lack of real borrowing), leading to
-//! unsoundness if a ScopedFuture internally registers the waker with something
-//! that expects it to live for 'scope, and then the ScopedFutureWrapper is
-//! dropped
-//!
-//! This code is not for the faint of heart. Read at your own risk.
+//! Any interaction between an executor/reactor intended for task::Future
+//! with an executor/reactor intended for bcsc::Future is strictly unsound.
 
 use std::{
-    cell::UnsafeCell,
-    marker::PhantomData,
-    mem,
     pin::Pin,
-    task::{Context, Poll, Waker},
+    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
 };
 
-use futures_core::{ScopedFuture, Wake};
+use lifetime_guard::atomic_guard::AtomicValueGuard;
+
+static EVIL_VTABLE: RawWakerVTable = RawWakerVTable::new(
+    |_| panic!("wtf"),
+    |_| panic!("wtf"),
+    |_| panic!("wtf"),
+    |_| panic!("wtf"),
+);
 
-/// RawWaker: fat ptr (*const (), &'static RawWakerVTable)
-/// &'scope dyn Wake fat ptr: (&'scope (), &'scope WakeVTable)
+/// Coerces a pinned `AtomicValueGuard` reference to a `Waker` for use in
+/// `core::future::Future`
 ///
-/// can transmute between them, but the waker will be completely invalid!
+/// Any usage or storage of the resulting `Waker` is undefined behavior.
+pub unsafe fn guard_to_waker(guard: Pin<&AtomicValueGuard<fn()>>) -> Waker {
+    unsafe {
+        Waker::from_raw(RawWaker::new(
+            guard.get_ref() as *const AtomicValueGuard<fn()> as *const (),
+            &EVIL_VTABLE,
+        ))
+    }
+}
 
-/// wraps an internal ScopedFuture, implements Future
-pub struct ScopedFutureWrapper<'scope, F: ScopedFuture<'scope>> {
-    inner: UnsafeCell<F>,
-    marker: PhantomData<&'scope ()>,
+/// Coerces a `Waker` into a pinned `AtomicValueGuard` reference.
+///
+/// This should only be used to undo the work of `guard_to_waker`.
+pub unsafe fn waker_to_guard<'a>(
+    waker: Waker,
+) -> Pin<&'a AtomicValueGuard<fn()>> {
+    unsafe {
+        Pin::new_unchecked(&*(waker.data() as *const AtomicValueGuard<fn()>))
+    }
 }
 
-impl<'scope, F: ScopedFuture<'scope> + 'scope> Future
-    for ScopedFutureWrapper<'scope, F>
-{
+/// wraps `core::future::Future` in impl of `bcsc:Future`
+#[repr(transparent)]
+pub struct NormalFutureWrapper<F: core::future::Future>(F);
+
+impl<F: core::future::Future> futures_core::Future for NormalFutureWrapper<F> {
     type Output = F::Output;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        // # Safety
-        //
-        // Transmutes `Waker` into `&'scope dyn Wake`.
-        // This is possible because Waker (internally just RawWaker) contains
-        // (*const (), &'static RawWakerVTable), and the fat ptr `&dyn Wake`
-        // internally is (*const (), *const WakeVTable).
-        //
-        // For this to be sound, the input waker from `cx` must be an invalid
-        // waker (using the waker as intended would be UB) that has the form of
-        // a `&dyn Wake` fat ptr, as generated in `UnscopedFutureWrapper`.
-        //
-        // This is only sound because it is paired with the transmute in
-        // `UnscopedFutureWrapper`
-        //
-        // This conversion is necessary to piggyback off rustc's expansion
-        // of `async` blocks into state machines implementing `Future`.
-        //
-        // The unpinning is safe because inner (a `ScopedFuture`) cannot be
-        // moved after a self reference is established on its first `poll`.
-        //
-        // The use of the `UnsafeCell` is sound and necessary to get around
-        // the afformentioned immutable self reference (since `Future::poll`)
-        // requires a `&mut Self`. It is sound because we never take a
-        // `&mut self.inner`.
-        unsafe {
-            let this = self.get_unchecked_mut();
-            let wake: &'scope dyn Wake = mem::transmute::<
-                Waker,
-                &'scope dyn Wake,
-            >(cx.waker().to_owned());
-            (&*this.inner.get()).poll(wake)
-        }
+        unsafe { self.map_unchecked_mut(|this| &mut this.0).poll(cx) }
     }
 }
 
-impl<'scope, F: ScopedFuture<'scope> + 'scope> ScopedFutureWrapper<'scope, F> {
-    pub unsafe fn from_scoped(f: F) -> Self {
-        Self {
-            inner: f.into(),
-            marker: PhantomData,
-        }
+impl<F: core::future::Future> NormalFutureWrapper<F> {
+    pub unsafe fn from_std_future(future: F) -> Self {
+        Self(future)
     }
 }
 
-/// wraps an internal Future, implements ScopedFuture
-/// this is fundamentally unsafe and relies on the future not registering its waker
-/// in any reactor that lives beyond this wrapper, otherwise there will be a dangling pointer
-///
-/// it is safe to use only with the #[async_scoped] macro, which guarantees that, internally, every futures is a ScopedFutureWrapper
-pub struct UnscopedFutureWrapper<'scope, F: Future> {
-    inner: UnsafeCell<F>,
-    marker: PhantomData<&'scope ()>,
-}
+/// wraps custom `bcsc::Future` in impl of `core::future::Future`
+#[repr(transparent)]
+pub struct CustomFutureWrapper<F: futures_core::Future>(F);
 
-impl<'scope, F: Future + 'scope> ScopedFuture<'scope>
-    for UnscopedFutureWrapper<'scope, F>
-{
+impl<F: futures_core::Future> core::future::Future for CustomFutureWrapper<F> {
     type Output = F::Output;
 
-    fn poll(
-        self: &'scope Self,
-        wake: &'scope dyn Wake<'scope>,
-    ) -> Poll<Self::Output> {
-        // # Safety
-        //
-        // Transmutes `&'scope dyn Wake` into a Waker.
-        // This is possible because Waker (internally just RawWaker) contains
-        // (*const (), &'static RawWakerVTable), and the fat ptr `&dyn Wake`
-        // internally is (*const (), *const WakeVTable).
-        //
-        // Using the resulting Waker is UB, which is why UnscopedFutureWrapper
-        // can only be used in pair with ScopedFutureWrapper, which transmutes
-        // the invalid `Waker` back to a `&dyn Wake`.
-        //
-        // This conversion is necessary to piggyback off rustc's expansion
-        // of `async` blocks into state machines implementing `Future`.
-        let waker: Waker =
-            unsafe { mem::transmute::<&'scope dyn Wake<'scope>, Waker>(wake) };
-        // # Safety
-        //
-        // Once any ScopedFuture is first polled and stores a waker, it becomes
-        // immutable and immovable because it has an immutable self reference.
-        //
-        // The Pin::new_unchecked is necessary to be compatible with
-        // `task::Future`
-        let pinned_future =
-            unsafe { Pin::new_unchecked(&mut *self.inner.get()) };
-
-        pinned_future.poll(&mut Context::from_waker(&waker))
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        unsafe { self.map_unchecked_mut(|this| &mut this.0).poll(cx) }
     }
 }
 
-impl<'scope, F: Future + 'scope> UnscopedFutureWrapper<'scope, F> {
-    pub unsafe fn from_future(f: F) -> Self {
-        Self {
-            inner: f.into(),
-            marker: PhantomData,
-        }
+impl<F: futures_core::Future> CustomFutureWrapper<F> {
+    pub unsafe fn from_custom_future(future: F) -> Self {
+        Self(future)
     }
 }

futures-core/src/lib.rs

···
-use std::{pin::Pin, task::Poll};
+//! Redefinitions of task::Future to be incompatible with them
 
-mod task;
+use std::{
+    ops,
+    pin::Pin,
+    task::{Context, Poll},
+};
 
-pub use crate::task::Wake;
-
-/// ScopedFuture represents a unit of asynchronous computation that must be
-/// polled by an external actor.
+/// A future represents an asynchronous computation obtained by use of `async`.
 ///
-/// Implementations access a context (`cx: &'scope dyn Wake`) to signal
-/// they are ready to resume execution.
-///
-/// A notable difference between `bcsc::ScopedFuture` and `core::task::Future`
-/// is the latter cannot safetly ran as a task by an executor without having a
-/// 'static lifetime. This is because there is no way for the compiler to
-/// guarantee the task doesn't outlive any data, as the executor is free to
-/// cancel it (or refuse to) whenever it wants.
+/// This future assumes a nonstandard Context, which is incompatible with
+/// executors or reactors made for `core::future::Future`. In the interest of
+/// safety, it has a dedicated type.
 ///
-/// Additionally, because raw/unsafe implementations of `core::task::Waker`
-/// effectively do lifetime-erasure, stack-allocated futures cannot prevent
-/// unsound behavior from wakers outliving them (even `Forget` would not
-/// entirely fix this due to the api).
+/// A future is a value that might not have finished computing yet. This kind of
+/// "asynchronous value" makes it possible for a thread to continue doing useful
+/// work while it waits for the value to become available.
 ///
-/// In order to avoid unsound behavior, executors must either use Weak<Wake>
-/// for safetly losing access to tasks or enforce tasks being stored in
-/// `static` pools of memory.
+/// # The `poll` method
 ///
-/// `ScopedFuture` instead leverages the borrow checker to allow for (less
-/// powerful) stack based async execution.
+/// The core method of future, `poll`, *attempts* to resolve the future into a
+/// final value. This method does not block if the value is not ready. Instead,
+/// the current task is scheduled to be woken up when it's possible to make
+/// further progress by `poll`ing again. The `context` passed to the `poll`
+/// method can provide a [`Waker`], which is a handle for waking up the current
+/// task.
 ///
-/// some more:
-/// what occurs in `core::task::Future::poll()` is that the ref to a cx.waker
-/// is cloned and stored by a reactor via some method.
+/// When using a future, you generally won't call `poll` directly, but instead
+/// `.await` the value.
 ///
-/// 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.
+/// [`Waker`]: crate::task::Waker
 #[must_use = "futures do nothing unless you `.await` or poll them"]
 #[diagnostic::on_unimplemented(
-    message = "`{Self}` is not a `ScopedFuture`",
-    label = "`{Self}` is not a `ScopedFuture`",
-    note = "If you are trying to await a `task::Future` from within a `ScopedFuture`, note that the systems are incompatible."
+    label = "`{Self}` is not a `bcsc::Future`",
+    message = "`{Self}` is not a `bcsc::Future`",
+    note = "If you are trying to await a `core::future::Future` from within a `bcsc::Future`, note that the systems are incompatible."
 )]
-pub trait ScopedFuture<'scope> {
+pub trait Future {
+    /// The type of value produced on completion.
     type Output;
 
-    /// as soon as poll is called, the struct becomes self-referential,
-    /// effectively pinned until dropped (or forgotten....D; )
-    fn poll<'events>(
-        self: Pin<&mut Self>,
-        wake: &'events dyn Wake<'scope>,
-    ) -> Poll<Self::Output>
-    where
-        'events: 'scope;
+    /// Attempts to resolve the future to a final value, registering
+    /// the current task for wakeup if the value is not yet available.
+    ///
+    /// # Return value
+    ///
+    /// This function returns:
+    ///
+    /// - [`Poll::Pending`] if the future is not ready yet
+    /// - [`Poll::Ready(val)`] with the result `val` of this future if it
+    ///   finished successfully.
+    ///
+    /// Once a future has finished, clients should not `poll` it again.
+    ///
+    /// When a future is not ready yet, `poll` returns `Poll::Pending` and
+    /// stores a clone of the [`Waker`] copied from the current [`Context`].
+    /// This [`Waker`] is then woken once the future can make progress.
+    /// For example, a future waiting for a socket to become
+    /// readable would call `.clone()` on the [`Waker`] and store it.
+    /// When a signal arrives elsewhere indicating that the socket is readable,
+    /// [`Waker::wake`] is called and the socket future's task is awoken.
+    /// Once a task has been woken up, it should attempt to `poll` the future
+    /// again, which may or may not produce a final value.
+    ///
+    /// Note that on multiple calls to `poll`, only the [`Waker`] from the
+    /// [`Context`] passed to the most recent call should be scheduled to
+    /// receive a wakeup.
+    ///
+    /// # Runtime characteristics
+    ///
+    /// Futures alone are *inert*; they must be *actively* `poll`ed to make
+    /// progress, meaning that each time the current task is woken up, it should
+    /// actively re-`poll` pending futures that it still has an interest in.
+    ///
+    /// The `poll` function is not called repeatedly in a tight loop -- instead,
+    /// it should only be called when the future indicates that it is ready to
+    /// make progress (by calling `wake()`). If you're familiar with the
+    /// `poll(2)` or `select(2)` syscalls on Unix it's worth noting that futures
+    /// typically do *not* suffer the same problems of "all wakeups must poll
+    /// all events"; they are more like `epoll(4)`.
+    ///
+    /// An implementation of `poll` should strive to return quickly, and should
+    /// not block. Returning quickly prevents unnecessarily clogging up
+    /// threads or event loops. If it is known ahead of time that a call to
+    /// `poll` may end up taking a while, the work should be offloaded to a
+    /// thread pool (or something similar) to ensure that `poll` can return
+    /// quickly.
+    ///
+    /// # Panics
+    ///
+    /// Once a future has completed (returned `Ready` from `poll`), calling its
+    /// `poll` method again may panic, block forever, or cause other kinds of
+    /// problems; the `Future` trait places no requirements on the effects of
+    /// such a call. However, as the `poll` method is not marked `unsafe`,
+    /// Rust's usual rules apply: calls must never cause undefined behavior
+    /// (memory corruption, incorrect use of `unsafe` functions, or the like),
+    /// regardless of the future's state.
+    ///
+    /// [`Poll::Ready(val)`]: Poll::Ready
+    /// [`Waker`]: crate::task::Waker
+    /// [`Waker::wake`]: crate::task::Waker::wake
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
+}
+
+impl<F: ?Sized + Future + Unpin> Future for &mut F {
+    type Output = F::Output;
+
+    fn poll(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Self::Output> {
+        F::poll(Pin::new(&mut **self), cx)
+    }
+}
+
+impl<P> Future for Pin<P>
+where
+    P: ops::DerefMut<Target: Future>,
+{
+    type Output = <<P as ops::Deref>::Target as Future>::Output;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        <P::Target as Future>::poll(self.as_deref_mut(), cx)
+    }
 }

futures-core/src/task.rs

···
-// Task: Wake
-//
-// Wake must not outlive event loop/storage
-pub trait Wake<'events> {
-    fn wake(&self);
-}

futures-util/Cargo.toml

···
 homepage.workspace = true
 
 [dependencies]
-futures-core = { workspace = true }

futures/Cargo.toml

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