Remove duplicate specification of features

Features for a given context are duplicated throughout the features
module. Use a macro for defining a Context and the applicable features
such that features only need to be defined for a Context in one place.
The Context provides bitmasks for selecting known and unknown feature
flags.

Author: jkczyz

lightning/src/ln/features.rs

@@ -18,17 +18,106 @@ use std::marker::PhantomData;
 use ln::msgs::DecodeError;
 use util::ser::{Readable, Writeable, Writer};
 
-#[macro_use]
-mod sealed { // You should just use the type aliases instead.
-	pub struct InitContext {}
-	pub struct NodeContext {}
-	pub struct ChannelContext {}
-
-	/// An internal trait capturing the various feature context types
-	pub trait Context {}
-	impl Context for InitContext {}
-	impl Context for NodeContext {}
-	impl Context for ChannelContext {}
+mod sealed {
+	/// The context in which [`Features`] are applicable. Defines which features are supported.
+	///
+	/// [`Features`]: ../struct.Features.html
+	pub trait Context {
+		/// Features that are supported by the implementation, indicated by setting their
+		/// optional (odd) bits.
+		const SUPPORTED_FEATURE_FLAGS: &'static [u8];
+
+		/// Bitmask for selecting features that are known though not necessarily implemented.
+		const KNOWN_FEATURE_MASK: &'static [u8];
+
+		/// Bitmask for selecting features that are unknown to the implementation.
+		const UNKNOWN_FEATURE_MASK: &'static [u8];
+	}
+
+	/// Defines a [`Context`] by stating which features it does and does not support. Features are
+	/// specified as a comma-separated list of bytes where each byte is a pipe-delimited list of
+	/// feature identifiers.
+	///
+	/// [`Context`]: trait.Context.html
+	macro_rules! define_context {
+		($context: ident {
+			supported_features: [$( $( $supported_feature: ident )|*, )*],
+			unsupported_features: [$( $( $unsupported_feature: ident )|*, )*],
+		}) => {
+			pub struct $context {}
+
+			impl Context for $context {
+				const SUPPORTED_FEATURE_FLAGS: &'static [u8] = &[
+					$(
+						0b00_00_00_00 $(| <Self as $supported_feature>::OPTIONAL_MASK)*,
+					)*
+				];
+
+				const KNOWN_FEATURE_MASK: &'static [u8] = &[
+					$(
+						0b00_00_00_00 $(|
+							<Self as $supported_feature>::REQUIRED_MASK |
+							<Self as $supported_feature>::OPTIONAL_MASK)*
+						$(|
+							<Self as $unsupported_feature>::REQUIRED_MASK |
+							<Self as $unsupported_feature>::OPTIONAL_MASK)*,
+					)*
+				];
+
+				const UNKNOWN_FEATURE_MASK: &'static [u8] = &[
+					$(
+						0b11_11_11_11 $(&
+							!<Self as $supported_feature>::REQUIRED_MASK &
+							!<Self as $supported_feature>::OPTIONAL_MASK)*
+						$(&
+							!<Self as $unsupported_feature>::REQUIRED_MASK &
+							!<Self as $unsupported_feature>::OPTIONAL_MASK)*,
+					)*
+				];
+			}
+		};
+	}
+
+	define_context!(InitContext {
+		supported_features: [
+			// Byte 0
+			DataLossProtect | UpfrontShutdownScript,
+			// Byte 1
+			VariableLengthOnion | PaymentSecret,
+			// Byte 2
+			BasicMPP,
+		],
+		unsupported_features: [
+			// Byte 0
+			InitialRoutingSync,
+			// Byte 1
+			,
+			// Byte 2
+			,
+		],
+	});
+	define_context!(NodeContext {
+		supported_features: [
+			// Byte 0
+			DataLossProtect | UpfrontShutdownScript,
+			// Byte 1
+			VariableLengthOnion | PaymentSecret,
+			// Byte 2
+			BasicMPP,
+		],
+		unsupported_features: [
+			// Byte 0
+			,
+			// Byte 1
+			,
+			// Byte 2
+			,
+		],
+	});
+	define_context!(ChannelContext {
+		supported_features: [],
+		unsupported_features: [],
+	});
 
 	/// Defines a feature with the given bits for the specified [`Context`]s. The generated trait is
 	/// useful for manipulating feature flags.
@@ -120,20 +209,6 @@ mod sealed { // You should just use the type aliases instead.
 		"Feature flags for `payment_secret`.");
 	define_feature!(16, 17, BasicMPP, [InitContext, NodeContext],
 		"Feature flags for `basic_mpp`.");
-
-	/// Generates a feature flag byte with the given features set as optional. Useful for initializing
-	/// the flags within [`Features`].
-	///
-	/// [`Features`]: struct.Features.html
-	macro_rules! feature_flags {
-		($context: ty; $($feature: ident)|*) => {
-			(0b00_00_00_00
-				$(
-					| <$context as sealed::$feature>::OPTIONAL_MASK
-				)*
-			)
-		}
-	}
 }
 
 /// Tracks the set of features which a node implements, templated by the context in which it
@@ -171,18 +246,6 @@ pub type NodeFeatures = Features<sealed::NodeContext>;
 pub type ChannelFeatures = Features<sealed::ChannelContext>;
 
 impl InitFeatures {
-	/// Create a Features with the features we support
-	pub fn supported() -> InitFeatures {
-		InitFeatures {
-			flags: vec![
-				feature_flags![sealed::InitContext; DataLossProtect | UpfrontShutdownScript],
-				feature_flags![sealed::InitContext; VariableLengthOnion | PaymentSecret],
-				feature_flags![sealed::InitContext; BasicMPP],
-			],
-			mark: PhantomData,
-		}
-	}
-
 	/// Writes all features present up to, and including, 13.
 	pub(crate) fn write_up_to_13<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		let len = cmp::min(2, self.flags.len());
@@ -212,22 +275,6 @@ impl InitFeatures {
 }
 
 impl ChannelFeatures {
-	/// Create a Features with the features we support
-	#[cfg(not(feature = "fuzztarget"))]
-	pub(crate) fn supported() -> ChannelFeatures {
-		ChannelFeatures {
-			flags: Vec::new(),
-			mark: PhantomData,
-		}
-	}
-	#[cfg(feature = "fuzztarget")]
-	pub fn supported() -> ChannelFeatures {
-		ChannelFeatures {
-			flags: Vec::new(),
-			mark: PhantomData,
-		}
-	}
-
 	/// Takes the flags that we know how to interpret in an init-context features that are also
 	/// relevant in a channel-context features and creates a channel-context features from them.
 	pub(crate) fn with_known_relevant_init_flags(_init_ctx: &InitFeatures) -> Self {
@@ -237,54 +284,17 @@ impl ChannelFeatures {
 }
 
 impl NodeFeatures {
-	/// Create a Features with the features we support
-	#[cfg(not(feature = "fuzztarget"))]
-	pub(crate) fn supported() -> NodeFeatures {
-		NodeFeatures {
-			flags: vec![
-				feature_flags![sealed::NodeContext; DataLossProtect | UpfrontShutdownScript],
-				feature_flags![sealed::NodeContext; VariableLengthOnion | PaymentSecret],
-				feature_flags![sealed::NodeContext; BasicMPP],
-			],
-			mark: PhantomData,
-		}
-	}
-	#[cfg(feature = "fuzztarget")]
-	pub fn supported() -> NodeFeatures {
-		NodeFeatures {
-			flags: vec![
-				feature_flags![sealed::NodeContext; DataLossProtect | UpfrontShutdownScript],
-				feature_flags![sealed::NodeContext; VariableLengthOnion | PaymentSecret],
-				feature_flags![sealed::NodeContext; BasicMPP],
-			],
-			mark: PhantomData,
-		}
-	}
-
 	/// Takes the flags that we know how to interpret in an init-context features that are also
 	/// relevant in a node-context features and creates a node-context features from them.
 	/// Be sure to blank out features that are unknown to us.
 	pub(crate) fn with_known_relevant_init_flags(init_ctx: &InitFeatures) -> Self {
-		// Generates a bitmask with both even and odd bits set for the given features. Bitwise
-		// AND-ing it with a byte will select only common features.
-		macro_rules! features_including {
-			($($feature: ident)|*) => {
-				(0b00_00_00_00
-					$(
-						| <sealed::NodeContext as sealed::$feature>::REQUIRED_MASK
-						| <sealed::NodeContext as sealed::$feature>::OPTIONAL_MASK
-					)*
-				)
-			}
-		}
+		use ln::features::sealed::Context;
+		let byte_count = sealed::NodeContext::KNOWN_FEATURE_MASK.len();
 
 		let mut flags = Vec::new();
-		for (i, feature_byte)in init_ctx.flags.iter().enumerate() {
-			match i {
-				0 => flags.push(feature_byte & features_including![DataLossProtect | UpfrontShutdownScript]),
-				1 => flags.push(feature_byte & features_including![VariableLengthOnion | PaymentSecret]),
-				2 => flags.push(feature_byte & features_including![BasicMPP]),
-				_ => (),
+		for (i, feature_byte) in init_ctx.flags.iter().enumerate() {
+			if i < byte_count {
+				flags.push(feature_byte & sealed::NodeContext::KNOWN_FEATURE_MASK[i]);
 			}
 		}
 		Self { flags, mark: PhantomData, }
@@ -300,6 +310,14 @@ impl<T: sealed::Context> Features<T> {
 		}
 	}
 
+	/// Creates features supported by the implementation.
+	pub fn supported() -> Features<T> {
+		Self {
+			flags: T::SUPPORTED_FEATURE_FLAGS.to_vec(),
+			mark: PhantomData,
+		}
+	}
+
 	#[cfg(test)]
 	/// Create a Features given a set of flags, in LE.
 	pub fn from_le_bytes(flags: Vec<u8>) -> Features<T> {
@@ -316,49 +334,35 @@ impl<T: sealed::Context> Features<T> {
 	}
 
 	pub(crate) fn requires_unknown_bits(&self) -> bool {
-		// Generates a bitmask with all even bits set except for the given features. Bitwise
-		// AND-ing it with a byte will select unknown required features.
-		macro_rules! features_excluding {
-			($($feature: ident)|*) => {
-				(0b01_01_01_01
-					$(
-						& !(<sealed::InitContext as sealed::$feature>::REQUIRED_MASK)
-					)*
-				)
-			}
-		}
-
-		self.flags.iter().enumerate().any(|(idx, &byte)| {
-			(match idx {
-				0 => (byte & features_excluding![DataLossProtect | InitialRoutingSync | UpfrontShutdownScript]),
-				1 => (byte & features_excluding![VariableLengthOnion | PaymentSecret]),
-				2 => (byte & features_excluding![BasicMPP]),
-				_ => (byte & features_excluding![]),
-			}) != 0
+		use ln::features::sealed::Context;
+		let byte_count = sealed::InitContext::UNKNOWN_FEATURE_MASK.len();
+
+		// Bitwise AND-ing with all even bits set except for known features will select unknown
+		// required features.
+		self.flags.iter().enumerate().any(|(i, &byte)| {
+			let required_features = 0b01_01_01_01;
+			let unknown_features = if i < byte_count {
+				sealed::InitContext::UNKNOWN_FEATURE_MASK[i]
+			} else {
+				0b11_11_11_11
+			};
+			(byte & (required_features & unknown_features)) != 0
 		})
 	}
 
 	pub(crate) fn supports_unknown_bits(&self) -> bool {
-		// Generates a bitmask with all even and odd bits set except for the given features. Bitwise
-		// AND-ing it with a byte will select unknown supported features.
-		macro_rules! features_excluding {
-			($($feature: ident)|*) => {
-				(0b11_11_11_11
-					$(
-						& !(<sealed::InitContext as sealed::$feature>::REQUIRED_MASK)
-						& !(<sealed::InitContext as sealed::$feature>::OPTIONAL_MASK)
-					)*
-				)
-			}
-		}
-
-		self.flags.iter().enumerate().any(|(idx, &byte)| {
-			(match idx {
-				0 => (byte & features_excluding![DataLossProtect | InitialRoutingSync | UpfrontShutdownScript]),
-				1 => (byte & features_excluding![VariableLengthOnion | PaymentSecret]),
-				2 => (byte & features_excluding![BasicMPP]),
-				_ => byte,
-			}) != 0
+		use ln::features::sealed::Context;
+		let byte_count = sealed::InitContext::UNKNOWN_FEATURE_MASK.len();
+
+		// Bitwise AND-ing with all even and odd bits set except for known features will select
+		// unknown features.
+		self.flags.iter().enumerate().any(|(i, &byte)| {
+			let unknown_features = if i < byte_count {
+				sealed::InitContext::UNKNOWN_FEATURE_MASK[i]
+			} else {
+				0b11_11_11_11
+			};
+			(byte & unknown_features) != 0
 		})
 	}