f remove unnecessary pub

Author: TheBlueMatt

lightning-types/src/features.rs

@@ -96,7 +96,7 @@ use core::{cmp, fmt};
 use alloc::vec::Vec;
 
 mod sealed {
-	use super::{FeatureFlags, Features};
+	use super::Features;
 
 	/// The context in which [`Features`] are applicable. Defines which features are known to the
 	/// implementation, though specification of them as required or optional is up to the code
@@ -310,54 +310,54 @@ mod sealed {
 
 				/// Sets the feature's required (even) bit in the given flags.
 				#[inline]
-				fn set_required_bit(flags: &mut FeatureFlags) {
-					if flags.len() <= Self::BYTE_OFFSET {
-						flags.resize(Self::BYTE_OFFSET + 1, 0u8);
+				fn set_required_bit(obj: &mut Features<Self>) {
+					if obj.flags.len() <= Self::BYTE_OFFSET {
+						obj.flags.resize(Self::BYTE_OFFSET + 1, 0u8);
 					}
 
-					flags[Self::BYTE_OFFSET] |= Self::REQUIRED_MASK;
-					flags[Self::BYTE_OFFSET] &= !Self::OPTIONAL_MASK;
+					obj.flags[Self::BYTE_OFFSET] |= Self::REQUIRED_MASK;
+					obj.flags[Self::BYTE_OFFSET] &= !Self::OPTIONAL_MASK;
 				}
 
 				/// Sets the feature's optional (odd) bit in the given flags.
 				#[inline]
-				fn set_optional_bit(flags: &mut FeatureFlags) {
-					if flags.len() <= Self::BYTE_OFFSET {
-						flags.resize(Self::BYTE_OFFSET + 1, 0u8);
+				fn set_optional_bit(obj: &mut Features<Self>) {
+					if obj.flags.len() <= Self::BYTE_OFFSET {
+						obj.flags.resize(Self::BYTE_OFFSET + 1, 0u8);
 					}
 
-					flags[Self::BYTE_OFFSET] |= Self::OPTIONAL_MASK;
+					obj.flags[Self::BYTE_OFFSET] |= Self::OPTIONAL_MASK;
 				}
 
 				/// Clears the feature's required (even) and optional (odd) bits from the given
 				/// flags.
 				#[inline]
-				fn clear_bits(flags: &mut FeatureFlags) {
-					if flags.len() > Self::BYTE_OFFSET {
-						flags[Self::BYTE_OFFSET] &= !Self::REQUIRED_MASK;
-						flags[Self::BYTE_OFFSET] &= !Self::OPTIONAL_MASK;
+				fn clear_bits(obj: &mut Features<Self>) {
+					if obj.flags.len() > Self::BYTE_OFFSET {
+						obj.flags[Self::BYTE_OFFSET] &= !Self::REQUIRED_MASK;
+						obj.flags[Self::BYTE_OFFSET] &= !Self::OPTIONAL_MASK;
 					}
 
-					let last_non_zero_byte = flags.iter().rposition(|&byte| byte != 0);
+					let last_non_zero_byte = obj.flags.iter().rposition(|&byte| byte != 0);
 					let size = if let Some(offset) = last_non_zero_byte { offset + 1 } else { 0 };
-					flags.resize(size, 0u8);
+					obj.flags.resize(size, 0u8);
 				}
 			}
 
 			impl <T: $feature> Features<T> {
 				/// Set this feature as optional.
 				pub fn $optional_setter(&mut self) {
-					<T as $feature>::set_optional_bit(&mut self.flags);
+					<T as $feature>::set_optional_bit(self);
 				}
 
 				/// Set this feature as required.
 				pub fn $required_setter(&mut self) {
-					<T as $feature>::set_required_bit(&mut self.flags);
+					<T as $feature>::set_required_bit(self);
 				}
 
 				/// Unsets this feature.
 				pub fn $clear(&mut self) {
-					<T as $feature>::clear_bits(&mut self.flags);
+					<T as $feature>::clear_bits(self);
 				}
 
 				/// Checks if this feature is supported.
@@ -718,15 +718,20 @@ const DIRECT_ALLOC_BYTES: usize = if sealed::MIN_FEATURES_ALLOCATION_BYTES > 8 *
 };
 const _ASSERT: () = assert!(DIRECT_ALLOC_BYTES <= u8::MAX as usize);
 
-/// The internal storage for feature flags. Public only for the [`sealed`] feature flag traits but
-/// generally should never be used directly.
+#[cfg(fuzzing)]
 #[derive(Clone, PartialEq, Eq)]
-#[doc(hidden)]
 pub enum FeatureFlags {
 	Held { bytes: [u8; DIRECT_ALLOC_BYTES], len: u8 },
 	Heap(Vec<u8>),
 }
 
+#[cfg(not(fuzzing))]
+#[derive(Clone, PartialEq, Eq)]
+enum FeatureFlags {
+	Held { bytes: [u8; DIRECT_ALLOC_BYTES], len: u8 },
+	Heap(Vec<u8>),
+}
+
 impl FeatureFlags {
 	fn empty() -> Self {
 		Self::Held { bytes: [0; DIRECT_ALLOC_BYTES], len: 0 }
@@ -826,7 +831,7 @@ impl fmt::Debug for FeatureFlags {
 ///
 /// This is not exported to bindings users as we map the concrete feature types below directly instead
 #[derive(Eq)]
-pub struct Features<T: sealed::Context> {
+pub struct Features<T: sealed::Context + ?Sized> {
 	/// Note that, for convenience, flags is LITTLE endian (despite being big-endian on the wire)
 	flags: FeatureFlags,
 	mark: PhantomData<T>,
@@ -865,7 +870,7 @@ impl<T: sealed::Context> Hash for Features<T> {
 		nonzero_flags.hash(hasher);
 	}
 }
-impl<T: sealed::Context> PartialEq for Features<T> {
+impl<T: sealed::Context + ?Sized> PartialEq for Features<T> {
 	fn eq(&self, o: &Self) -> bool {
 		let mut o_iter = o.flags.iter();
 		let mut self_iter = self.flags.iter();
@@ -1000,17 +1005,15 @@ impl ChannelTypeFeatures {
 	/// Constructs a ChannelTypeFeatures with only static_remotekey set
 	pub fn only_static_remote_key() -> Self {
 		let mut ret = Self::empty();
-		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret.flags);
+		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret);
 		ret
 	}
 
 	/// Constructs a ChannelTypeFeatures with anchors support
 	pub fn anchors_zero_htlc_fee_and_dependencies() -> Self {
 		let mut ret = Self::empty();
-		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret.flags);
-		<sealed::ChannelTypeContext as sealed::AnchorsZeroFeeHtlcTx>::set_required_bit(
-			&mut ret.flags,
-		);
+		<sealed::ChannelTypeContext as sealed::StaticRemoteKey>::set_required_bit(&mut ret);
+		<sealed::ChannelTypeContext as sealed::AnchorsZeroFeeHtlcTx>::set_required_bit(&mut ret);
 		ret
 	}
 }

lightning-types/src/lib.rs

@@ -14,7 +14,7 @@
 //! See the `lightning` crate for usage of these.
 
 #![cfg_attr(not(test), no_std)]
-#![deny(missing_docs)]
+#![cfg_attr(not(fuzzing), deny(missing_docs))]
 #![forbid(unsafe_code)]
 #![deny(rustdoc::broken_intra_doc_links)]
 #![deny(rustdoc::private_intra_doc_links)]