Remove `futures` dependency in `lightning-background-processor`

As `futures` apparently makes no guarantees on MSRVs even in patch
releases we really can't rely on it at all, and while it currently
has an acceptable MSRV without the macros feature, its best to just
remove it wholesale.

Luckily, removing it is relatively trivial, even if it requires
the most trivial of unsafe tags.

diff --git a/lightning-background-processor/Cargo.toml b/lightning-background-processor/Cargo.toml
index fe4f272385832f1798d04415313fc876d3870ede..af8bb25e55f558ed7a277712981da5c99b968581 100644 (file)
--- a/lightning-background-processor/Cargo.toml
+++ b/lightning-background-processor/Cargo.toml
@@ -14,7 +14,7 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-futures = [ "futures-util" ]
+futures = [ ]
 std = ["lightning/std", "lightning-rapid-gossip-sync/std"]
 
 default = ["std"]
@@ -23,7 +23,6 @@ default = ["std"]
 bitcoin = { version = "0.29.0", default-features = false }
 lightning = { version = "0.0.114", path = "../lightning", default-features = false }
 lightning-rapid-gossip-sync = { version = "0.0.114", path = "../lightning-rapid-gossip-sync", default-features = false }
-futures-util = { version = "0.3", default-features = false, optional = true }
 
 [dev-dependencies]
 lightning = { version = "0.0.114", path = "../lightning", features = ["_test_utils"] }

diff --git a/lightning-background-processor/src/lib.rs b/lightning-background-processor/src/lib.rs
index e15458d54b22c101c63d5961d11cd6182515e398..884a7c2266420eb17f568f5da4cb65d513f6cae1 100644 (file)
--- a/lightning-background-processor/src/lib.rs
+++ b/lightning-background-processor/src/lib.rs
@@ -7,7 +7,7 @@
 #![deny(private_intra_doc_links)]
 
 #![deny(missing_docs)]
-#![deny(unsafe_code)]
+#![cfg_attr(not(feature = "futures"), deny(unsafe_code))]
 
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
@@ -52,8 +52,6 @@ use std::thread::{self, JoinHandle};
 #[cfg(feature = "std")]
 use std::time::Instant;
 
-#[cfg(feature = "futures")]
-use futures_util::task;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 
@@ -385,38 +383,48 @@ macro_rules! define_run_body {
 }
 
 #[cfg(feature = "futures")]
-use core::future::Future;
-#[cfg(feature = "futures")]
-use core::task::Poll;
-#[cfg(feature = "futures")]
-use core::pin::Pin;
-#[cfg(feature = "futures")]
-use core::marker::Unpin;
-#[cfg(feature = "futures")]
-struct Selector<A: Future<Output=()> + Unpin, B: Future<Output=bool> + Unpin> {
-       a: A,
-       b: B,
-}
-#[cfg(feature = "futures")]
-enum SelectorOutput {
-       A, B(bool),
-}
+pub(crate) mod futures_util {
+       use core::future::Future;
+       use core::task::{Poll, Waker, RawWaker, RawWakerVTable};
+       use core::pin::Pin;
+       use core::marker::Unpin;
+       pub(crate) struct Selector<A: Future<Output=()> + Unpin, B: Future<Output=bool> + Unpin> {
+               pub a: A,
+               pub b: B,
+       }
+       pub(crate) enum SelectorOutput {
+               A, B(bool),
+       }
 
-#[cfg(feature = "futures")]
-impl<A: Future<Output=()> + Unpin, B: Future<Output=bool> + Unpin> Future for Selector<A, B> {
-       type Output = SelectorOutput;
-       fn poll(mut self: Pin<&mut Self>, ctx: &mut core::task::Context<'_>) -> Poll<SelectorOutput> {
-               match Pin::new(&mut self.a).poll(ctx) {
-                       Poll::Ready(()) => { return Poll::Ready(SelectorOutput::A); },
-                       Poll::Pending => {},
-               }
-               match Pin::new(&mut self.b).poll(ctx) {
-                       Poll::Ready(res) => { return Poll::Ready(SelectorOutput::B(res)); },
-                       Poll::Pending => {},
+       impl<A: Future<Output=()> + Unpin, B: Future<Output=bool> + Unpin> Future for Selector<A, B> {
+               type Output = SelectorOutput;
+               fn poll(mut self: Pin<&mut Self>, ctx: &mut core::task::Context<'_>) -> Poll<SelectorOutput> {
+                       match Pin::new(&mut self.a).poll(ctx) {
+                               Poll::Ready(()) => { return Poll::Ready(SelectorOutput::A); },
+                               Poll::Pending => {},
+                       }
+                       match Pin::new(&mut self.b).poll(ctx) {
+                               Poll::Ready(res) => { return Poll::Ready(SelectorOutput::B(res)); },
+                               Poll::Pending => {},
+                       }
+                       Poll::Pending
                }
-               Poll::Pending
        }
+
+       // If we want to poll a future without an async context to figure out if it has completed or
+       // not without awaiting, we need a Waker, which needs a vtable...we fill it with dummy values
+       // but sadly there's a good bit of boilerplate here.
+       fn dummy_waker_clone(_: *const ()) -> RawWaker { RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE) }
+       fn dummy_waker_action(_: *const ()) { }
+
+       const DUMMY_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(
+               dummy_waker_clone, dummy_waker_action, dummy_waker_action, dummy_waker_action);
+       pub(crate) fn dummy_waker() -> Waker { unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &DUMMY_WAKER_VTABLE)) } }
 }
+#[cfg(feature = "futures")]
+use futures_util::{Selector, SelectorOutput, dummy_waker};
+#[cfg(feature = "futures")]
+use core::task;
 
 /// Processes background events in a future.
 ///
@@ -517,7 +525,7 @@ where
                        }
                }, |t| sleeper(Duration::from_secs(t)),
                |fut: &mut SleepFuture, _| {
-                       let mut waker = task::noop_waker();
+                       let mut waker = dummy_waker();
                        let mut ctx = task::Context::from_waker(&mut waker);
                        core::pin::Pin::new(fut).poll(&mut ctx).is_ready()
                })