Refactor type generation, remove code duplication (#352)

* codegen: fix compact unnamed fields

* Fmt

* codegen: move derives and struct_def to types

* codegen: rename struct_def to composite_def.r

* WIP: deduplicate struct def code

* Fmt

* WIP refactoring composite type codegen duplication

* Fmt

* Fix TokenStream import

* Fix field_tokens ty_path parse error

* Fix call struct generation

* Refactor ty_path()

* Optional derives and move CompactAs derive to composite_def

* Fmt

* Introduce CompositeDefFieldType

* Restore default codec derives

* Extract TypeDefParameters and TypeDefGen construction

* Fmt

* Reset codegen to master

* Introduce CompositeDefFields

* Introduce CompositeDefFields

* Fix up errors

* Fix Box field types

* Fmt

* Fix compact attribute

* Handle no fields case

* Handle no fields with trailing semi

* Fix compact field detection

* Fix generic phantom marker

* Fmt

* Fix generic type parm fields

* Clippy

* Fix up boxed call fields

* Fmt

* Add comments to composite_def.rs

* Fix license headers

* Restore Debug derive in tests

* Fix empty struct codegen test

* Use BTreeSet for type params for ordering

* code review: fix comment

* code review: refactor CompositeDefFields as enum

* Fix empty named fields

* Fix generation of call variant enum structs

* Expand field_tokens into separate methods for struct and enum variants

* Add TypeDefParameters docs

* Fix doc link

* Clippy redundant return

codegen/src/api/calls.rs

@@ -14,7 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with subxt.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::types::TypeGenerator;
+use crate::types::{
+    CompositeDefFields,
+    TypeGenerator,
+};
 use frame_metadata::{
     PalletCallMetadata,
     PalletMetadata,
@@ -39,17 +42,29 @@ pub fn generate_calls(
     let (call_structs, call_fns): (Vec<_>, Vec<_>) = struct_defs
         .iter()
         .map(|struct_def| {
-            let (call_fn_args, call_args): (Vec<_>, Vec<_>) = struct_def
-                .named_fields()
-                .unwrap_or_else(|| {
-                    abort_call_site!(
-                        "Call variant for type {} must have all named fields",
-                        call.ty.id()
-                    )
-                })
-                .iter()
-                .map(|(name, ty)| (quote!( #name: #ty ), name))
-                .unzip();
+            let (call_fn_args, call_args): (Vec<_>, Vec<_>) =
+                match struct_def.fields {
+                    CompositeDefFields::Named(ref named_fields) => {
+                        named_fields
+                            .iter()
+                            .map(|(name, field)| {
+                                let fn_arg_type = &field.type_path;
+                                let call_arg = if field.is_boxed() {
+                                    quote! { #name: ::std::boxed::Box::new(#name) }
+                                } else {
+                                    quote! { #name }
+                                };
+                                (quote!( #name: #fn_arg_type ), call_arg)
+                            })
+                            .unzip()
+                    }
+                    CompositeDefFields::NoFields => Default::default(),
+                    CompositeDefFields::Unnamed(_) =>
+                        abort_call_site!(
+                            "Call variant for type {} must have all named fields",
+                            call.ty.id()
+                        )
+                };
 
             let pallet_name = &pallet.name;
             let call_struct_name = &struct_def.name;

codegen/src/api/mod.rs

@@ -22,8 +22,11 @@ mod storage;
 use super::GeneratedTypeDerives;
 use crate::{
     ir,
-    struct_def::StructDef,
-    types::TypeGenerator,
+    types::{
+        CompositeDef,
+        CompositeDefFields,
+        TypeGenerator,
+    },
 };
 use codec::Decode;
 use frame_metadata::{
@@ -316,21 +319,28 @@ impl RuntimeGenerator {
     }
 }
 
-pub fn generate_structs_from_variants(
-    type_gen: &TypeGenerator,
+pub fn generate_structs_from_variants<'a>(
+    type_gen: &'a TypeGenerator,
     type_id: u32,
     error_message_type_name: &str,
-) -> Vec<StructDef> {
+) -> Vec<CompositeDef> {
     let ty = type_gen.resolve_type(type_id);
     if let scale_info::TypeDef::Variant(variant) = ty.type_def() {
         variant
             .variants()
             .iter()
             .map(|var| {
-                StructDef::new(
+                let fields = CompositeDefFields::from_scale_info_fields(
                     var.name(),
                     var.fields(),
-                    Some(syn::parse_quote!(pub)),
+                    &[],
+                    type_gen,
+                );
+                CompositeDef::struct_def(
+                    var.name(),
+                    Default::default(),
+                    fields,
+                    Some(parse_quote!(pub)),
                     type_gen,
                 )
             })