Doc and build warning fixes

fuzz/src/full_stack.rs

@@ -42,7 +42,7 @@ use lightning::ln::msgs::{self, DecodeError};
 use lightning::ln::script::ShutdownScript;
 use lightning::routing::gossip::{P2PGossipSync, NetworkGraph};
 use lightning::routing::utxo::UtxoLookup;
-use lightning::routing::router::{find_route, InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, Router};
+use lightning::routing::router::{find_route, InFlightHtlcs, PaymentParameters, Route, RouteParameters, Router};
 use lightning::routing::scoring::FixedPenaltyScorer;
 use lightning::util::config::UserConfig;
 use lightning::util::errors::APIError;

lightning-background-processor/src/lib.rs

@@ -33,7 +33,9 @@ use lightning::routing::gossip::{NetworkGraph, P2PGossipSync};
 use lightning::routing::utxo::UtxoLookup;
 use lightning::routing::router::Router;
 use lightning::routing::scoring::{Score, WriteableScore};
-use lightning::util::events::{Event, EventHandler, EventsProvider, PathFailure};
+use lightning::util::events::{Event, PathFailure};
+#[cfg(feature = "std")]
+use lightning::util::events::{EventHandler, EventsProvider};
 use lightning::util::logger::Logger;
 use lightning::util::persist::Persister;
 use lightning_rapid_gossip_sync::RapidGossipSync;

lightning-block-sync/src/lib.rs

@@ -132,6 +132,9 @@ impl BlockSourceError {
 	}
 
 	/// Converts the error into the underlying error.
+	///
+	/// May contain an [`std::io::Error`] from the [`BlockSource`]. See implementations for further
+	/// details, if any.
 	pub fn into_inner(self) -> Box<dyn std::error::Error + Send + Sync> {
 		self.error
 	}

lightning-block-sync/src/rpc.rs

@@ -35,6 +35,9 @@ impl fmt::Display for RpcError {
 impl Error for RpcError {}
 
 /// A simple RPC client for calling methods using HTTP `POST`.
+///
+/// Implements [`BlockSource`] and may return an `Err` containing [`RpcError`]. See
+/// [`RpcClient::call_method`] for details.
 pub struct RpcClient {
 	basic_auth: String,
 	endpoint: HttpEndpoint,
@@ -57,6 +60,9 @@ impl RpcClient {
 	}
 
 	/// Calls a method with the response encoded in JSON format and interpreted as type `T`.
+	///
+	/// When an `Err` is returned, [`std::io::Error::into_inner`] may contain an [`RpcError`] if
+	/// [`std::io::Error::kind`] is [`std::io::ErrorKind::Other`].
 	pub async fn call_method<T>(&self, method: &str, params: &[serde_json::Value]) -> std::io::Result<T>
 	where JsonResponse: TryFrom<Vec<u8>, Error = std::io::Error> + TryInto<T, Error = std::io::Error> {
 		let host = format!("{}:{}", self.endpoint.host(), self.endpoint.port());

lightning-rapid-gossip-sync/src/processing.rs

@@ -42,7 +42,7 @@ impl<NG: Deref<Target=NetworkGraph<L>>, L: Deref> RapidGossipSync<NG, L> where L
 		&self,
 		read_cursor: &mut R,
 	) -> Result<u32, GraphSyncError> {
-		#[allow(unused_mut)]
+		#[allow(unused_mut, unused_assignments)]
 		let mut current_time_unix = None;
 		#[cfg(all(feature = "std", not(test)))]
 		{

lightning/src/ln/channelmanager.rs

@@ -13,11 +13,9 @@
 //! responsible for tracking which channels are open, HTLCs are in flight and reestablishing those
 //! upon reconnect to the relevant peer(s).
 //!
-//! It does not manage routing logic (see [`find_route`] for that) nor does it manage constructing
+//! It does not manage routing logic (see [`Router`] for that) nor does it manage constructing
 //! on-chain transactions (it only monitors the chain to watch for any force-closes that might
 //! imply it needs to fail HTLCs/payments/channels it manages).
-//!
-//! [`find_route`]: crate::routing::router::find_route
 
 use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::transaction::Transaction;
@@ -1745,14 +1743,12 @@ where
 		self.list_channels_with_filter(|_| true)
 	}
 
-	/// Gets the list of usable channels, in random order. Useful as an argument to [`find_route`]
-	/// to ensure non-announced channels are used.
+	/// Gets the list of usable channels, in random order. Useful as an argument to
+	/// [`Router::find_route`] to ensure non-announced channels are used.
 	///
 	/// These are guaranteed to have their [`ChannelDetails::is_usable`] value set to true, see the
 	/// documentation for [`ChannelDetails::is_usable`] for more info on exactly what the criteria
 	/// are.
-	///
-	/// [`find_route`]: crate::routing::router::find_route
 	pub fn list_usable_channels(&self) -> Vec<ChannelDetails> {
 		// Note we use is_live here instead of usable which leads to somewhat confused
 		// internal/external nomenclature, but that's ok cause that's probably what the user
@@ -3986,7 +3982,7 @@ where
 			None => None
 		};
 
-		let mut peer_state_opt = counterparty_node_id_opt.as_ref().map(
+		let peer_state_opt = counterparty_node_id_opt.as_ref().map(
 			|counterparty_node_id| per_peer_state.get(counterparty_node_id).map(
 				|peer_mutex| peer_mutex.lock().unwrap()
 			)

lightning/src/ln/outbound_payment.rs

@@ -276,7 +276,11 @@ pub(crate) struct PaymentAttemptsUsingTime<T: Time> {
 	/// it means the result of the first attempt is not known yet.
 	pub(crate) count: usize,
 	/// This field is only used when retry is `Retry::Timeout` which is only build with feature std
-	first_attempted_at: T
+	#[cfg(not(feature = "no-std"))]
+	first_attempted_at: T,
+	#[cfg(feature = "no-std")]
+	phantom: core::marker::PhantomData<T>,
+
 }
 
 #[cfg(not(any(feature = "no-std", test)))]
@@ -290,7 +294,10 @@ impl<T: Time> PaymentAttemptsUsingTime<T> {
 	pub(crate) fn new() -> Self {
 		PaymentAttemptsUsingTime {
 			count: 0,
-			first_attempted_at: T::now()
+			#[cfg(not(feature = "no-std"))]
+			first_attempted_at: T::now(),
+			#[cfg(feature = "no-std")]
+			phantom: core::marker::PhantomData,
 		}
 	}
 }

lightning/src/sync/debug_sync.rs

@@ -129,7 +129,7 @@ impl LockMetadata {
 			// For each lock which is currently locked, check that no lock's locked-before
 			// set includes the lock we're about to lock, which would imply a lockorder
 			// inversion.
-			for (locked_idx, locked) in held.borrow().iter() {
+			for (locked_idx, _locked) in held.borrow().iter() {
 				if *locked_idx == this.lock_idx {
 					// Note that with `feature = "backtrace"` set, we may be looking at different
 					// instances of the same lock. Still, doing so is quite risky, a total order
@@ -143,7 +143,7 @@ impl LockMetadata {
 					panic!("Tried to acquire a lock while it was held!");
 				}
 			}
-			for (locked_idx, locked) in held.borrow().iter() {
+			for (_locked_idx, locked) in held.borrow().iter() {
 				for (locked_dep_idx, _locked_dep) in locked.locked_before.lock().unwrap().iter() {
 					if *locked_dep_idx == this.lock_idx && *locked_dep_idx != locked.lock_idx {
 						#[cfg(feature = "backtrace")]

lightning/src/sync/fairrwlock.rs

@@ -45,6 +45,7 @@ impl<T> FairRwLock<T> {
 		self.lock.read()
 	}
 
+	#[allow(dead_code)]
 	pub fn try_write(&self) -> TryLockResult<RwLockWriteGuard<'_, T>> {
 		self.lock.try_write()
 	}

lightning/src/sync/test_lockorder_checks.rs

@@ -3,7 +3,6 @@ use crate::sync::debug_sync::{RwLock, Mutex};
 use super::{LockHeldState, LockTestExt};
 
 use std::sync::Arc;
-use std::thread;
 
 #[test]
 #[should_panic]