From 50af954e76be66d0a1a4e3ba210bd849c4780b8d Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 27 Oct 2022 00:15:31 +0000 Subject: [PATCH] (Partially) support supertraits with generic bounds If we extend a supertrait where the supertrait is generic, we will ultimately need to genericize the supertrait into a derived object. This doesn't implement that part, but it does implement the subtrait-writing code to make it compatible with such a future. --- c-bindings-gen/src/blocks.rs | 12 +++++- c-bindings-gen/src/main.rs | 71 +++++++++++++++++++----------------- c-bindings-gen/src/types.rs | 19 +++++++++- 3 files changed, 64 insertions(+), 38 deletions(-) diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 84a971b..e6d1528 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -747,7 +747,7 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu /// Prints concrete generic parameters for a struct/trait/function, including the less-than and /// greater-than symbols, if any generic parameters are defined. -pub fn maybe_write_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver, concrete_lifetimes: bool) { +pub fn maybe_write_generics(w: &mut W, generics: &syn::Generics, generics_impld: &syn::PathArguments, types: &TypeResolver, concrete_lifetimes: bool) { let mut gen_types = GenericTypes::new(None); assert!(gen_types.learn_generics(generics, types)); if generics.params.is_empty() { return; } @@ -778,7 +778,15 @@ pub fn maybe_write_generics(w: &mut W, generics: &syn::Generi syn::GenericParam::Type(type_param) => { write!(w, "{}", if idx != 0 { ", " } else { "" }).unwrap(); let type_ident = &type_param.ident; - types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false); + if types.understood_c_type(&syn::parse_quote!(#type_ident), Some(&gen_types)) { + types.write_c_type_in_generic_param(w, &syn::parse_quote!(#type_ident), Some(&gen_types), false); + } else { + if let syn::PathArguments::AngleBracketed(args) = generics_impld { + if let syn::GenericArgument::Type(ty) = &args.args[idx] { + types.write_c_type_in_generic_param(w, &ty, Some(&gen_types), false); + } + } + } }, syn::GenericParam::Lifetime(lt) => { if concrete_lifetimes { diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index b07bb26..975db56 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -244,14 +244,15 @@ macro_rules! walk_supertraits { ($t: expr, $types: expr, ($( $($pat: pat)|* => $ let types_opt: Option<&TypeResolver> = $types; if let Some(types) = types_opt { if let Some(path) = types.maybe_resolve_path(&supertrait.path, None) { - match (&path as &str, &supertrait.path.segments.iter().last().unwrap().ident) { + let last_seg = supertrait.path.segments.iter().last().unwrap(); + match (&path as &str, &last_seg.ident, &last_seg.arguments) { $( $($pat)|* => $e, )* } continue; } } if let Some(ident) = supertrait.path.get_ident() { - match (&format!("{}", ident) as &str, &ident) { + match (&format!("{}", ident) as &str, &ident, &syn::PathArguments::None) { $( $($pat)|* => $e, )* } } else if types_opt.is_some() { @@ -292,14 +293,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty } writeln_docs(w, &t.attrs, ""); - let mut gen_types = GenericTypes::new(None); + let mut gen_types = GenericTypes::new(Some(format!("{}::{}", types.module_path, trait_name))); // Add functions which may be required for supertrait implementations. // Due to borrow checker limitations, we only support one in-crate supertrait here. let supertrait_name; let supertrait_resolver; walk_supertraits!(t, Some(&types), ( - (s, _i) => { + (s, _i, _) => { if let Some(supertrait) = types.crate_types.traits.get(s) { supertrait_name = s.to_string(); supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_libs, types.crate_types); @@ -385,20 +386,20 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty } // Add functions which may be required for supertrait implementations. walk_supertraits!(t, Some(&types), ( - ("Clone", _) => { + ("Clone", _, _) => { writeln!(w, "\t/// Called, if set, after this {} has been cloned into a duplicate object.", trait_name).unwrap(); writeln!(w, "\t/// The new {} is provided, and should be mutated as needed to perform a", trait_name).unwrap(); writeln!(w, "\t/// deep copy of the object pointed to by this_arg or avoid any double-freeing.").unwrap(); writeln!(w, "\tpub cloned: Option,", trait_name, trait_name).unwrap(); generated_fields.push(("cloned".to_owned(), None, None)); }, - ("std::cmp::Eq", _)|("core::cmp::Eq", _) => { + ("std::cmp::Eq", _, _)|("core::cmp::Eq", _, _) => { let eq_docs = "Checks if two objects are equal given this object's this_arg pointer and another object."; writeln!(w, "\t/// {}", eq_docs).unwrap(); writeln!(w, "\tpub eq: extern \"C\" fn (this_arg: *const c_void, other_arg: &{}) -> bool,", trait_name).unwrap(); generated_fields.push(("eq".to_owned(), None, Some(format!("\t/** {} */\n", eq_docs)))); }, - ("std::hash::Hash", _)|("core::hash::Hash", _) => { + ("std::hash::Hash", _, _)|("core::hash::Hash", _, _) => { let hash_docs_a = "Calculate a succinct non-cryptographic hash for an object given its this_arg pointer."; let hash_docs_b = "This is used, for example, for inclusion of this object in a hash map."; writeln!(w, "\t/// {}", hash_docs_a).unwrap(); @@ -407,15 +408,15 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty generated_fields.push(("hash".to_owned(), None, Some(format!("\t/**\n\t * {}\n\t * {}\n\t */\n", hash_docs_a, hash_docs_b)))); }, - ("Send", _) => {}, ("Sync", _) => {}, - ("std::fmt::Debug", _)|("core::fmt::Debug", _) => { + ("Send", _, _) => {}, ("Sync", _, _) => {}, + ("std::fmt::Debug", _, _)|("core::fmt::Debug", _, _) => { let debug_docs = "Return a human-readable \"debug\" string describing this object"; writeln!(w, "\t/// {}", debug_docs).unwrap(); writeln!(w, "\tpub debug_str: extern \"C\" fn (this_arg: *const c_void) -> crate::c_types::Str,").unwrap(); generated_fields.push(("debug_str".to_owned(), None, Some(format!("\t/**\n\t * {}\n\t */\n", debug_docs)))); }, - (s, i) => { + (s, i, _) => { // TODO: Both of the below should expose supertrait methods in C++, but doing so is // nontrivial. generated_fields.push(if types.crate_types.traits.get(s).is_none() { @@ -441,7 +442,9 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "}}").unwrap(); macro_rules! impl_trait_for_c { - ($t: expr, $impl_accessor: expr, $type_resolver: expr) => { + ($t: expr, $impl_accessor: expr, $type_resolver: expr, $generic_impls: expr) => { + let mut trait_gen_types = gen_types.push_ctx(); + assert!(trait_gen_types.learn_generics_with_impls(&$t.generics, $generic_impls, $type_resolver)); for item in $t.items.iter() { match item { syn::TraitItem::Method(m) => { @@ -450,7 +453,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty m.sig.abi.is_some() || m.sig.variadic.is_some() { panic!("1"); } - let mut meth_gen_types = gen_types.push_ctx(); + let mut meth_gen_types = trait_gen_types.push_ctx(); assert!(meth_gen_types.learn_generics(&m.sig.generics, $type_resolver)); // Note that we do *not* use the method generics when printing "native" // rust parts - if the method is generic, we need to print a generic @@ -565,17 +568,17 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty // Implement supertraits for the C-mapped struct. walk_supertraits!(t, Some(&types), ( - ("std::cmp::Eq", _)|("core::cmp::Eq", _) => { + ("std::cmp::Eq", _, _)|("core::cmp::Eq", _, _) => { writeln!(w, "impl core::cmp::Eq for {} {{}}", trait_name).unwrap(); writeln!(w, "impl core::cmp::PartialEq for {} {{", trait_name).unwrap(); writeln!(w, "\tfn eq(&self, o: &Self) -> bool {{ (self.eq)(self.this_arg, o) }}\n}}").unwrap(); }, - ("std::hash::Hash", _)|("core::hash::Hash", _) => { + ("std::hash::Hash", _, _)|("core::hash::Hash", _, _) => { writeln!(w, "impl core::hash::Hash for {} {{", trait_name).unwrap(); writeln!(w, "\tfn hash(&self, hasher: &mut H) {{ hasher.write_u64((self.hash)(self.this_arg)) }}\n}}").unwrap(); }, - ("Send", _) => {}, ("Sync", _) => {}, - ("Clone", _) => { + ("Send", _, _) => {}, ("Sync", _, _) => {}, + ("Clone", _, _) => { writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Creates a copy of a {}", trait_name).unwrap(); writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap(); @@ -587,14 +590,14 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "\t\t{}_clone(self)", trait_name).unwrap(); writeln!(w, "\t}}\n}}").unwrap(); }, - ("std::fmt::Debug", _)|("core::fmt::Debug", _) => { + ("std::fmt::Debug", _, _)|("core::fmt::Debug", _, _) => { writeln!(w, "impl core::fmt::Debug for {} {{", trait_name).unwrap(); writeln!(w, "\tfn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {{").unwrap(); writeln!(w, "\t\tf.write_str((self.debug_str)(self.this_arg).into_str())").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); }, - (s, i) => { + (s, i, generic_args) => { if let Some(supertrait) = types.crate_types.traits.get(s) { let resolver = get_module_type_resolver!(s, types.crate_libs, types.crate_types); @@ -604,10 +607,10 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty write!(w, "impl").unwrap(); maybe_write_lifetime_generics(w, &supertrait.generics, types); write!(w, " {}", s).unwrap(); - maybe_write_generics(w, &supertrait.generics, types, false); + maybe_write_generics(w, &supertrait.generics, generic_args, types, false); writeln!(w, " for {} {{", trait_name).unwrap(); - impl_trait_for_c!(supertrait, format!(".{}", i), &resolver); + impl_trait_for_c!(supertrait, format!(".{}", i), &resolver, generic_args); writeln!(w, "}}").unwrap(); } else { do_write_impl_trait(w, s, i, &trait_name); @@ -621,9 +624,9 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty write!(w, "impl").unwrap(); maybe_write_lifetime_generics(w, &t.generics, types); write!(w, " rust{}", t.ident).unwrap(); - maybe_write_generics(w, &t.generics, types, false); + maybe_write_generics(w, &t.generics, &syn::PathArguments::None, types, false); writeln!(w, " for {} {{", trait_name).unwrap(); - impl_trait_for_c!(t, "", types); + impl_trait_for_c!(t, "", types, &syn::PathArguments::None); writeln!(w, "}}\n").unwrap(); writeln!(w, "// We're essentially a pointer already, or at least a set of pointers, so allow us to be used").unwrap(); writeln!(w, "// directly as a Deref trait in higher-level structs:").unwrap(); @@ -652,7 +655,7 @@ fn writeln_opaque(w: &mut W, ident: &syn::Ident, struct_name: // https://github.com/eqrion/cbindgen/issues/286 Thus, instead, we import it as a temporary // name and then reference it by that name, which works around the issue. write!(w, "\nuse {}::{} as native{}Import;\npub(crate) type native{} = native{}Import", types.module_path, ident, ident, ident, ident).unwrap(); - maybe_write_generics(w, &generics, &types, true); + maybe_write_generics(w, &generics, &syn::PathArguments::None, &types, true); writeln!(w, ";\n").unwrap(); writeln!(extra_headers, "struct native{}Opaque;\ntypedef struct native{}Opaque LDKnative{};", ident, ident, ident).unwrap(); writeln_docs(w, &attrs, ""); @@ -933,7 +936,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ let supertrait_name; let supertrait_resolver; walk_supertraits!(trait_obj, Some(&types), ( - (s, _i) => { + (s, _i, _) => { if let Some(supertrait) = types.crate_types.traits.get(s) { supertrait_name = s.to_string(); supertrait_resolver = get_module_type_resolver!(supertrait_name, types.crate_libs, types.crate_types); @@ -1048,14 +1051,14 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ } let mut requires_clone = false; walk_supertraits!(trait_obj, Some(&types), ( - ("Clone", _) => { + ("Clone", _, _) => { requires_clone = true; writeln!(w, "\t\tcloned: Some({}_{}_cloned),", trait_obj.ident, ident).unwrap(); }, - ("Sync", _) => {}, ("Send", _) => {}, - ("std::marker::Sync", _) => {}, ("std::marker::Send", _) => {}, - ("core::fmt::Debug", _) => {}, - (s, t) => { + ("Sync", _, _) => {}, ("Send", _, _) => {}, + ("std::marker::Sync", _, _) => {}, ("std::marker::Send", _, _) => {}, + ("core::fmt::Debug", _, _) => {}, + (s, t, _) => { if let Some(supertrait_obj) = types.crate_types.traits.get(s) { writeln!(w, "\t\t{}: crate::{} {{", t, s).unwrap(); writeln!(w, "\t\t\tthis_arg: unsafe {{ ObjOps::untweak_ptr((*this_arg).inner) as *mut c_void }},").unwrap(); @@ -1199,7 +1202,7 @@ fn writeln_impl(w: &mut W, i: &syn::ItemImpl, types: &mut Typ writeln!(w, "\tnew_obj.this_arg = {}_clone_void(new_obj.this_arg);", ident).unwrap(); writeln!(w, "\tnew_obj.free = Some({}_free_void);", ident).unwrap(); walk_supertraits!(trait_obj, Some(&types), ( - (s, t) => { + (s, t, _) => { if types.crate_types.traits.get(s).is_some() { assert!(!types.is_clonable(s)); // We don't currently support cloning with a clonable supertrait writeln!(w, "\tnew_obj.{}.this_arg = new_obj.this_arg;", t).unwrap(); @@ -1729,7 +1732,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type } writeln!(w, "}}\nuse {}::{} as {}Import;", types.module_path, e.ident, e.ident).unwrap(); write!(w, "pub(crate) type native{} = {}Import", e.ident, e.ident).unwrap(); - maybe_write_generics(w, &e.generics, &types, true); + maybe_write_generics(w, &e.generics, &syn::PathArguments::None, &types, true); writeln!(w, ";\n\nimpl {} {{", e.ident).unwrap(); macro_rules! write_conv { @@ -1898,7 +1901,7 @@ fn writeln_fn<'a, 'b, W: std::io::Write>(w: &mut W, f: &'a syn::ItemFn, types: & write!(w, "{}::{}", types.module_path, f.sig.ident).unwrap(); let mut function_generic_args = Vec::new(); - maybe_write_generics(&mut function_generic_args, &f.sig.generics, types, true); + maybe_write_generics(&mut function_generic_args, &f.sig.generics, &syn::PathArguments::None, types, true); if !function_generic_args.is_empty() { write!(w, "::{}", String::from_utf8(function_generic_args).unwrap()).unwrap(); } @@ -2201,10 +2204,10 @@ fn walk_ast_first_pass<'a>(ast_storage: &'a FullLibraryAST, crate_types: &mut Cr } let trait_path = format!("{}::{}", module, t.ident); walk_supertraits!(t, None, ( - ("Clone", _) => { + ("Clone", _, _) => { crate_types.set_clonable("crate::".to_owned() + &trait_path); }, - (_, _) => {} + (_, _, _) => {} ) ); crate_types.traits.insert(trait_path, &t); } diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 6089d64..ecc508d 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -205,10 +205,10 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { } /// Learn the generics in generics in the current context, given a TypeResolver. - pub fn learn_generics<'b, 'c>(&mut self, generics: &'a syn::Generics, types: &'b TypeResolver<'a, 'c>) -> bool { + pub fn learn_generics_with_impls<'b, 'c>(&mut self, generics: &'a syn::Generics, impld_generics: &'a syn::PathArguments, types: &'b TypeResolver<'a, 'c>) -> bool { let mut new_typed_generics = HashMap::new(); // First learn simple generics... - for generic in generics.params.iter() { + for (idx, generic) in generics.params.iter().enumerate() { match generic { syn::GenericParam::Type(type_param) => { let mut non_lifetimes_processed = false; @@ -260,6 +260,15 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { if let Some(default) = type_param.default.as_ref() { assert!(type_param.bounds.is_empty()); self.default_generics.insert(&type_param.ident, (default.clone(), parse_quote!(&#default), parse_quote!(&mut #default))); + } else if type_param.bounds.is_empty() { + if let syn::PathArguments::AngleBracketed(args) = impld_generics { + match &args.args[idx] { + syn::GenericArgument::Type(ty) => { + self.default_generics.insert(&type_param.ident, (ty.clone(), parse_quote!(&#ty), parse_quote!(&mut #ty))); + } + _ => unimplemented!(), + } + } } }, _ => {}, @@ -270,6 +279,7 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { for pred in wh.predicates.iter() { if let syn::WherePredicate::Type(t) = pred { if let syn::Type::Path(p) = &t.bounded_ty { + if first_seg_self(&t.bounded_ty).is_some() && p.path.segments.len() == 1 { continue; } if p.qself.is_some() { return false; } if p.path.leading_colon.is_some() { return false; } let mut p_iter = p.path.segments.iter(); @@ -315,6 +325,11 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { true } + /// Learn the generics in generics in the current context, given a TypeResolver. + pub fn learn_generics<'b, 'c>(&mut self, generics: &'a syn::Generics, types: &'b TypeResolver<'a, 'c>) -> bool { + self.learn_generics_with_impls(generics, &syn::PathArguments::None, types) + } + /// Learn the associated types from the trait in the current context. pub fn learn_associated_types<'b, 'c>(&mut self, t: &'a syn::ItemTrait, types: &'b TypeResolver<'a, 'c>) { for item in t.items.iter() { -- 2.39.5