Allow generation of manual types in reference options

[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 608a34aa8834ecb47a8597891916f4358de08c4d..dc8c3b939d3e3c2bf737c60b451ca55c9fedf3cb 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -215,7 +215,7 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
                                        'bound_loop: for bound in type_param.bounds.iter() {
                                                if let syn::TypeParamBound::Trait(trait_bound) = bound {
                                                        if let Some(ident) = single_ident_generic_path_to_ident(&trait_bound.path) {
-                                                               match &format!("{}", ident) as &str { "Send" => continue, "Sync" => continue, _ => {} }
+                                                               match &format!("{}", ident) as &str { "Send" => continue, "Sync" => continue, "Sized" => continue, _ => {} }
                                                        }
                                                        if path_matches_nongeneric(&trait_bound.path, &["core", "clone", "Clone"]) { continue; }
 
@@ -352,7 +352,12 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
                                                                        }
                                                                } else { unimplemented!(); }
                                                                for bound in bounds_iter {
-                                                                       if let syn::TypeParamBound::Trait(_) = bound { unimplemented!(); }
+                                                                       if let syn::TypeParamBound::Trait(t) = bound {
+                                                                               // We only allow for `?Sized` here.
+                                                                               if let syn::TraitBoundModifier::Maybe(_) = t.modifier {} else { panic!(); }
+                                                                               assert_eq!(t.path.segments.len(), 1);
+                                                                               assert_eq!(format!("{}", t.path.segments[0].ident), "Sized");
+                                                                       }
                                                                }
                                                                break;
                                                        },
@@ -589,13 +594,8 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr
                                        }
                                },
                                syn::Item::Trait(t) => {
-                                       match export_status(&t.attrs) {
-                                               ExportStatus::Export|ExportStatus::NotImplementable => {
-                                                       if let syn::Visibility::Public(_) = t.vis {
-                                                               declared.insert(t.ident.clone(), DeclType::Trait(t));
-                                                       }
-                                               },
-                                               _ => continue,
+                                       if let syn::Visibility::Public(_) = t.vis {
+                                               declared.insert(t.ident.clone(), DeclType::Trait(t));
                                        }
                                },
                                syn::Item::Mod(m) => {
@@ -859,6 +859,8 @@ pub struct CrateTypes<'a> {
        clonable_types: RefCell<HashSet<String>>,
        /// Key impls Value
        pub trait_impls: HashMap<String, Vec<String>>,
+       /// Value impls Key
+       pub traits_impld: HashMap<String, Vec<String>>,
        /// The full set of modules in the crate(s)
        pub lib_ast: &'a FullLibraryAST,
 }
@@ -869,7 +871,8 @@ impl<'a> CrateTypes<'a> {
                        opaques: HashMap::new(), mirrored_enums: HashMap::new(), traits: HashMap::new(),
                        type_aliases: HashMap::new(), reverse_alias_map: HashMap::new(),
                        templates_defined: RefCell::new(HashMap::default()), priv_structs: HashMap::new(),
-                       clonable_types: RefCell::new(initial_clonable_types()), trait_impls: HashMap::new(),
+                       clonable_types: RefCell::new(initial_clonable_types()),
+                       trait_impls: HashMap::new(), traits_impld: HashMap::new(),
                        template_file: RefCell::new(template_file), lib_ast: &libast,
                }
        }
@@ -2126,7 +2129,19 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                        if let Some(decl_type) = self.types.maybe_resolve_declared(ident) {
                                                decl_lookup(w, decl_type, &self.maybe_resolve_ident(ident).unwrap(), is_ref, is_mut);
                                        } else { unimplemented!(); }
-                               } else { unimplemented!(); }
+                               } else {
+                                       if let Some(trait_impls) = self.crate_types.traits_impld.get(&resolved_path) {
+                                               if trait_impls.len() == 1 {
+                                                       // If this is a no-export'd crate and there's only one implementation
+                                                       // in the whole crate, just treat it as a reference to whatever the
+                                                       // implementor is.
+                                                       let implementor = self.crate_types.opaques.get(&trait_impls[0]).unwrap();
+                                                       decl_lookup(w, &DeclType::StructImported { generics: &implementor.1 }, &trait_impls[0], true, is_mut);
+                                                       return;
+                                               }
+                                       }
+                                       unimplemented!();
+                               }
                        },
                        syn::Type::Array(a) => {
                                if let syn::Type::Path(p) = &*a.elem {
@@ -2666,17 +2681,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                } else { unimplemented!(); }
                        } else if let syn::Type::Path(p_arg) = t {
                                if let Some(resolved) = self.maybe_resolve_path(&p_arg.path, generics) {
-                                       if !self.is_primitive(&resolved) {
+                                       if !self.is_primitive(&resolved) && self.c_type_from_path(&resolved, false, false).is_none() {
                                                if is_ref {
                                                        // We don't currently support outer reference types for non-primitive inners
                                                        return false;
                                                }
                                        }
                                } else {
-                                       if is_ref {
-                                               // We don't currently support outer reference types for non-primitive inners
-                                               return false;
-                                       }
+                                       return false;
                                }
                                if !self.write_c_type_intern(w, t, generics, false, false, false, true, true) { return false; }
                        } else {
@@ -2964,6 +2976,18 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        }
                        true
                } else {
+                       if let Some(trait_impls) = self.crate_types.traits_impld.get(&full_path) {
+                               if trait_impls.len() == 1 {
+                                       // If this is a no-export'd crate and there's only one implementation in the
+                                       // whole crate, just treat it as a reference to whatever the implementor is.
+                                       if with_ref_lifetime {
+                                               write!(w, "&'static crate::{}", trait_impls[0]).unwrap();
+                                       } else {
+                                               write!(w, "&crate::{}", trait_impls[0]).unwrap();
+                                       }
+                                       return true;
+                               }
+                       }
                        false
                }
        }