From b7defa46972f319f4bc86fc30900862c1a459f71 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Mon, 17 Jul 2023 02:16:01 +0000 Subject: [PATCH] Handle no-export traits which are only implemented once as the implementor If we have a trait marked no-export, and there's a single implementor, we can just pretend its always the implementor. This makes sense in LDK, for example, for the `APeerManager` trait, which is implemented for all `PeerManager`s, but doesn't make sense in bindings. --- c-bindings-gen/src/main.rs | 20 ++++++++++++++------ c-bindings-gen/src/types.rs | 31 +++++++++++++++++++++++++++++-- 2 files changed, 43 insertions(+), 8 deletions(-) diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index 2cd4664..0a1d22a 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -2200,9 +2200,13 @@ fn walk_private_mod<'a>(ast_storage: &'a FullLibraryAST, orig_crate: &str, modul if let Some(trait_path) = i.trait_.as_ref() { if let Some(tp) = import_resolver.maybe_resolve_path(&trait_path.1, None) { if let Some(sp) = import_resolver.maybe_resolve_path(&p.path, None) { - match crate_types.trait_impls.entry(sp) { - hash_map::Entry::Occupied(mut e) => { e.get_mut().push(tp); }, - hash_map::Entry::Vacant(e) => { e.insert(vec![tp]); }, + match crate_types.trait_impls.entry(sp.clone()) { + hash_map::Entry::Occupied(mut e) => { e.get_mut().push(tp.clone()); }, + hash_map::Entry::Vacant(e) => { e.insert(vec![tp.clone()]); }, + } + match crate_types.traits_impld.entry(tp) { + hash_map::Entry::Occupied(mut e) => { e.get_mut().push(sp); }, + hash_map::Entry::Vacant(e) => { e.insert(vec![sp]); }, } } } @@ -2312,9 +2316,13 @@ fn walk_ast_first_pass<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut Cr } if let Some(tp) = import_resolver.maybe_resolve_path(&trait_path.1, None) { if let Some(sp) = import_resolver.maybe_resolve_path(&p.path, None) { - match crate_types.trait_impls.entry(sp) { - hash_map::Entry::Occupied(mut e) => { e.get_mut().push(tp); }, - hash_map::Entry::Vacant(e) => { e.insert(vec![tp]); }, + match crate_types.trait_impls.entry(sp.clone()) { + hash_map::Entry::Occupied(mut e) => { e.get_mut().push(tp.clone()); }, + hash_map::Entry::Vacant(e) => { e.insert(vec![tp.clone()]); }, + } + match crate_types.traits_impld.entry(tp) { + hash_map::Entry::Occupied(mut e) => { e.get_mut().push(sp); }, + hash_map::Entry::Vacant(e) => { e.insert(vec![sp]); }, } } } diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index e45fdca..bc42bda 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -864,6 +864,8 @@ pub struct CrateTypes<'a> { clonable_types: RefCell>, /// Key impls Value pub trait_impls: HashMap>, + /// Value impls Key + pub traits_impld: HashMap>, /// The full set of modules in the crate(s) pub lib_ast: &'a FullLibraryAST, } @@ -874,7 +876,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, } } @@ -2131,7 +2134,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 { @@ -2969,6 +2984,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 } } -- 2.39.5