Fix bug in contractimpl code generation for impl traits using associated types (#1401)

### What

Allow associated types in impl of traits, specifically the
CustomAccountInterface.

### Why

The use of associated types was allowed until v22 of the SDK, where an
assumption in the code generation `contractimpl` macro is causing
ambiguous code to be generated when associated types are in use.

Close #1400

Author: leighmcculloch

soroban-sdk-macros/Cargo.toml

@@ -23,7 +23,7 @@ soroban-spec = { workspace = true }
 soroban-spec-rust = { workspace = true }
 soroban-env-common = { workspace = true }
 stellar-xdr = { workspace = true, features = ["curr", "std"] }
-syn = {version="2.0",features=["full"]}
+syn = {version="2.0.77",features=["full"]}
 quote = "1.0"
 proc-macro2 = "1.0"
 itertools = "0.10.5"

soroban-sdk-macros/src/syn_ext.rs

@@ -1,5 +1,6 @@
 use proc_macro2::TokenStream;
-use quote::{quote, ToTokens};
+use quote::{format_ident, quote, ToTokens};
+use std::collections::HashMap;
 use syn::{
     parse::{Parse, ParseStream},
     punctuated::Punctuated,
@@ -133,9 +134,12 @@ impl Parse for HasFnsItem {
         _ = input.parse::<Token![pub]>();
         let lookahead = input.lookahead1();
         if lookahead.peek(Token![trait]) {
-            input.parse().map(HasFnsItem::Trait)
+            let t = input.parse()?;
+            Ok(HasFnsItem::Trait(t))
         } else if lookahead.peek(Token![impl]) {
-            input.parse().map(HasFnsItem::Impl)
+            let mut imp = input.parse()?;
+            flatten_associated_items_in_impl_fns(&mut imp);
+            Ok(HasFnsItem::Impl(imp))
         } else {
             Err(lookahead.error())
         }
@@ -209,3 +213,45 @@ fn unpack_result(typ: &Type) -> Option<(Type, Type)> {
         _ => None,
     }
 }
+
+fn flatten_associated_items_in_impl_fns(imp: &mut ItemImpl) {
+    // TODO: Flatten associated consts used in functions.
+    // Flatten associated types used in functions.
+    let associated_types = imp
+        .items
+        .iter()
+        .filter_map(|item| match item {
+            ImplItem::Type(i) => Some((i.ident.clone(), i.ty.clone())),
+            _ => None,
+        })
+        .collect::<HashMap<_, _>>();
+    let fn_input_types = imp
+        .items
+        .iter_mut()
+        .filter_map(|item| match item {
+            ImplItem::Fn(f) => Some(f.sig.inputs.iter_mut().filter_map(|input| match input {
+                FnArg::Typed(t) => Some(&mut t.ty),
+                _ => None,
+            })),
+            _ => None,
+        })
+        .flatten();
+    for t in fn_input_types {
+        if let Type::Path(TypePath { qself: None, path }) = t.as_mut() {
+            let segments = &path.segments;
+            if segments.len() == 2
+                && segments.first() == Some(&PathSegment::from(format_ident!("Self")))
+            {
+                if let Some(PathSegment {
+                    arguments: PathArguments::None,
+                    ident,
+                }) = segments.get(1)
+                {
+                    if let Some(resolved_ty) = associated_types.get(ident) {
+                        *t.as_mut() = resolved_ty.clone();
+                    }
+                }
+            }
+        }
+    }
+}

soroban-sdk/src/tests.rs

@@ -7,6 +7,7 @@ mod bytes_alloc_vec;
 mod bytes_buffer;
 mod contract_add_i32;
 mod contract_assert;
+mod contract_custom_account_impl;
 mod contract_docs;
 mod contract_duration;
 mod contract_fn;

soroban-sdk/src/tests/contract_custom_account_impl.rs

@@ -0,0 +1,48 @@
+use crate::{self as soroban_sdk, BytesN, IntoVal};
+use soroban_sdk::{
+    auth::{Context, CustomAccountInterface},
+    contract, contracterror, contractimpl,
+    crypto::Hash,
+    Env, Vec,
+};
+
+#[contract]
+pub struct Contract;
+
+#[contracterror]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Error {
+    Fail = 1,
+}
+
+#[contractimpl]
+impl CustomAccountInterface for Contract {
+    type Signature = ();
+    type Error = Error;
+
+    /// Check that the signatures and auth contexts are valid.
+    fn __check_auth(
+        _env: Env,
+        _signature_payload: Hash<32>,
+        _signatures: Self::Signature,
+        _auth_contexts: Vec<Context>,
+    ) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[test]
+fn test_functional() {
+    let e = Env::default();
+    let contract_id = e.register(Contract, ());
+    let payload = BytesN::from_array(&e, &[0; 32]);
+    let signature = ();
+    let auth_context = Vec::new(&e);
+    let result = e.try_invoke_contract_check_auth::<Error>(
+        &contract_id,
+        &payload,
+        signature.into_val(&e),
+        &auth_context,
+    );
+    assert_eq!(result, Ok(()));
+}

soroban-sdk/test_snapshots/tests/contract_custom_account_impl/test_functional.1.json

@@ -0,0 +1,76 @@
+{
+  "generators": {
+    "address": 1,
+    "nonce": 0
+  },
+  "auth": [
+    [],
+    []
+  ],
+  "ledger": {
+    "protocol_version": 22,
+    "sequence_number": 0,
+    "timestamp": 0,
+    "network_id": "0000000000000000000000000000000000000000000000000000000000000000",
+    "base_reserve": 0,
+    "min_persistent_entry_ttl": 4096,
+    "min_temp_entry_ttl": 16,
+    "max_entry_ttl": 6312000,
+    "ledger_entries": [
+      [
+        {
+          "contract_data": {
+            "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+            "key": "ledger_key_contract_instance",
+            "durability": "persistent"
+          }
+        },
+        [
+          {
+            "last_modified_ledger_seq": 0,
+            "data": {
+              "contract_data": {
+                "ext": "v0",
+                "contract": "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM",
+                "key": "ledger_key_contract_instance",
+                "durability": "persistent",
+                "val": {
+                  "contract_instance": {
+                    "executable": {
+                      "wasm": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+                    },
+                    "storage": null
+                  }
+                }
+              }
+            },
+            "ext": "v0"
+          },
+          4095
+        ]
+      ],
+      [
+        {
+          "contract_code": {
+            "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+          }
+        },
+        [
+          {
+            "last_modified_ledger_seq": 0,
+            "data": {
+              "contract_code": {
+                "ext": "v0",
+                "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+                "code": ""
+              }
+            },
+            "ext": "v0"
+          },
+          4095
+        ]
+      ]
+    ]
+  },
+  "events": []
+}

tests/account/src/lib.rs

@@ -21,7 +21,7 @@ impl CustomAccountInterface for Contract {
     fn __check_auth(
         _env: Env,
         _signature_payload: Hash<32>,
-        _signatures: (),
+        _signatures: Self::Signature,
         _auth_contexts: Vec<Context>,
     ) -> Result<(), Error> {
         Ok(())