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/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,
                 )
             })