codegen: Generate type aliases for better API ergonomics

cli/src/commands/explore/mod.rs

@@ -180,7 +180,7 @@ pub mod tests {
     async fn test_commands() {
         // show pallets:
         let output = simulate_run("").await;
-        assert_eq!(output.unwrap(), "Usage:\n    subxt explore <PALLET>\n        explore a specific pallet\n\nAvailable <PALLET> values are:\n    Balances\n    Multisig\n    ParaInherent\n    Staking\n    System\n    Timestamp\n");
+        assert_eq!(output.unwrap(), "Usage:\n    subxt explore <PALLET>\n        explore a specific pallet\n\nAvailable <PALLET> values are:\n    Balances\n    Multisig\n    ParaInherent\n    System\n    Timestamp\n");
         // if incorrect pallet, error:
         let output = simulate_run("abc123").await;
         assert!(output.is_err());
@@ -198,19 +198,20 @@ pub mod tests {
         let output = simulate_run("Balances abc123").await;
         assert!(output.is_err());
         // check that we can explore a certain call:
-        let output = simulate_run("Balances calls transfer").await;
-        assert!(output.unwrap().starts_with("Usage:\n    subxt explore Balances calls transfer <SCALE_VALUE>\n        construct the call by providing a valid argument\n\nThe call expect expects a <SCALE_VALUE> with this shape:\n    {\n        dest: enum MultiAddress"));
+        let output = simulate_run("Balances calls transfer_allow_death").await;
+        assert!(output.unwrap().starts_with("Usage:\n    subxt explore Balances calls transfer_allow_death <SCALE_VALUE>\n        construct the call by providing a valid argument\n\nThe call expect expects a <SCALE_VALUE> with this shape:\n    {\n        dest: enum MultiAddress"));
         // check that unsigned extrinsic can be constructed:
-        let output =
-            simulate_run("Balances calls transfer {\"dest\":v\"Raw\"((255,255, 255)),\"value\":0}")
-                .await;
+        let output = simulate_run(
+            "Balances calls transfer_allow_death {\"dest\":v\"Raw\"((255,255, 255)),\"value\":0}",
+        )
+        .await;
         assert_eq!(
             output.unwrap(),
-            "Encoded call data:\n    0x24040507020cffffff00\n"
+            "Encoded call data:\n    0x24040400020cffffff00\n"
         );
         // check that we can explore a certain constant:
         let output = simulate_run("Balances constants ExistentialDeposit").await;
-        assert_eq!(output.unwrap(), "Description:\n    The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!\n\nThe constant has the following shape:\n    u128\n\nThe value of the constant is:\n    10000000000\n");
+        assert_eq!(output.unwrap(), "Description:\n    The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!\n\nThe constant has the following shape:\n    u128\n\nThe value of the constant is:\n    33333333\n");
         // check that we can explore a certain storage entry:
         let output = simulate_run("System storage Account").await;
         assert!(output.unwrap().starts_with("Usage:\n    subxt explore System storage Account <KEY_VALUE>\n\nDescription:\n    The full account information for a particular account ID."));

codegen/Cargo.toml

@@ -37,4 +37,5 @@ getrandom = { workspace = true, optional = true }
 [dev-dependencies]
 bitvec = { workspace = true }
 scale-info = { workspace = true, features = ["bit-vec"] }
-pretty_assertions = { workspace = true }
+pretty_assertions = { workspace = true }
+frame-metadata = { workspace = true }

codegen/src/api/calls.rs

@@ -32,34 +32,44 @@ pub fn generate_calls(
 
     let mut struct_defs = super::generate_structs_from_variants(
         type_gen,
+        types_mod_ident,
         call_ty,
         |name| name.to_upper_camel_case().into(),
         "Call",
         crate_path,
         should_gen_docs,
     )?;
-    let (call_structs, call_fns): (Vec<_>, Vec<_>) = struct_defs
+
+    let result = struct_defs
         .iter_mut()
-        .map(|(variant_name, struct_def)| {
-            let (call_fn_args, call_args): (Vec<_>, Vec<_>) = match struct_def.fields {
+        .map(|(variant_name, struct_def, aliases)| {
+            let fn_name = format_ident!("{}", variant_name.to_snake_case());
+
+            let result: 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)
+
+                        let alias_name =
+                            format_ident!("{}", name.to_string().to_upper_camel_case());
+
+                        (quote!( #name: types::#fn_name::#alias_name ), call_arg)
                     })
-                    .unzip(),
+                    .collect(),
                 CompositeDefFields::NoFields => Default::default(),
                 CompositeDefFields::Unnamed(_) => {
                     return Err(CodegenError::InvalidCallVariant(call_ty))
                 }
             };
 
+            let call_fn_args = result.iter().map(|(call_fn_arg, _)| call_fn_arg);
+            let call_args = result.iter().map(|(_, call_arg)| call_arg);
+
             let pallet_name = pallet.name();
             let call_name = &variant_name;
             let struct_name = &struct_def.name;
@@ -69,7 +79,7 @@ pub fn generate_calls(
                     call_name.to_string(),
                 ));
             };
-            let fn_name = format_ident!("{}", variant_name.to_snake_case());
+
             // Propagate the documentation just to `TransactionApi` methods, while
             // draining the documentation of inner call structures.
             let docs = should_gen_docs.then_some(struct_def.docs.take()).flatten();
@@ -78,6 +88,8 @@ pub fn generate_calls(
             let call_struct = quote! {
                 #struct_def
 
+                #aliases
+
                 impl #crate_path::blocks::StaticExtrinsic for #struct_name {
                     const PALLET: &'static str = #pallet_name;
                     const CALL: &'static str = #call_name;
@@ -101,9 +113,10 @@ pub fn generate_calls(
 
             Ok((call_struct, client_fn))
         })
-        .collect::<Result<Vec<_>, _>>()?
-        .into_iter()
-        .unzip();
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let call_structs = result.iter().map(|(call_struct, _)| call_struct);
+    let call_fns = result.iter().map(|(_, client_fn)| client_fn);
 
     let call_type = type_gen.resolve_type_path(call_ty);
     let call_ty = type_gen.resolve_type(call_ty);

codegen/src/api/events.rs

@@ -52,27 +52,32 @@ pub fn generate_events(
 
     let struct_defs = super::generate_structs_from_variants(
         type_gen,
+        types_mod_ident,
         event_ty,
         |name| name.into(),
         "Event",
         crate_path,
         should_gen_docs,
     )?;
 
-    let event_structs = struct_defs.iter().map(|(variant_name, struct_def)| {
-        let pallet_name = pallet.name();
-        let event_struct = &struct_def.name;
-        let event_name = variant_name;
+    let event_structs = struct_defs
+        .iter()
+        .map(|(variant_name, struct_def, aliases)| {
+            let pallet_name = pallet.name();
+            let event_struct = &struct_def.name;
+            let event_name = variant_name;
 
-        quote! {
-            #struct_def
+            quote! {
+                #struct_def
 
-            impl #crate_path::events::StaticEvent for #event_struct {
-                const PALLET: &'static str = #pallet_name;
-                const EVENT: &'static str = #event_name;
+                #aliases
+
+                impl #crate_path::events::StaticEvent for #event_struct {
+                    const PALLET: &'static str = #pallet_name;
+                    const EVENT: &'static str = #event_name;
+                }
             }
-        }
-    });
+        });
     let event_type = type_gen.resolve_type_path(event_ty);
     let event_ty = type_gen.resolve_type(event_ty);
     let docs = &event_ty.docs;

codegen/src/api/mod.rs

@@ -358,12 +358,13 @@ impl RuntimeGenerator {
 /// Return a vector of tuples of variant names and corresponding struct definitions.
 pub fn generate_structs_from_variants<F>(
     type_gen: &TypeGenerator,
+    types_mod_ident: &syn::Ident,
     type_id: u32,
     variant_to_struct_name: F,
     error_message_type_name: &str,
     crate_path: &syn::Path,
     should_gen_docs: bool,
-) -> Result<Vec<(String, CompositeDef)>, CodegenError>
+) -> Result<Vec<(String, CompositeDef, TypeAliases)>, CodegenError>
 where
     F: Fn(&str) -> std::borrow::Cow<str>,
 {
@@ -386,19 +387,75 @@ where
                 type_gen,
             )?;
 
+            let alias_module_name = format_ident!("{}", var.name.to_snake_case());
+
             let docs = should_gen_docs.then_some(&*var.docs).unwrap_or_default();
             let struct_def = CompositeDef::struct_def(
                 &ty,
                 struct_name.as_ref(),
                 Default::default(),
-                fields,
+                fields.clone(),
                 Some(parse_quote!(pub)),
                 type_gen,
                 docs,
                 crate_path,
+                Some(alias_module_name.clone()),
             )?;
 
-            Ok((var.name.to_string(), struct_def))
+            let type_aliases = TypeAliases::new(fields, types_mod_ident.clone(), alias_module_name);
+
+            Ok((var.name.to_string(), struct_def, type_aliases))
         })
         .collect()
 }
+
+/// Generate the type aliases from a set of enum / struct definitions.
+///
+/// The type aliases are used to make the generated code more readable.
+#[derive(Debug)]
+pub struct TypeAliases {
+    fields: CompositeDefFields,
+    types_mod_ident: syn::Ident,
+    mod_name: syn::Ident,
+}
+
+impl TypeAliases {
+    pub fn new(
+        fields: CompositeDefFields,
+        types_mod_ident: syn::Ident,
+        mod_name: syn::Ident,
+    ) -> Self {
+        TypeAliases {
+            fields,
+            types_mod_ident,
+            mod_name,
+        }
+    }
+}
+
+impl quote::ToTokens for TypeAliases {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let has_fields = matches!(&self.fields, CompositeDefFields::Named(fields) if !fields.is_empty())
+            || matches!(&self.fields, CompositeDefFields::Unnamed(fields) if !fields.is_empty());
+        if !has_fields {
+            return;
+        }
+
+        let visibility: syn::Visibility = parse_quote!(pub);
+
+        let aliases = self
+            .fields
+            .to_type_aliases_tokens(Some(visibility).as_ref());
+
+        let mod_name = &self.mod_name;
+        let types_mod_ident = &self.types_mod_ident;
+
+        tokens.extend(quote! {
+            pub mod #mod_name {
+                use super::#types_mod_ident;
+
+                #aliases
+            }
+        })
+    }
+}