Support concretizing generics in template parameters

[ldk-c-bindings] / c-bindings-gen / src / types.rs

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 92da8727929bd1f0ef43b245fc2895b05bc95aa0..acfcc1d8a8c26c0b85a3493ae1c82646733fe38b 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -413,10 +413,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
                                                        else { process_alias = false; }
                                                }
                                                if process_alias {
-                                                       match &*t.ty {
-                                                               syn::Type::Path(_) => { declared.insert(t.ident.clone(), DeclType::StructImported); },
-                                                               _ => {},
-                                                       }
+                                                       declared.insert(t.ident.clone(), DeclType::StructImported);
                                                }
                                        }
                                },
@@ -510,11 +507,20 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
        pub fn resolve_imported_refs(&self, mut ty: syn::Type) -> syn::Type {
                match &mut ty {
                        syn::Type::Path(p) => {
-                               if let Some(ident) = p.path.get_ident() {
-                                       if let Some((_, newpath)) = self.imports.get(ident) {
-                                               p.path = newpath.clone();
+eprintln!("rir {:?}", p);
+                               if p.path.segments.len() != 1 { unimplemented!(); }
+                               let mut args = p.path.segments[0].arguments.clone();
+                               if let syn::PathArguments::AngleBracketed(ref mut generics) = &mut args {
+                                       for arg in generics.args.iter_mut() {
+                                               if let syn::GenericArgument::Type(ref mut t) = arg {
+                                                       *t = self.resolve_imported_refs(t.clone());
+                                               }
                                        }
-                               } else { unimplemented!(); }
+                               }
+                               if let Some((_, newpath)) = self.imports.get(single_ident_generic_path_to_ident(&p.path).unwrap()) {
+                                       p.path = newpath.clone();
+                               }
+                               p.path.segments[0].arguments = args;
                        },
                        syn::Type::Reference(r) => {
                                r.elem = Box::new(self.resolve_imported_refs((*r.elem).clone()));