X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Futil%2Fser_macros.rs;h=165d1f1edbacea61438ef3426828a1195336a39e;hb=5cfe19ef02cc9746ba664aeaa90921691a75dcd6;hp=5178732c7457e93745d39319fa2f2ecee99a80dd;hpb=a265f1e97a9eff25b3418daf4b12fc9c6ad4c036;p=rust-lightning

diff --git a/lightning/src/util/ser_macros.rs b/lightning/src/util/ser_macros.rs
index 5178732c..165d1f1e 100644
--- a/lightning/src/util/ser_macros.rs
+++ b/lightning/src/util/ser_macros.rs
@@ -154,7 +154,8 @@ macro_rules! decode_tlv {
 		$field = ser::Readable::read(&mut $reader)?;
 	}};
 	($reader: expr, $field: ident, vec_type) => {{
-		$field = Some(ser::Readable::read(&mut $reader)?);
+		let f: ::util::ser::VecReadWrapper<_> = ser::Readable::read(&mut $reader)?;
+		$field = Some(f.0);
 	}};
 	($reader: expr, $field: ident, option) => {{
 		$field = Some(ser::Readable::read(&mut $reader)?);
@@ -230,103 +231,52 @@ macro_rules! decode_tlv_stream {
 	} }
 }
 
-macro_rules! impl_writeable {
-	($st:ident, $len: expr, {$($field:ident),*}) => {
+macro_rules! impl_writeable_msg {
+	($st:ident, {$($field:ident),* $(,)*}, {$(($type: expr, $tlvfield: ident, $fieldty: tt)),* $(,)*}) => {
 		impl ::util::ser::Writeable for $st {
 			fn write<W: ::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
-				if $len != 0 {
-					w.size_hint($len);
-				}
-				#[cfg(any(test, feature = "fuzztarget"))]
-				{
-					// In tests, assert that the hard-coded length matches the actual one
-					if $len != 0 {
-						let mut len_calc = ::util::ser::LengthCalculatingWriter(0);
-						$( self.$field.write(&mut len_calc).expect("No in-memory data may fail to serialize"); )*
-						assert_eq!(len_calc.0, $len);
-						assert_eq!(self.serialized_length(), $len);
-					}
-				}
 				$( self.$field.write(w)?; )*
+				encode_tlv_stream!(w, {$(($type, self.$tlvfield, $fieldty)),*});
 				Ok(())
 			}
-
-			#[inline]
-			fn serialized_length(&self) -> usize {
-				if $len == 0 || cfg!(any(test, feature = "fuzztarget")) {
-					let mut len_calc = 0;
-					$( len_calc += self.$field.serialized_length(); )*
-					if $len != 0 {
-						// In tests, assert that the hard-coded length matches the actual one
-						assert_eq!(len_calc, $len);
-					} else {
-						return len_calc;
-					}
-				}
-				$len
-			}
 		}
-
 		impl ::util::ser::Readable for $st {
 			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+				$(let $field = ::util::ser::Readable::read(r)?;)*
+				$(init_tlv_field_var!($tlvfield, $fieldty);)*
+				decode_tlv_stream!(r, {$(($type, $tlvfield, $fieldty)),*});
 				Ok(Self {
-					$($field: ::util::ser::Readable::read(r)?),*
+					$($field),*,
+					$($tlvfield),*
 				})
 			}
 		}
 	}
 }
-macro_rules! impl_writeable_len_match {
-	($struct: ident, $cmp: tt, ($calc_len: expr), {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => {
-		impl Writeable for $struct {
-			fn write<W: Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
-				let len = match *self {
-					$($match => $length,)*
-				};
-				w.size_hint(len);
-				#[cfg(any(test, feature = "fuzztarget"))]
-				{
-					// In tests, assert that the hard-coded length matches the actual one
-					let mut len_calc = ::util::ser::LengthCalculatingWriter(0);
-					$( self.$field.write(&mut len_calc).expect("No in-memory data may fail to serialize"); )*
-					assert!(len_calc.0 $cmp len);
-					assert_eq!(len_calc.0, self.serialized_length());
-				}
+
+macro_rules! impl_writeable {
+	($st:ident, {$($field:ident),*}) => {
+		impl ::util::ser::Writeable for $st {
+			fn write<W: ::util::ser::Writer>(&self, w: &mut W) -> Result<(), $crate::io::Error> {
 				$( self.$field.write(w)?; )*
 				Ok(())
 			}
 
 			#[inline]
 			fn serialized_length(&self) -> usize {
-				if $calc_len || cfg!(any(test, feature = "fuzztarget")) {
-					let mut len_calc = 0;
-					$( len_calc += self.$field.serialized_length(); )*
-					if !$calc_len {
-						assert_eq!(len_calc, match *self {
-							$($match => $length,)*
-						});
-					}
-					return len_calc
-				}
-				match *self {
-					$($match => $length,)*
-				}
+				let mut len_calc = 0;
+				$( len_calc += self.$field.serialized_length(); )*
+				return len_calc;
 			}
 		}
 
-		impl ::util::ser::Readable for $struct {
-			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
+		impl ::util::ser::Readable for $st {
+			fn read<R: $crate::io::Read>(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
 				Ok(Self {
-					$($field: Readable::read(r)?),*
+					$($field: ::util::ser::Readable::read(r)?),*
 				})
 			}
 		}
-	};
-	($struct: ident, $cmp: tt, {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => {
-		impl_writeable_len_match!($struct, $cmp, (true), { $({ $match, $length }),* }, { $($field),* });
-	};
-	($struct: ident, {$({$match: pat, $length: expr}),*}, {$($field:ident),*}) => {
-		impl_writeable_len_match!($struct, ==, (false), { $({ $match, $length }),* }, { $($field),* });
 	}
 }
 
@@ -360,7 +310,7 @@ macro_rules! write_ver_prefix {
 /// correctly.
 macro_rules! write_tlv_fields {
 	($stream: expr, {$(($type: expr, $field: expr, $fieldty: tt)),* $(,)*}) => {
-		encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*});
+		encode_varint_length_prefixed_tlv!($stream, {$(($type, $field, $fieldty)),*})
 	}
 }
 
@@ -399,7 +349,7 @@ macro_rules! init_tlv_based_struct_field {
 		$field.0.unwrap()
 	};
 	($field: ident, vec_type) => {
-		$field.unwrap().0
+		$field.unwrap()
 	};
 }
 
@@ -411,7 +361,7 @@ macro_rules! init_tlv_field_var {
 		let mut $field = ::util::ser::OptionDeserWrapper(None);
 	};
 	($field: ident, vec_type) => {
-		let mut $field = Some(::util::ser::VecReadWrapper(Vec::new()));
+		let mut $field = Some(Vec::new());
 	};
 	($field: ident, option) => {
 		let mut $field = None;
@@ -505,9 +455,12 @@ macro_rules! _impl_writeable_tlv_based_enum_common {
 macro_rules! impl_writeable_tlv_based_enum_upgradable {
 	($st: ident, $(($variant_id: expr, $variant_name: ident) =>
 		{$(($type: expr, $field: ident, $fieldty: tt)),* $(,)*}
-	),* $(,)*) => {
+	),* $(,)*
+	$(;
+	$(($tuple_variant_id: expr, $tuple_variant_name: ident)),*  $(,)*)*) => {
 		_impl_writeable_tlv_based_enum_common!($st,
-			$(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*; );
+			$(($variant_id, $variant_name) => {$(($type, $field, $fieldty)),*}),*;
+			$($(($tuple_variant_id, $tuple_variant_name)),*)*);
 
 		impl ::util::ser::MaybeReadable for $st {
 			fn read<R: $crate::io::Read>(reader: &mut R) -> Result<Option<Self>, ::ln::msgs::DecodeError> {
@@ -531,6 +484,9 @@ macro_rules! impl_writeable_tlv_based_enum_upgradable {
 						};
 						f()
 					}),*
+					$($($tuple_variant_id => {
+						Ok(Some($st::$tuple_variant_name(Readable::read(reader)?)))
+					}),*)*
 					_ if id % 2 == 1 => Ok(None),
 					_ => Err(DecodeError::UnknownRequiredFeature),
 				}