Add support for ABI alias types

Author: tritao

Cargo.toml

@@ -8,6 +8,7 @@ resolver = "2"
 members = [
   "e2e",
   "examples/codec",
+  "examples/codegen",
   "examples/contracts",
   "examples/cookbook",
   "examples/debugging",
@@ -52,7 +53,8 @@ cynic = { version = "3.1.0", default-features = false }
 test-case = { version = "3.3", default-features = false }
 eth-keystore = "0.5.0"
 flate2 = { version = "1.0", default-features = false }
-fuel-abi-types = "0.13.0"
+#fuel-abi-types = "0.13.0"
+fuel-abi-types = { path = "../fuel-abi-types", version = "0.13.0" }
 futures = "0.3.29"
 hex = { version = "0.4.3", default-features = false }
 itertools = "0.12.0"

examples/codegen/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "fuels-example-codegen"
+version = { workspace = true }
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = false
+repository = { workspace = true }
+description = "Fuel Rust SDK macro examples."
+
+[dev-dependencies]
+fuels = { workspace = true, features = ["default"] }
+tokio = { workspace = true, features = ["full"] }

examples/codegen/src/lib.rs

@@ -0,0 +1,19 @@
+extern crate alloc;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn example_alias() {
+        use fuels::code_gen::*;
+
+        let target = AbigenTarget::new(
+            "MyContract".into(),
+            Abi::load_from("/home/joao/dev/sway/_test_aliases_abi/out/debug/test-case-abi.json")
+                .unwrap(),
+            ProgramType::Contract,
+        );
+        let targets = vec![target];
+
+        let abigen = Abigen::generate(targets, false).expect("abigen generation failed");
+    }
+}

packages/fuels-code-gen/src/program_bindings/abigen.rs

@@ -34,8 +34,15 @@ impl Abigen {
     ///   for, and of what nature (Contract, Script or Predicate).
     /// * `no_std`: don't use the Rust std library.
     pub fn generate(targets: Vec<AbigenTarget>, no_std: bool) -> Result<TokenStream> {
+        // eprintln!("{:#?}", targets);
+
         let generated_code = Self::generate_code(no_std, targets)?;
 
+        eprintln!(
+            "========================== CODE: \n {:#}",
+            generated_code.code()
+        );
+
         let use_statements = generated_code.use_statements_for_uniquely_named_types();
 
         let code = if no_std {
@@ -67,10 +74,18 @@ impl Abigen {
 
     fn generate_code(no_std: bool, parsed_targets: Vec<AbigenTarget>) -> Result<GeneratedCode> {
         let custom_types = Self::filter_custom_types(&parsed_targets);
-        let shared_types = Self::filter_shared_types(custom_types);
+        let mut shared_types = Self::filter_shared_types(custom_types);
+
+        let alias_types = Self::filter_alias_types(&parsed_targets)
+            .cloned()
+            .collect::<Vec<_>>();
+        shared_types.clear();
+        shared_types.extend(alias_types);
 
         let bindings = Self::generate_all_bindings(parsed_targets, no_std, &shared_types)?;
+        eprintln!("bindings {:#}", bindings.code().to_string());
         let shared_types = Self::generate_shared_types(shared_types, no_std)?;
+        eprintln!("shared_types {:#}", shared_types.code().to_string());
 
         let mod_name = ident("abigen_bindings");
         Ok(shared_types.merge(bindings).wrap_in_mod(mod_name))
@@ -94,11 +109,14 @@ impl Abigen {
         no_std: bool,
         shared_types: &HashSet<FullTypeDeclaration>,
     ) -> Result<GeneratedCode> {
+        eprintln!("generate_bindings shared_types {:#?}", shared_types);
         let mod_name = ident(&format!("{}_mod", &target.name.to_snake_case()));
 
         let recompile_trigger =
             Self::generate_macro_recompile_trigger(target.source.path.as_ref(), no_std);
         let types = generate_types(&target.source.abi.types, shared_types, no_std)?;
+        eprintln!("generate_bindings types {:#?}", types);
+
         let bindings = generate_bindings(target, no_std)?;
         Ok(recompile_trigger
             .merge(types)
@@ -145,6 +163,15 @@ impl Abigen {
             .filter(|ttype| ttype.is_custom_type())
     }
 
+    fn filter_alias_types(
+        all_types: &[AbigenTarget],
+    ) -> impl Iterator<Item = &FullTypeDeclaration> {
+        all_types
+            .iter()
+            .flat_map(|target| &target.source.abi.types)
+            .filter(|ttype| ttype.is_alias_type())
+    }
+
     /// A type is considered "shared" if it appears at least twice in
     /// `all_custom_types`.
     ///

packages/fuels-code-gen/src/program_bindings/abigen/abigen_target.rs

@@ -12,9 +12,9 @@ use crate::error::{Error, Result, error};
 
 #[derive(Debug, Clone)]
 pub struct AbigenTarget {
-    pub(crate) name: String,
-    pub(crate) source: Abi,
-    pub(crate) program_type: ProgramType,
+    pub name: String,
+    pub source: Abi,
+    pub program_type: ProgramType,
 }
 
 impl AbigenTarget {

packages/fuels-code-gen/src/program_bindings/custom_types.rs

@@ -40,6 +40,8 @@ pub(crate) fn generate_types<'a, T: IntoIterator<Item = &'a FullTypeDeclaration>
         .map(|ttype: &FullTypeDeclaration| {
             if shared_types.contains(ttype) {
                 reexport_the_shared_type(ttype, no_std)
+            } else if ttype.is_alias_type() {
+                expand_alias_type(ttype, no_std)
             } else if ttype.is_struct_type() {
                 expand_custom_struct(ttype, no_std)
             } else {
@@ -51,13 +53,36 @@ pub(crate) fn generate_types<'a, T: IntoIterator<Item = &'a FullTypeDeclaration>
         })
 }
 
+fn expand_alias_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result<GeneratedCode> {
+    let type_path = ttype.alias_type_path().expect("This must be an alias type");
+
+    let type_mod = type_path.parent();
+
+    let top_lvl_mod = TypePath::default();
+    let from_current_mod_to_top_level = top_lvl_mod.relative_path_from(&type_mod);
+
+    let path = from_current_mod_to_top_level
+        .append(type_path);
+
+    let the_reexport = quote! {pub use #path;};
+
+    Ok(GeneratedCode::new(the_reexport, Default::default(), no_std).wrap_in_mod(type_mod))
+}
+
 /// Instead of generating bindings for `ttype` this fn will just generate a `pub use` pointing to
 /// the already generated equivalent shared type.
 fn reexport_the_shared_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result<GeneratedCode> {
+
     // e.g. some_library::another_mod::SomeStruct
-    let type_path = ttype
+    let type_path = if ttype.is_custom_type() {
+        ttype
         .custom_type_path()
-        .expect("This must be a custom type due to the previous filter step");
+        .expect("This must be a custom type due to the previous filter step")
+    }  else if ttype.is_alias_type() {
+        ttype.alias_type_path().expect("This must be an alias type")
+    } else {
+        unreachable!()
+    };
 
     let type_mod = type_path.parent();
 
@@ -85,6 +110,10 @@ fn reexport_the_shared_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result
 // implementation details of the contract's Vec type and are not directly
 // used in the SDK.
 fn should_skip_codegen(type_decl: &FullTypeDeclaration) -> bool {
+    if type_decl.is_alias_type() {
+        return false;
+    }
+
     if !type_decl.is_custom_type() {
         return true;
     }

packages/fuels-code-gen/src/program_bindings/resolved_type.rs

@@ -1,4 +1,7 @@
-use std::fmt::{Display, Formatter};
+use std::{
+    fmt::{Display, Formatter},
+    sync::Arc,
+};
 
 use fuel_abi_types::{
     abi::full_program::FullTypeApplication,
@@ -44,6 +47,10 @@ pub enum ResolvedType {
     Array(Box<ResolvedType>, usize),
     Tuple(Vec<ResolvedType>),
     Generic(GenericType),
+    Alias {
+        path: TypePath,
+        target: Arc<ResolvedType>,
+    },
 }
 
 impl ResolvedType {
@@ -57,6 +64,7 @@ impl ResolvedType {
             }
             ResolvedType::Array(el, _) => el.generics(),
             ResolvedType::Generic(inner) => vec![inner.clone()],
+            ResolvedType::Alias { target, .. } => target.generics(),
             _ => vec![],
         }
     }
@@ -82,6 +90,10 @@ impl ToTokens for ResolvedType {
                 quote! { (#(#elements,)*) }
             }
             ResolvedType::Generic(generic_type) => generic_type.into_token_stream(),
+            ResolvedType::Alias { path, .. } => {
+                path.to_token_stream()
+                // target.as_ref().into_token_stream()
+            }
         };
 
         tokens.extend(tokenized)
@@ -122,6 +134,7 @@ impl TypeResolver {
             Self::try_as_tuple,
             Self::try_as_raw_slice,
             Self::try_as_custom_type,
+            Self::try_as_alias_type,
         ];
 
         for resolver in resolvers {
@@ -302,6 +315,42 @@ impl TypeResolver {
             generics,
         }))
     }
+
+    fn try_as_alias_type(
+        &self,
+        type_application: &FullTypeApplication,
+    ) -> Result<Option<ResolvedType>> {
+        let type_decl = &type_application.type_decl;
+
+        if !type_decl.is_alias_type() {
+            return Ok(None);
+        }
+
+        let Some(alias_of) = &type_decl.alias_of else {
+            return Ok(None);
+        };
+
+        let target = Arc::new(self.resolve(alias_of)?);
+
+        let path = if let Ok(custom_type_path) = type_decl.custom_type_path() {
+            custom_type_path
+        } else {
+            type_decl.alias_type_path()?
+        };
+
+        let path = path.relative_path_from(&self.current_mod);
+
+        Ok(Some(ResolvedType::Alias { path, target }))
+
+        // if let Some(alias_app) = &type_decl.alias_of {
+        //     let resolver = TypeResolver::default();
+        //     let resolved_alias = resolver.resolve(alias_app)?;
+        //     let resolved_type = ResolvedType::Alias(Arc::new(resolved_alias));
+        //     return Ok(Some(resolved_type));
+        // }
+
+        // Ok(None)
+    }
 }
 
 #[cfg(test)]

packages/fuels/Cargo.toml

@@ -18,6 +18,7 @@ fuel-core-client = { workspace = true, optional = true }
 fuel-crypto = { workspace = true }
 fuel-tx = { workspace = true }
 fuels-accounts = { workspace = true, default-features = false }
+fuels-code-gen = { workspace = true }
 fuels-core = { workspace = true }
 fuels-macros = { workspace = true }
 fuels-programs = { workspace = true }

packages/fuels/src/lib.rs

@@ -29,6 +29,10 @@ pub mod client {
     };
 }
 
+pub mod code_gen {
+    pub use fuels_code_gen::*;
+}
+
 pub mod macros {
     pub use fuels_macros::*;
 }