Add 'Static' type and improve type substitution codegen to accept it

cli/src/commands/codegen.rs

@@ -6,7 +6,7 @@ use clap::Parser as ClapParser;
 use color_eyre::eyre;
 use jsonrpsee::client_transport::ws::Uri;
 use std::{fs, io::Read, path::PathBuf};
-use subxt_codegen::{DerivesRegistry, TypeSubstitutes};
+use subxt_codegen::{DerivesRegistry, TypeSubstitutes, TypeSubstitutionError};
 
 /// Generate runtime API client code from metadata.
 ///
@@ -29,6 +29,11 @@ pub struct Opts {
     /// Example `--derive-for-type my_module::my_type=serde::Serialize`.
     #[clap(long = "derive-for-type", value_parser = derive_for_type_parser)]
     derives_for_type: Vec<(String, String)>,
+    /// Substitute a type for another.
+    ///
+    /// Example `--substitute-type sp_runtime::MultiAddress<A,B>=subxt::utils::Static<::sp_runtime::MultiAddress<A,B>>`
+    #[clap(long = "substitute-type", value_parser = substitute_type_parser)]
+    substitute_types: Vec<(String, String)>,
     /// The `subxt` crate access path in the generated code.
     /// Defaults to `::subxt`.
     #[clap(long = "crate")]
@@ -51,6 +56,14 @@ fn derive_for_type_parser(src: &str) -> Result<(String, String), String> {
     Ok((ty.to_string(), derive.to_string()))
 }
 
+fn substitute_type_parser(src: &str) -> Result<(String, String), String> {
+    let (from, to) = src
+        .split_once('=')
+        .ok_or_else(|| String::from("Invalid pattern for `substitute-type`. It should be something like `input::Type<A>=replacement::Type<A>`"))?;
+
+    Ok((from.to_string(), to.to_string()))
+}
+
 pub async fn run(opts: Opts) -> color_eyre::Result<()> {
     let bytes = if let Some(file) = opts.file.as_ref() {
         if opts.url.is_some() {
@@ -74,6 +87,7 @@ pub async fn run(opts: Opts) -> color_eyre::Result<()> {
         &bytes,
         opts.derives,
         opts.derives_for_type,
+        opts.substitute_types,
         opts.crate_path,
         opts.no_docs,
         opts.runtime_types_only,
@@ -85,6 +99,7 @@ fn codegen(
     metadata_bytes: &[u8],
     raw_derives: Vec<String>,
     derives_for_type: Vec<(String, String)>,
+    substitute_types: Vec<(String, String)>,
     crate_path: Option<String>,
     no_docs: bool,
     runtime_types_only: bool,
@@ -102,13 +117,31 @@ fn codegen(
     let mut derives = DerivesRegistry::new(&crate_path);
     derives.extend_for_all(p.into_iter());
 
-    for (ty, derive) in derives_for_type.into_iter() {
+    for (ty, derive) in derives_for_type {
         let ty = syn::parse_str(&ty)?;
         let derive = syn::parse_str(&derive)?;
-        derives.extend_for_type(ty, std::iter::once(derive), &crate_path)
+        derives.extend_for_type(ty, std::iter::once(derive), &crate_path);
     }
 
-    let type_substitutes = TypeSubstitutes::new(&crate_path);
+    let mut type_substitutes = TypeSubstitutes::new(&crate_path);
+    for (from_str, to_str) in substitute_types {
+        let from: syn::Path = syn::parse_str(&from_str)?;
+        let to: syn::Path = syn::parse_str(&to_str)?;
+        let to = to.try_into().map_err(|e: TypeSubstitutionError| {
+            eyre::eyre!(
+                "Cannot parse substitute '{from_str}={to_str}': {}",
+                e.to_string()
+            )
+        })?;
+        type_substitutes
+            .insert(from, to)
+            .map_err(|e: TypeSubstitutionError| {
+                eyre::eyre!(
+                    "Cannot parse substitute '{from_str}={to_str}': {}",
+                    e.to_string()
+                )
+            })?;
+    }
 
     let should_gen_docs = !no_docs;
     let runtime_api = subxt_codegen::generate_runtime_api_from_bytes(

codegen/src/api/mod.rs

@@ -12,80 +12,21 @@ mod storage;
 use subxt_metadata::get_metadata_per_pallet_hash;
 
 use super::DerivesRegistry;
+use crate::error::CodegenError;
 use crate::{
     ir,
     types::{CompositeDef, CompositeDefFields, TypeGenerator, TypeSubstitutes},
-    utils::{fetch_metadata_bytes_blocking, FetchMetadataError, Uri},
+    utils::{fetch_metadata_bytes_blocking, Uri},
     CratePath,
 };
 use codec::Decode;
 use frame_metadata::{v14::RuntimeMetadataV14, RuntimeMetadata, RuntimeMetadataPrefixed};
 use heck::ToSnakeCase as _;
-use proc_macro2::{Span, TokenStream as TokenStream2};
+use proc_macro2::TokenStream as TokenStream2;
 use quote::{format_ident, quote};
 use std::{fs, io::Read, path, string::ToString};
 use syn::parse_quote;
 
-/// Error returned when the Codegen cannot generate the runtime API.
-#[derive(Debug, thiserror::Error)]
-pub enum CodegenError {
-    /// The given metadata type could not be found.
-    #[error("Could not find type with ID {0} in the type registry; please raise a support issue.")]
-    TypeNotFound(u32),
-    /// Cannot fetch the metadata bytes.
-    #[error("Failed to fetch metadata, make sure that you're pointing at a node which is providing V14 metadata: {0}")]
-    Fetch(#[from] FetchMetadataError),
-    /// Failed IO for the metadata file.
-    #[error("Failed IO for {0}, make sure that you are providing the correct file path for metadata V14: {1}")]
-    Io(String, std::io::Error),
-    /// Cannot decode the metadata bytes.
-    #[error("Could not decode metadata, only V14 metadata is supported: {0}")]
-    Decode(#[from] codec::Error),
-    /// Out of line modules are not supported.
-    #[error("Out-of-line subxt modules are not supported, make sure you are providing a body to your module: pub mod polkadot {{ ... }}")]
-    InvalidModule(Span),
-    /// Expected named or unnamed fields.
-    #[error("Fields should either be all named or all unnamed, make sure you are providing a valid metadata V14: {0}")]
-    InvalidFields(String),
-    /// Substitute types must have a valid path.
-    #[error("Substitute types must have a valid path")]
-    EmptySubstitutePath(Span),
-    /// Invalid type path.
-    #[error("Invalid type path {0}: {1}")]
-    InvalidTypePath(String, syn::Error),
-    /// Metadata for constant could not be found.
-    #[error("Metadata for constant entry {0}_{1} could not be found. Make sure you are providing a valid metadata V14")]
-    MissingConstantMetadata(String, String),
-    /// Metadata for storage could not be found.
-    #[error("Metadata for storage entry {0}_{1} could not be found. Make sure you are providing a valid metadata V14")]
-    MissingStorageMetadata(String, String),
-    /// Metadata for call could not be found.
-    #[error("Metadata for call entry {0}_{1} could not be found. Make sure you are providing a valid metadata V14")]
-    MissingCallMetadata(String, String),
-    /// Call variant must have all named fields.
-    #[error("Call variant for type {0} must have all named fields. Make sure you are providing a valid metadata V14")]
-    InvalidCallVariant(u32),
-    /// Type should be an variant/enum.
-    #[error(
-        "{0} type should be an variant/enum type. Make sure you are providing a valid metadata V14"
-    )]
-    InvalidType(String),
-}
-
-impl CodegenError {
-    /// Render the error as an invocation of syn::compile_error!.
-    pub fn into_compile_error(self) -> TokenStream2 {
-        let msg = self.to_string();
-        let span = match self {
-            Self::InvalidModule(span) => span,
-            Self::EmptySubstitutePath(span) => span,
-            Self::InvalidTypePath(_, err) => err.span(),
-            _ => proc_macro2::Span::call_site(),
-        };
-        syn::Error::new(span, msg).into_compile_error()
-    }
-}
-
 /// Generates the API for interacting with a Substrate runtime.
 ///
 /// # Arguments

codegen/src/api/storage.rs

@@ -92,7 +92,7 @@ fn generate_storage_entry_fns(
                     let keys = fields
                         .iter()
                         .map(|(field_name, _)| {
-                            quote!( #crate_path::storage::address::StaticStorageMapKey::new(#field_name.borrow()) )
+                            quote!( #crate_path::storage::address::make_static_storage_map_key(#field_name.borrow()) )
                         });
                     let key_impl = quote! {
                         vec![ #( #keys ),* ]
@@ -105,7 +105,7 @@ fn generate_storage_entry_fns(
                     let ty_path = type_gen.resolve_type_path(key.id());
                     let fields = vec![(format_ident!("_0"), ty_path)];
                     let key_impl = quote! {
-                        vec![ #crate_path::storage::address::StaticStorageMapKey::new(_0.borrow()) ]
+                        vec![ #crate_path::storage::address::make_static_storage_map_key(_0.borrow()) ]
                     };
                     (fields, key_impl)
                 }
@@ -134,7 +134,7 @@ fn generate_storage_entry_fns(
 
     let key_args = fields.iter().map(|(field_name, field_type)| {
         // The field type is translated from `std::vec::Vec<T>` to `[T]`. We apply
-        // AsRef to all types, so this just makes it a little more ergonomic.
+        // Borrow to all types, so this just makes it a little more ergonomic.
         //
         // TODO [jsdw]: Support mappings like `String -> str` too for better borrow
         // ergonomics.

codegen/src/error.rs

@@ -0,0 +1,120 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! Errors that can be emitted from codegen.
+
+use proc_macro2::{Span, TokenStream as TokenStream2};
+
+/// Error returned when the Codegen cannot generate the runtime API.
+#[derive(Debug, thiserror::Error)]
+pub enum CodegenError {
+    /// The given metadata type could not be found.
+    #[error("Could not find type with ID {0} in the type registry; please raise a support issue.")]
+    TypeNotFound(u32),
+    /// Cannot fetch the metadata bytes.
+    #[error("Failed to fetch metadata, make sure that you're pointing at a node which is providing V14 metadata: {0}")]
+    Fetch(#[from] FetchMetadataError),
+    /// Failed IO for the metadata file.
+    #[error("Failed IO for {0}, make sure that you are providing the correct file path for metadata V14: {1}")]
+    Io(String, std::io::Error),
+    /// Cannot decode the metadata bytes.
+    #[error("Could not decode metadata, only V14 metadata is supported: {0}")]
+    Decode(#[from] codec::Error),
+    /// Out of line modules are not supported.
+    #[error("Out-of-line subxt modules are not supported, make sure you are providing a body to your module: pub mod polkadot {{ ... }}")]
+    InvalidModule(Span),
+    /// Expected named or unnamed fields.
+    #[error("Fields should either be all named or all unnamed, make sure you are providing a valid metadata V14: {0}")]
+    InvalidFields(String),
+    /// Substitute types must have a valid path.
+    #[error("Type substitution error: {0}")]
+    TypeSubstitutionError(#[from] TypeSubstitutionError),
+    /// Invalid type path.
+    #[error("Invalid type path {0}: {1}")]
+    InvalidTypePath(String, syn::Error),
+    /// Metadata for constant could not be found.
+    #[error("Metadata for constant entry {0}_{1} could not be found. Make sure you are providing a valid metadata V14")]
+    MissingConstantMetadata(String, String),
+    /// Metadata for storage could not be found.
+    #[error("Metadata for storage entry {0}_{1} could not be found. Make sure you are providing a valid metadata V14")]
+    MissingStorageMetadata(String, String),
+    /// Metadata for call could not be found.
+    #[error("Metadata for call entry {0}_{1} could not be found. Make sure you are providing a valid metadata V14")]
+    MissingCallMetadata(String, String),
+    /// Call variant must have all named fields.
+    #[error("Call variant for type {0} must have all named fields. Make sure you are providing a valid metadata V14")]
+    InvalidCallVariant(u32),
+    /// Type should be an variant/enum.
+    #[error(
+        "{0} type should be an variant/enum type. Make sure you are providing a valid metadata V14"
+    )]
+    InvalidType(String),
+}
+
+impl CodegenError {
+    /// Fetch the location for this error.
+    // Todo: Probably worth storing location outside of the variant,
+    // so that there's a common way to set a location for some error.
+    fn get_location(&self) -> Span {
+        match self {
+            Self::InvalidModule(span) => *span,
+            Self::TypeSubstitutionError(err) => err.get_location(),
+            Self::InvalidTypePath(_, err) => err.span(),
+            _ => proc_macro2::Span::call_site(),
+        }
+    }
+    /// Render the error as an invocation of syn::compile_error!.
+    pub fn into_compile_error(self) -> TokenStream2 {
+        let msg = self.to_string();
+        let span = self.get_location();
+        syn::Error::new(span, msg).into_compile_error()
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum FetchMetadataError {
+    #[error("Cannot decode hex value: {0}")]
+    DecodeError(#[from] hex::FromHexError),
+    #[error("Request error: {0}")]
+    RequestError(#[from] jsonrpsee::core::Error),
+    #[error("'{0}' not supported, supported URI schemes are http, https, ws or wss.")]
+    InvalidScheme(String),
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum TypeSubstitutionError {
+    /// Substitute "to" type must be an absolute path.
+    #[error("The 'to' type must be a path prefixed with 'crate::' or '::'")]
+    ExpectedAbsolutePath(Span),
+    /// Substitute types must have a valid path.
+    #[error("Substitute types must have a valid path.")]
+    EmptySubstitutePath(Span),
+    #[error("Expected the from/to type generics to have the form 'Foo<A,B,C..>'.")]
+    ExpectedAngleBracketGenerics(Span),
+    /// Source substitute type must be an ident.
+    #[error("Expected an ident like 'Foo' or 'A' to mark a type to be substituted.")]
+    InvalidFromType(Span),
+    /// Target type is invalid.
+    #[error("Expected an ident like 'Foo' or an absolute concrete path like '::path::to::Bar' for the substitute type.")]
+    InvalidToType(Span),
+    /// Target ident doesn't correspond to any source type.
+    #[error("Cannot find matching param on 'from' type.")]
+    NoMatchingFromType(Span),
+}
+
+impl TypeSubstitutionError {
+    /// Fetch the location for this error.
+    // Todo: Probably worth storing location outside of the variant,
+    // so that there's a common way to set a location for some error.
+    fn get_location(&self) -> Span {
+        match self {
+            TypeSubstitutionError::ExpectedAbsolutePath(span) => *span,
+            TypeSubstitutionError::EmptySubstitutePath(span) => *span,
+            TypeSubstitutionError::ExpectedAngleBracketGenerics(span) => *span,
+            TypeSubstitutionError::InvalidFromType(span) => *span,
+            TypeSubstitutionError::InvalidToType(span) => *span,
+            TypeSubstitutionError::NoMatchingFromType(span) => *span,
+        }
+    }
+}

codegen/src/ir.rs

@@ -2,7 +2,7 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use crate::api::CodegenError;
+use crate::error::CodegenError;
 use syn::token;
 
 #[derive(Debug, PartialEq, Eq)]

codegen/src/lib.rs

@@ -46,6 +46,7 @@
 #![deny(unused_crate_dependencies)]
 
 mod api;
+mod error;
 mod ir;
 mod types;
 
@@ -54,7 +55,8 @@ pub mod utils;
 pub use self::{
     api::{
         generate_runtime_api_from_bytes, generate_runtime_api_from_path,
-        generate_runtime_api_from_url, CodegenError, RuntimeGenerator,
+        generate_runtime_api_from_url, RuntimeGenerator,
     },
+    error::{CodegenError, TypeSubstitutionError},
     types::{CratePath, Derives, DerivesRegistry, Module, TypeGenerator, TypeSubstitutes},
 };

codegen/src/types/composite_def.rs

@@ -2,7 +2,7 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use crate::api::CodegenError;
+use crate::error::CodegenError;
 
 use super::{CratePath, Derives, Field, TypeDefParameters, TypeGenerator, TypeParameter, TypePath};
 use proc_macro2::TokenStream;