Move MaxEncodedLen from Substrate

Cargo.toml

@@ -16,12 +16,14 @@ bitvec = { version = "0.20.1", default-features = false, features = ["alloc"], o
 byte-slice-cast = { version = "1.0.0", default-features = false }
 generic-array = { version = "0.14.4", optional = true }
 arbitrary = { version = "1.0.1", features = ["derive"], optional = true }
+impl-trait-for-tuples = "0.2.1"
 
 [dev-dependencies]
 criterion = "0.3.0"
 serde_derive = { version = "1.0" }
 parity-scale-codec-derive = { path = "derive", version = "2.1.3", default-features = false }
 quickcheck = "1.0"
+trybuild = "1.0.42"
 
 [[bench]]
 name = "benches"

derive/src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2017-2018 Parity Technologies
+// Copyright 2017-2021 Parity Technologies
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -32,6 +32,7 @@ use crate::utils::is_lint_attribute;
 
 mod decode;
 mod encode;
+mod max_encoded_len;
 mod utils;
 mod trait_bounds;
 
@@ -333,3 +334,9 @@ pub fn compact_as_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStr
 
 	wrap_with_dummy_const(input, impl_block)
 }
+
+/// Derive `MaxEncodedLen`.
+#[proc_macro_derive(MaxEncodedLen)]
+pub fn derive_max_encoded_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	max_encoded_len::derive_max_encoded_len(input)
+}

derive/src/max_encoded_len.rs

@@ -0,0 +1,124 @@
+// Copyright (C) 2021 Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use quote::{quote, quote_spanned};
+use syn::{
+	Data, DeriveInput, Fields, GenericParam, Generics, TraitBound, Type, TypeParamBound,
+	parse_quote, spanned::Spanned,
+};
+
+/// impl for `#[derive(MaxEncodedLen)]`
+pub fn derive_max_encoded_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+	let input: DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let crate_import = crate::include_parity_scale_codec_crate();
+	let mel_trait: TraitBound = parse_quote!(_parity_scale_codec::MaxEncodedLen);
+
+	let name = &input.ident;
+	let generics = add_trait_bounds(input.generics, mel_trait.clone());
+	let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+	let data_expr = data_length_expr(&input.data);
+
+	quote::quote!(
+		const _: () = {
+			#crate_import
+			impl #impl_generics #mel_trait for #name #ty_generics #where_clause {
+				fn max_encoded_len() -> usize {
+					#data_expr
+				}
+			}
+		};
+	)
+	.into()
+}
+
+// Add a bound `T: MaxEncodedLen` to every type parameter T.
+fn add_trait_bounds(mut generics: Generics, mel_trait: TraitBound) -> Generics {
+	for param in &mut generics.params {
+		if let GenericParam::Type(ref mut type_param) = *param {
+			type_param.bounds.push(TypeParamBound::Trait(mel_trait.clone()));
+		}
+	}
+	generics
+}
+
+/// generate an expression to sum up the max encoded length from several fields
+fn fields_length_expr(fields: &Fields) -> proc_macro2::TokenStream {
+	let type_iter: Box<dyn Iterator<Item = &Type>> = match fields {
+		Fields::Named(ref fields) => Box::new(fields.named.iter().map(|field| &field.ty)),
+		Fields::Unnamed(ref fields) => Box::new(fields.unnamed.iter().map(|field| &field.ty)),
+		Fields::Unit => Box::new(std::iter::empty()),
+	};
+	// expands to an expression like
+	//
+	//   0
+	//     .saturating_add(<type of first field>::max_encoded_len())
+	//     .saturating_add(<type of second field>::max_encoded_len())
+	//
+	// We match the span of each field to the span of the corresponding
+	// `max_encoded_len` call. This way, if one field's type doesn't implement
+	// `MaxEncodedLen`, the compiler's error message will underline which field
+	// caused the issue.
+	let expansion = type_iter.map(|ty| {
+		quote_spanned! {
+			ty.span() => .saturating_add(<#ty>::max_encoded_len())
+		}
+	});
+	quote! {
+		0_usize #( #expansion )*
+	}
+}
+
+// generate an expression to sum up the max encoded length of each field
+fn data_length_expr(data: &Data) -> proc_macro2::TokenStream {
+	match *data {
+		Data::Struct(ref data) => fields_length_expr(&data.fields),
+		Data::Enum(ref data) => {
+			// We need an expression expanded for each variant like
+			//
+			//   0
+			//     .max(<variant expression>)
+			//     .max(<variant expression>)
+			//     .saturating_add(1)
+			//
+			// The 1 derives from the discriminant; see
+			// https://github.com/paritytech/parity-scale-codec/
+			//   blob/f0341dabb01aa9ff0548558abb6dcc5c31c669a1/derive/src/encode.rs#L211-L216
+			//
+			// Each variant expression's sum is computed the way an equivalent struct's would be.
+
+			let expansion = data.variants.iter().map(|variant| {
+				let variant_expression = fields_length_expr(&variant.fields);
+				quote! {
+					.max(#variant_expression)
+				}
+			});
+
+			quote! {
+				0_usize #( #expansion )* .saturating_add(1)
+			}
+		}
+		Data::Union(ref data) => {
+			// https://github.com/paritytech/parity-scale-codec/
+			//   blob/f0341dabb01aa9ff0548558abb6dcc5c31c669a1/derive/src/encode.rs#L290-L293
+			syn::Error::new(data.union_token.span(), "Union types are not supported")
+				.to_compile_error()
+		}
+	}
+}

src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2017, 2018 Parity Technologies
+// Copyright 2017-2021 Parity Technologies
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -274,6 +274,7 @@ mod depth_limit;
 mod encode_append;
 mod encode_like;
 mod error;
+mod max_encoded_len;
 
 pub use self::error::Error;
 pub use self::codec::{
@@ -289,3 +290,29 @@ pub use self::decode_all::DecodeAll;
 pub use self::depth_limit::DecodeLimit;
 pub use self::encode_append::EncodeAppend;
 pub use self::encode_like::{EncodeLike, Ref};
+pub use max_encoded_len::MaxEncodedLen;
+/// Derive [`MaxEncodedLen`][max_encoded_len::MaxEncodedLen].
+///
+/// # Examples
+///
+/// ```
+/// # use parity_scale_codec::{Encode, MaxEncodedLen};
+/// #[derive(Encode, MaxEncodedLen)]
+/// struct TupleStruct(u8, u32);
+///
+/// assert_eq!(TupleStruct::max_encoded_len(), u8::max_encoded_len() + u32::max_encoded_len());
+/// ```
+///
+/// ```
+/// # use parity_scale_codec::{Encode, MaxEncodedLen};
+/// #[derive(Encode, MaxEncodedLen)]
+/// enum GenericEnum<T> {
+/// 	A,
+/// 	B(T),
+/// }
+///
+/// assert_eq!(GenericEnum::<u8>::max_encoded_len(), u8::max_encoded_len() + u8::max_encoded_len());
+/// assert_eq!(GenericEnum::<u128>::max_encoded_len(), u8::max_encoded_len() + u128::max_encoded_len());
+/// ```
+#[cfg(feature = "derive")]
+pub use parity_scale_codec_derive::MaxEncodedLen;