Metadata with complete type information

Cargo.toml

@@ -84,6 +84,8 @@ members = [
 	"node/runtime",
 	"node-template",
 	"subkey",
+	"core/metadata",
+	"core/metadata-derive",
 ]
 exclude = [
 	"node/runtime/wasm",

core/metadata-derive/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "substrate-metadata-derive"
+version = "0.1.0"
+authors = ["Bryan Chen <xlchen1291@gmail.com>"]
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "0.15"
+quote = "0.6"
+proc-macro2 = "0.4"
+
+[features]
+default = ["std"]
+std = []

core/metadata-derive/src/encode.rs

@@ -0,0 +1,206 @@
+use quote::{quote, quote_spanned};
+
+use proc_macro2::{Span, TokenStream};
+use syn::{
+	Data, Field, Fields, Type,
+	Meta, NestedMeta, Lit, Attribute, Variant,
+	punctuated::Punctuated,
+	spanned::Spanned,
+	token::Comma,
+};
+
+type FieldsList = Punctuated<Field, Comma>;
+
+fn encode_fields(
+	fields: &FieldsList,
+	registry: &TokenStream
+) -> TokenStream
+{
+	let recurse = fields.iter().enumerate().map(|(i, f)| {
+		let compact = get_enable_compact(f);
+		let name = f.ident.as_ref().map(|iden| quote! {
+			_substrate_metadata::FieldName::Named(stringify!(#iden).into())
+		})
+		.unwrap_or(quote! {
+			_substrate_metadata::FieldName::Unnamed(#i as u16)
+		});
+		let ty = &f.ty;
+		quote_spanned! { f.span() =>
+			{
+				let type_name = <#ty as _substrate_metadata::EncodeMetadata>::type_name();
+				#registry.register(type_name.clone(), <#ty as _substrate_metadata::EncodeMetadata>::type_metadata_kind);
+				_substrate_metadata::FieldMetadata {
+					name: #name,
+					ty: if #compact { _substrate_metadata::MetadataName::Compact(Box::new(type_name)) } else { type_name }
+				}
+			}
+		}
+	});
+
+	quote! {
+		_substrate_metadata::TypeMetadataKind::Struct(vec![#( #recurse, )*])
+	}
+}
+
+pub fn quote(data: &Data, registry: &TokenStream) -> TokenStream {
+	let call_site = Span::call_site();
+	let res = match *data {
+		Data::Struct(ref data) => {
+			match data.fields {
+				Fields::Named(ref fields) => encode_fields(
+					&fields.named,
+					registry
+				),
+				Fields::Unnamed(ref fields) => encode_fields(
+					&fields.unnamed,
+					registry
+				),
+				Fields::Unit => quote_spanned! { call_site =>
+					_substrate_metadata::TypeMetadataKind::Struct(vec![])
+				},
+			}
+		},
+		Data::Enum(ref data) => {
+			let recurse = data.variants.iter().enumerate().map(|(i, f)| {
+				let name = &f.ident;
+				let index = index(f, i);
+				match f.fields {
+					Fields::Named(ref fields) => {
+						let field_name = |ty: &Type| {
+							quote_spanned!(call_site => #ty)
+						};
+						let fields = fields.named
+							.iter()
+							.map(|f| {
+								let ty = field_name(&f.ty);
+								let name = &f.ident;
+								quote_spanned! { f.span() =>
+									{
+										let type_name = <#ty as _substrate_metadata::EncodeMetadata>::type_name();
+										#registry.register(
+											type_name.clone(),
+											<#ty as _substrate_metadata::EncodeMetadata>::type_metadata_kind
+										);
+										_substrate_metadata::FieldMetadata {
+											name: _substrate_metadata::FieldName::Named(stringify!(#name).into()),
+											ty: type_name
+										}
+									}
+								}
+							});
+
+						quote_spanned! { f.span() =>
+							_substrate_metadata::EnumVariantMetadata {
+								name: stringify!(#name).into(),
+								index: #index as u16,
+								fields: vec![#( #fields, )*]
+							}
+						}
+					},
+					Fields::Unnamed(ref fields) => {
+						let field_name = |ty: &Type| {
+							quote_spanned!(call_site => #ty)
+						};
+						let fields = fields.unnamed
+							.iter()
+							.enumerate()
+							.map(|(i, f)| {
+								let ty = field_name(&f.ty);
+								quote! {
+									{
+										let type_name = <#ty as _substrate_metadata::EncodeMetadata>::type_name();
+										#registry.register(
+											type_name.clone(),
+											<#ty as _substrate_metadata::EncodeMetadata>::type_metadata_kind
+										);
+										_substrate_metadata::FieldMetadata {
+											name: _substrate_metadata::FieldName::Unnamed(#i as u16),
+											ty: type_name
+										}
+									}
+								}
+							});
+
+						quote_spanned! { f.span() =>
+							_substrate_metadata::EnumVariantMetadata {
+								name: stringify!(#name).into(),
+								index: #index as u16,
+								fields: vec![#( #fields, )*]
+							}
+						}
+					},
+					Fields::Unit => {
+						quote_spanned! { f.span() =>
+							_substrate_metadata::EnumVariantMetadata {
+								name: stringify!(#name).into(),
+								index: #index as u16,
+								fields: Vec::new()
+							}
+						}
+					},
+				}
+			});
+
+			quote! {
+				_substrate_metadata::TypeMetadataKind::Enum(vec![#( #recurse, )*])
+			}
+		},
+		Data::Union(_) => panic!("Union types are not supported."),
+	};
+	res
+}
+
+fn find_meta_item<'a, F, R, I>(itr: I, pred: F) -> Option<R> where
+	F: FnMut(&NestedMeta) -> Option<R> + Clone,
+	I: Iterator<Item=&'a Attribute>
+{
+	itr.filter_map(|attr| {
+		let pair = attr.path.segments.first()?;
+		let seg = pair.value();
+		if seg.ident == "codec" {
+			let meta = attr.interpret_meta();
+			if let Some(Meta::List(ref meta_list)) = meta {
+				return meta_list.nested.iter().filter_map(pred.clone()).next();
+			}
+		}
+
+		None
+	}).next()
+}
+
+fn index(v: &Variant, i: usize) -> TokenStream {
+	// look for an index in attributes
+	let index = find_meta_item(v.attrs.iter(), |meta| {
+		if let NestedMeta::Meta(Meta::NameValue(ref nv)) = meta {
+			if nv.ident == "index" {
+				if let Lit::Str(ref s) = nv.lit {
+					let byte: u8 = s.value().parse().expect("Numeric index expected.");
+					return Some(byte)
+				}
+			}
+		}
+
+		None
+	});
+
+	// then fallback to discriminant or just index
+	index.map(|i| quote! { #i })
+		.unwrap_or_else(|| v.discriminant
+			.as_ref()
+			.map(|&(_, ref expr)| quote! { #expr })
+			.unwrap_or_else(|| quote! { #i })
+		)
+}
+
+fn get_enable_compact(field_entry: &Field) -> bool {
+	// look for `encode(compact)` in the attributes
+	find_meta_item(field_entry.attrs.iter(), |meta| {
+		if let NestedMeta::Meta(Meta::Word(ref word)) = meta {
+			if word == "compact" {
+				return Some(());
+			}
+		}
+
+		None
+	}).is_some()
+}

core/metadata-derive/src/lib.rs

@@ -0,0 +1,113 @@
+// Copyright 2019 Parity Technologies (UK) Ltd.
+// This file is part of Substrate.
+
+// Substrate is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Substrate is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Substrate.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Derives type metadata information to enable self-descriptive codec
+
+extern crate proc_macro;
+
+use syn::parse_quote;
+use quote::{quote};
+
+use proc_macro::TokenStream;
+use proc_macro2::{Span};
+use syn::{DeriveInput, Generics, Ident, GenericParam};
+
+mod encode;
+
+#[proc_macro_derive(EncodeMetadata, attributes(codec))]
+pub fn encode_derive(input: TokenStream) -> TokenStream {
+	let input: DeriveInput = match syn::parse(input) {
+		Ok(input) => input,
+		Err(e) => return e.to_compile_error().into(),
+	};
+
+	let generics = add_trait_bounds(input.generics, parse_quote!(_substrate_metadata::EncodeMetadata));
+
+	let generic_types = generics.params.iter().map(|param| {
+		if let GenericParam::Type(ref type_param) = *param {
+			Some(type_param.ident.clone())
+		} else {
+			None
+		}
+	})
+	.filter(Option::is_some)
+	.collect::<Vec<_>>();
+
+	let name = &input.ident;
+	let impl_type_name = if generic_types.is_empty() {
+		quote! {
+			fn type_name() -> _substrate_metadata::MetadataName {
+				_substrate_metadata::MetadataName::Custom(module_path!().into(), stringify!(#name).into())
+			}
+		}
+	} else {
+		let generic_type_names = generic_types.into_iter().map(|t| {
+			quote! {
+				<#t as _substrate_metadata::EncodeMetadata>::type_name()
+			}
+		});
+		quote! {
+			fn type_name() -> _substrate_metadata::MetadataName {
+				_substrate_metadata::MetadataName::CustomWithGenerics(module_path!().into(), stringify!(#name).into(), vec![
+					#( #generic_type_names ),*
+				])
+			}
+		}
+	};
+
+	let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+	let registry = quote!(registry);
+
+	let metadata_kind = encode::quote(&input.data, &registry);
+
+	let impl_block = quote! {
+		impl #impl_generics _substrate_metadata::EncodeMetadata for #name #ty_generics #where_clause {
+			#impl_type_name
+
+			fn type_metadata_kind(registry: &mut _substrate_metadata::MetadataRegistry) -> _substrate_metadata::TypeMetadataKind {
+				#metadata_kind
+			}
+		}
+	};
+
+	let mut new_name = "_IMPL_ENCODEMETADATA_FOR_".to_string();
+	new_name.push_str(name.to_string().trim_start_matches("r#"));
+	let dummy_const = Ident::new(&new_name, Span::call_site());
+
+	let generated = quote! {
+		#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+		const #dummy_const: () = {
+			#[allow(unknown_lints)]
+			#[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
+			#[allow(rust_2018_idioms)]
+			extern crate substrate_metadata as _substrate_metadata;
+			use _substrate_metadata::rstd::prelude::*;
+			#impl_block
+		};
+	};
+
+	generated.into()
+}
+
+fn add_trait_bounds(mut generics: Generics, bounds: syn::TypeParamBound) -> Generics {
+	for param in &mut generics.params {
+		if let GenericParam::Type(ref mut type_param) = *param {
+			type_param.bounds.push(bounds.clone());
+		}
+	}
+	generics
+}