Add #[abi_name(name = "foo") attribute to rename ABI items.

Add `#[abi_name(name = "foo")` attribute to rename enum and struct ABI
items.

Here is example of how it can be used:

```sway
contract;

#[abi_name(name = "RenamedMyScript")]
struct MyStruct {}

#[abi_name(name = "RenamedMyEnum")]
enum MyEnum {
  A: ()
}

abi MyAbi {
    fn my_struct() -> MyStruct;
    fn my_enum() -> MyEnum;
}

impl MyAbi for Contract {
  fn my_struct() -> MyStruct { MyStruct{} }
  fn my_enum() -> MyEnum { MyEnum::A }
}
```

Closes #5955.

Author: tritao

sway-ast/src/attribute.rs

@@ -47,6 +47,10 @@ pub const CFG_PROGRAM_TYPE_ARG_NAME: &str = "program_type";
 pub const DEPRECATED_ATTRIBUTE_NAME: &str = "deprecated";
 pub const DEPRECATED_NOTE_ARG_NAME: &str = "note";
 
+// Abi names.
+pub const ABI_NAME_ATTRIBUTE_NAME: &str = "abi_name";
+pub const ABI_NAME_NAME_ARG_NAME: &str = "name";
+
 pub const KNOWN_ATTRIBUTE_NAMES: &[&str] = &[
     STORAGE_ATTRIBUTE_NAME,
     DOC_COMMENT_ATTRIBUTE_NAME,
@@ -57,6 +61,7 @@ pub const KNOWN_ATTRIBUTE_NAMES: &[&str] = &[
     CFG_ATTRIBUTE_NAME,
     DEPRECATED_ATTRIBUTE_NAME,
     FALLBACK_ATTRIBUTE_NAME,
+    ABI_NAME_ATTRIBUTE_NAME,
 ];
 
 /// An attribute declaration. Attribute declaration

sway-core/src/abi_generation/abi_str.rs

@@ -1,6 +1,7 @@
-use sway_types::{integer_bits::IntegerBits, Named};
+use sway_error::handler::{ErrorEmitted, Handler};
+use sway_types::{integer_bits::IntegerBits, BaseIdent, Named};
 
-use crate::{language::CallPath, Engines, GenericArgument, TypeId, TypeInfo};
+use crate::{language::CallPath, transform, Engines, GenericArgument, TypeId, TypeInfo};
 
 #[derive(Clone)]
 pub struct AbiStrContext {
@@ -14,14 +15,17 @@ impl TypeId {
     /// Gives back a string that represents the type, considering what it resolves to
     pub fn get_abi_type_str(
         &self,
+        handler: &Handler,
         ctx: &AbiStrContext,
         engines: &Engines,
         resolved_type_id: TypeId,
-    ) -> String {
+    ) -> Result<String, ErrorEmitted> {
         let type_engine = engines.te();
-        let self_abi_str = type_engine.get(*self).abi_str(ctx, engines, true);
+        let self_abi_str = type_engine
+            .get(*self)
+            .abi_str(handler, ctx, engines, true)?;
         if self.is_generic_parameter(engines, resolved_type_id) {
-            format!("generic {}", self_abi_str)
+            Ok(format!("generic {}", self_abi_str))
         } else {
             match (
                 &*type_engine.get(*self),
@@ -30,23 +34,26 @@ impl TypeId {
                 (TypeInfo::Custom { .. }, TypeInfo::Struct { .. })
                 | (TypeInfo::Custom { .. }, TypeInfo::Enum { .. }) => type_engine
                     .get(resolved_type_id)
-                    .abi_str(ctx, engines, true),
+                    .abi_str(handler, ctx, engines, true),
                 (_, TypeInfo::Alias { ty, .. }) => {
-                    ty.type_id().get_abi_type_str(ctx, engines, ty.type_id())
+                    ty.type_id()
+                        .get_abi_type_str(handler, ctx, engines, ty.type_id())
                 }
                 (TypeInfo::Tuple(fields), TypeInfo::Tuple(resolved_fields)) => {
                     assert_eq!(fields.len(), resolved_fields.len());
                     let field_strs = resolved_fields
                         .iter()
                         .map(|f| {
                             if ctx.abi_with_fully_specified_types {
-                                type_engine.get(f.type_id()).abi_str(ctx, engines, false)
+                                type_engine
+                                    .get(f.type_id())
+                                    .abi_str(handler, ctx, engines, false)
                             } else {
-                                "_".to_string()
+                                Ok("_".to_string())
                             }
                         })
-                        .collect::<Vec<String>>();
-                    format!("({})", field_strs.join(", "))
+                        .collect::<Result<Vec<String>, _>>()?;
+                    Ok(format!("({})", field_strs.join(", ")))
                 }
                 (TypeInfo::Array(_, length), TypeInfo::Array(type_arg, resolved_length)) => {
                     assert_eq!(
@@ -56,76 +63,80 @@ impl TypeId {
                     let inner_type = if ctx.abi_with_fully_specified_types {
                         type_engine
                             .get(type_arg.type_id())
-                            .abi_str(ctx, engines, false)
+                            .abi_str(handler, ctx, engines, false)?
                     } else {
                         "_".to_string()
                     };
-                    format!("[{}; {:?}]", inner_type, engines.help_out(length))
+                    Ok(format!("[{}; {:?}]", inner_type, engines.help_out(length)))
                 }
                 (TypeInfo::Slice(type_arg), TypeInfo::Slice(_)) => {
                     let inner_type = if ctx.abi_with_fully_specified_types {
                         type_engine
                             .get(type_arg.type_id())
-                            .abi_str(ctx, engines, false)
+                            .abi_str(handler, ctx, engines, false)?
                     } else {
                         "_".to_string()
                     };
-                    format!("[{}]", inner_type)
-                }
-                (TypeInfo::Custom { .. }, _) => {
-                    format!("generic {}", self_abi_str)
+                    Ok(format!("[{}]", inner_type))
                 }
+                (TypeInfo::Custom { .. }, _) => Ok(format!("generic {}", self_abi_str)),
                 _ => type_engine
                     .get(resolved_type_id)
-                    .abi_str(ctx, engines, true),
+                    .abi_str(handler, ctx, engines, true),
             }
         }
     }
 }
 
 impl TypeInfo {
-    pub fn abi_str(&self, ctx: &AbiStrContext, engines: &Engines, is_root: bool) -> String {
+    pub fn abi_str(
+        &self,
+        handler: &Handler,
+        ctx: &AbiStrContext,
+        engines: &Engines,
+        is_root: bool,
+    ) -> Result<String, ErrorEmitted> {
         use TypeInfo::*;
         let decl_engine = engines.de();
         match self {
-            Unknown => "unknown".into(),
-            Never => "never".into(),
-            UnknownGeneric { name, .. } => name.to_string(),
-            Placeholder(_) => "_".to_string(),
-            TypeParam(param) => format!("typeparam({})", param.name()),
-            StringSlice => "str".into(),
-            StringArray(length) => format!("str[{}]", length.val()),
-            UnsignedInteger(x) => match x {
+            Unknown => Ok("unknown".into()),
+            Never => Ok("never".into()),
+            UnknownGeneric { name, .. } => Ok(name.to_string()),
+            Placeholder(_) => Ok("_".to_string()),
+            TypeParam(param) => Ok(format!("typeparam({})", param.name())),
+            StringSlice => Ok("str".into()),
+            StringArray(length) => Ok(format!("str[{}]", length.val())),
+            UnsignedInteger(x) => Ok(match x {
                 IntegerBits::Eight => "u8",
                 IntegerBits::Sixteen => "u16",
                 IntegerBits::ThirtyTwo => "u32",
                 IntegerBits::SixtyFour => "u64",
                 IntegerBits::V256 => "u256",
             }
-            .into(),
-            Boolean => "bool".into(),
+            .into()),
+            Boolean => Ok("bool".into()),
             Custom {
                 qualified_call_path: call_path,
                 ..
-            } => call_path.call_path.suffix.to_string(),
+            } => Ok(call_path.call_path.suffix.to_string()),
             Tuple(fields) => {
                 let field_strs = fields
                     .iter()
-                    .map(|field| field.abi_str(ctx, engines, false))
-                    .collect::<Vec<String>>();
-                format!("({})", field_strs.join(", "))
+                    .map(|field| field.abi_str(handler, ctx, engines, false))
+                    .collect::<Result<Vec<String>, ErrorEmitted>>()?;
+                Ok(format!("({})", field_strs.join(", ")))
             }
-            B256 => "b256".into(),
-            Numeric => "u64".into(), // u64 is the default
-            Contract => "contract".into(),
-            ErrorRecovery(_) => "unknown due to error".into(),
+            B256 => Ok("b256".into()),
+            Numeric => Ok("u64".into()), // u64 is the default
+            Contract => Ok("contract".into()),
+            ErrorRecovery(_) => Ok("unknown due to error".into()),
             UntypedEnum(decl_id) => {
                 let decl = engines.pe().get_enum(decl_id);
-                format!("untyped enum {}", decl.name)
+                Ok(format!("untyped enum {}", decl.name))
             }
             UntypedStruct(decl_id) => {
                 let decl = engines.pe().get_struct(decl_id);
-                format!("untyped struct {}", decl.name)
+                Ok(format!("untyped struct {}", decl.name))
             }
             Enum(decl_ref) => {
                 let decl = decl_engine.get_enum(decl_ref);
@@ -134,20 +145,19 @@ impl TypeInfo {
                 {
                     "".into()
                 } else {
-                    format!(
-                        "<{}>",
-                        decl.type_parameters
-                            .iter()
-                            .map(|p| p.abi_str(engines, ctx, false))
-                            .collect::<Vec<_>>()
-                            .join(",")
-                    )
+                    let params = decl
+                        .type_parameters
+                        .iter()
+                        .map(|p| p.abi_str(handler, engines, ctx, false))
+                        .collect::<Result<Vec<_>, _>>()?;
+                    format!("<{}>", params.join(","))
                 };
-                format!(
+                let abi_call_path = get_abi_call_path(handler, &decl.call_path, &decl.attributes)?;
+                Ok(format!(
                     "enum {}{}",
-                    call_path_display(ctx, &decl.call_path),
+                    call_path_display(ctx, &abi_call_path),
                     type_params
-                )
+                ))
             }
             Struct(decl_ref) => {
                 let decl = decl_engine.get_struct(decl_ref);
@@ -156,58 +166,69 @@ impl TypeInfo {
                 {
                     "".into()
                 } else {
-                    format!(
-                        "<{}>",
-                        decl.type_parameters
-                            .iter()
-                            .map(|p| p.abi_str(engines, ctx, false))
-                            .collect::<Vec<_>>()
-                            .join(",")
-                    )
+                    let params = decl
+                        .type_parameters
+                        .iter()
+                        .map(|p| p.abi_str(handler, engines, ctx, false))
+                        .collect::<Result<Vec<_>, _>>()?;
+                    format!("<{}>", params.join(","))
                 };
-                format!(
+                let abi_call_path = get_abi_call_path(handler, &decl.call_path, &decl.attributes)?;
+                Ok(format!(
                     "struct {}{}",
-                    call_path_display(ctx, &decl.call_path),
+                    call_path_display(ctx, &abi_call_path),
                     type_params
-                )
-            }
-            ContractCaller { abi_name, .. } => {
-                format!("contract caller {abi_name}")
-            }
-            Array(elem_ty, length) => {
-                format!(
-                    "[{}; {:?}]",
-                    elem_ty.abi_str(ctx, engines, false),
-                    engines.help_out(length)
-                )
+                ))
             }
-            RawUntypedPtr => "raw untyped ptr".into(),
-            RawUntypedSlice => "raw untyped slice".into(),
-            Ptr(ty) => {
-                format!("__ptr {}", ty.abi_str(ctx, engines, false))
-            }
-            Slice(ty) => {
-                format!("__slice {}", ty.abi_str(ctx, engines, false))
-            }
-            Alias { ty, .. } => ty.abi_str(ctx, engines, false),
+            ContractCaller { abi_name, .. } => Ok(format!("contract caller {abi_name}")),
+            Array(elem_ty, length) => Ok(format!(
+                "[{}; {:?}]",
+                elem_ty.abi_str(handler, ctx, engines, false)?,
+                engines.help_out(length)
+            )),
+            RawUntypedPtr => Ok("raw untyped ptr".into()),
+            RawUntypedSlice => Ok("raw untyped slice".into()),
+            Ptr(ty) => Ok(format!(
+                "__ptr {}",
+                ty.abi_str(handler, ctx, engines, false)?
+            )),
+            Slice(ty) => Ok(format!(
+                "__slice {}",
+                ty.abi_str(handler, ctx, engines, false)?
+            )),
+            Alias { ty, .. } => Ok(ty.abi_str(handler, ctx, engines, false)?),
             TraitType {
                 name,
                 trait_type_id: _,
-            } => format!("trait type {}", name),
+            } => Ok(format!("trait type {}", name)),
             Ref {
                 to_mutable_value,
                 referenced_type,
             } => {
-                format!(
+                Ok(format!(
                     "__ref {}{}", // TODO-IG: No references in ABIs according to the RFC. Or we want to have them?
                     if *to_mutable_value { "mut " } else { "" },
-                    referenced_type.abi_str(ctx, engines, false)
-                )
+                    referenced_type.abi_str(handler, ctx, engines, false)?
+                ))
             }
         }
     }
 }
 
+fn get_abi_call_path(
+    handler: &Handler,
+    call_path: &CallPath,
+    attributes: &transform::Attributes,
+) -> Result<CallPath, ErrorEmitted> {
+    let mut abi_call_path = call_path.clone();
+    if let Some(abi_name_attr) = attributes.abi_name() {
+        let name = abi_name_attr.args.first().unwrap();
+        let span = name.get_string_span(handler, abi_name_attr)?;
+        abi_call_path.suffix = BaseIdent::new(span);
+    }
+    Ok(abi_call_path)
+}
+
 /// `call_path_display`  returns the provided `call_path` without the first prefix in case it is equal to the program name.
 /// If the program name is `my_program` and the `call_path` is `my_program::MyStruct` then this function returns only `MyStruct`.
 fn call_path_display(ctx: &AbiStrContext, call_path: &CallPath) -> String {
@@ -228,10 +249,16 @@ fn call_path_display(ctx: &AbiStrContext, call_path: &CallPath) -> String {
 }
 
 impl GenericArgument {
-    pub(self) fn abi_str(&self, ctx: &AbiStrContext, engines: &Engines, is_root: bool) -> String {
+    pub(self) fn abi_str(
+        &self,
+        handler: &Handler,
+        ctx: &AbiStrContext,
+        engines: &Engines,
+        is_root: bool,
+    ) -> Result<String, ErrorEmitted> {
         engines
             .te()
             .get(self.type_id())
-            .abi_str(ctx, engines, is_root)
+            .abi_str(handler, ctx, engines, is_root)
     }
 }