X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fblocks.rs;h=28f30026ed0810ef0263be3a8b4636a234d59b54;hb=5266836421190e74f893a3f9de5182057c2bd9b8;hp=88172722efbda088aef61443fba43e2af6515e07;hpb=09c8d62d937e86eee350898c7187dad498f0ec81;p=ldk-c-bindings diff --git a/c-bindings-gen/src/blocks.rs b/c-bindings-gen/src/blocks.rs index 8817272..28f3002 100644 --- a/c-bindings-gen/src/blocks.rs +++ b/c-bindings-gen/src/blocks.rs @@ -20,7 +20,7 @@ use crate::types::*; /// Writes out a C++ wrapper class for the given type, which contains various utilities to access /// the underlying C-mapped type safely avoiding some common memory management issues by handling /// resource-freeing and prevending accidental raw copies. -pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: bool) { +pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: bool, trait_methods: Option>) { writeln!(cpp_header_file, "class {} {{", ty).unwrap(); writeln!(cpp_header_file, "private:").unwrap(); writeln!(cpp_header_file, "\tLDK{} self;", ty).unwrap(); @@ -39,6 +39,14 @@ pub fn write_cpp_wrapper(cpp_header_file: &mut File, ty: &str, has_destructor: b writeln!(cpp_header_file, "\tLDK{}* operator ->() {{ return &self; }}", ty).unwrap(); writeln!(cpp_header_file, "\tconst LDK{}* operator &() const {{ return &self; }}", ty).unwrap(); writeln!(cpp_header_file, "\tconst LDK{}* operator ->() const {{ return &self; }}", ty).unwrap(); + if let Some(methods) = trait_methods { + for (meth_name, meth_docs) in methods { + cpp_header_file.write_all(meth_docs.as_bytes()).unwrap(); + // Note that we have zero logic to print C/C__ code for a given function. Instead, we + // simply use sed to replace the following in genbindings.sh + writeln!(cpp_header_file, "XXX {} {}", ty, meth_name).unwrap(); + } + } writeln!(cpp_header_file, "}};").unwrap(); } @@ -53,7 +61,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\tpub result: *mut {},", ok_type).unwrap(); } else { writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the OK variant").unwrap(); - writeln!(w, "\tpub result: *mut std::ffi::c_void,").unwrap(); + writeln!(w, "\tpub result: *mut core::ffi::c_void,").unwrap(); } if err_type != "()" { writeln!(w, "\t/// A pointer to the contents in the error state.").unwrap(); @@ -61,7 +69,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\tpub err: *mut {},", err_type).unwrap(); } else { writeln!(w, "\t/// Note that this value is always NULL, as there are no contents in the Err variant").unwrap(); - writeln!(w, "\tpub err: *mut std::ffi::c_void,").unwrap(); + writeln!(w, "\tpub err: *mut core::ffi::c_void,").unwrap(); } writeln!(w, "}}").unwrap(); writeln!(w, "#[repr(C)]").unwrap(); @@ -89,7 +97,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if ok_type != "()" { writeln!(w, "\t\t\tresult: Box::into_raw(Box::new(o)),").unwrap(); } else { - writeln!(w, "\t\t\tresult: std::ptr::null_mut(),").unwrap(); + writeln!(w, "\t\t\tresult: core::ptr::null_mut(),").unwrap(); } writeln!(w, "\t\t}},").unwrap(); writeln!(w, "\t\tresult_ok: true,").unwrap(); @@ -109,13 +117,19 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if err_type != "()" { writeln!(w, "\t\t\terr: Box::into_raw(Box::new(e)),").unwrap(); } else { - writeln!(w, "\t\t\terr: std::ptr::null_mut(),").unwrap(); + writeln!(w, "\t\t\terr: core::ptr::null_mut(),").unwrap(); } writeln!(w, "\t\t}},").unwrap(); writeln!(w, "\t\tresult_ok: false,").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); + writeln!(w, "/// Checks if the given object is currently in the success state").unwrap(); + writeln!(w, "#[no_mangle]").unwrap(); + writeln!(w, "pub extern \"C\" fn {}_is_ok(o: &{}) -> bool {{", mangled_container, mangled_container).unwrap(); + writeln!(w, "\to.result_ok").unwrap(); + writeln!(w, "}}").unwrap(); + writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Frees any resources used by the {}.", mangled_container).unwrap(); writeln!(w, "pub extern \"C\" fn {}_free(_res: {}) {{ }}", mangled_container, mangled_container).unwrap(); @@ -137,31 +151,27 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); - // TODO: Templates should use () now that they can, too - let templ_ok_type = if ok_type != "()" { ok_type } else { "u8" }; - let templ_err_type = if err_type != "()" { err_type } else { "u8" }; - - writeln!(w, "impl From> for {} {{", templ_ok_type, templ_err_type, mangled_container).unwrap(); - writeln!(w, "\tfn from(mut o: crate::c_types::CResultTempl<{}, {}>) -> Self {{", templ_ok_type, templ_err_type).unwrap(); + writeln!(w, "impl From> for {} {{", ok_type, err_type, mangled_container).unwrap(); + writeln!(w, "\tfn from(mut o: crate::c_types::CResultTempl<{}, {}>) -> Self {{", ok_type, err_type).unwrap(); writeln!(w, "\t\tlet contents = if o.result_ok {{").unwrap(); if ok_type != "()" { writeln!(w, "\t\t\tlet result = unsafe {{ o.contents.result }};").unwrap(); - writeln!(w, "\t\t\tunsafe {{ o.contents.result = std::ptr::null_mut() }};").unwrap(); + writeln!(w, "\t\t\tunsafe {{ o.contents.result = core::ptr::null_mut() }};").unwrap(); writeln!(w, "\t\t\t{}Ptr {{ result }}", mangled_container).unwrap(); } else { writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.result) }};").unwrap(); - writeln!(w, "\t\t\to.contents.result = std::ptr::null_mut();").unwrap(); - writeln!(w, "\t\t\t{}Ptr {{ result: std::ptr::null_mut() }}", mangled_container).unwrap(); + writeln!(w, "\t\t\to.contents.result = core::ptr::null_mut();").unwrap(); + writeln!(w, "\t\t\t{}Ptr {{ result: core::ptr::null_mut() }}", mangled_container).unwrap(); } writeln!(w, "\t\t}} else {{").unwrap(); if err_type != "()" { writeln!(w, "\t\t\tlet err = unsafe {{ o.contents.err }};").unwrap(); - writeln!(w, "\t\t\tunsafe {{ o.contents.err = std::ptr::null_mut(); }}").unwrap(); + writeln!(w, "\t\t\tunsafe {{ o.contents.err = core::ptr::null_mut(); }}").unwrap(); writeln!(w, "\t\t\t{}Ptr {{ err }}", mangled_container).unwrap(); } else { writeln!(w, "\t\t\tlet _ = unsafe {{ Box::from_raw(o.contents.err) }};").unwrap(); - writeln!(w, "\t\t\to.contents.err = std::ptr::null_mut();").unwrap(); - writeln!(w, "\t\t\t{}Ptr {{ err: std::ptr::null_mut() }}", mangled_container).unwrap(); + writeln!(w, "\t\t\to.contents.err = core::ptr::null_mut();").unwrap(); + writeln!(w, "\t\t\t{}Ptr {{ err: core::ptr::null_mut() }}", mangled_container).unwrap(); } writeln!(w, "\t\t}};").unwrap(); writeln!(w, "\t\tSelf {{").unwrap(); @@ -179,7 +189,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if ok_type != "()" { writeln!(w, "\t\t\t\tresult: Box::into_raw(Box::new(<{}>::clone(unsafe {{ &*self.contents.result }})))", ok_type).unwrap(); } else { - writeln!(w, "\t\t\t\tresult: std::ptr::null_mut()").unwrap(); + writeln!(w, "\t\t\t\tresult: core::ptr::null_mut()").unwrap(); } writeln!(w, "\t\t\t}} }}").unwrap(); writeln!(w, "\t\t}} else {{").unwrap(); @@ -187,7 +197,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, if err_type != "()" { writeln!(w, "\t\t\t\terr: Box::into_raw(Box::new(<{}>::clone(unsafe {{ &*self.contents.err }})))", err_type).unwrap(); } else { - writeln!(w, "\t\t\t\terr: std::ptr::null_mut()").unwrap(); + writeln!(w, "\t\t\t\terr: core::ptr::null_mut()").unwrap(); } writeln!(w, "\t\t\t}} }}").unwrap(); writeln!(w, "\t\t}}").unwrap(); @@ -196,7 +206,7 @@ pub fn write_result_block(w: &mut W, mangled_container: &str, writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Creates a new {} which has the same data as `orig`", mangled_container).unwrap(); writeln!(w, "/// but with all dynamically-allocated buffers duplicated in new buffers.").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ orig.clone() }}", mangled_container, mangled_container, mangled_container).unwrap(); + writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ Clone::clone(&orig) }}", mangled_container, mangled_container, mangled_container).unwrap(); } } @@ -216,13 +226,13 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in writeln!(w, "impl {} {{", mangled_container).unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn into_rust(&mut self) -> Vec<{}> {{", inner_type).unwrap(); writeln!(w, "\t\tif self.datalen == 0 {{ return Vec::new(); }}").unwrap(); - writeln!(w, "\t\tlet ret = unsafe {{ Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }}.into();").unwrap(); - writeln!(w, "\t\tself.data = std::ptr::null_mut();").unwrap(); + writeln!(w, "\t\tlet ret = unsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }}.into();").unwrap(); + writeln!(w, "\t\tself.data = core::ptr::null_mut();").unwrap(); writeln!(w, "\t\tself.datalen = 0;").unwrap(); writeln!(w, "\t\tret").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn as_slice(&self) -> &[{}] {{", inner_type).unwrap(); - writeln!(w, "\t\tunsafe {{ std::slice::from_raw_parts_mut(self.data, self.datalen) }}").unwrap(); + writeln!(w, "\t\tunsafe {{ core::slice::from_raw_parts_mut(self.data, self.datalen) }}").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); @@ -240,7 +250,7 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in writeln!(w, "impl Drop for {} {{", mangled_container).unwrap(); writeln!(w, "\tfn drop(&mut self) {{").unwrap(); writeln!(w, "\t\tif self.datalen == 0 {{ return; }}").unwrap(); - writeln!(w, "\t\tunsafe {{ Box::from_raw(std::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap(); + writeln!(w, "\t\tlet _ = unsafe {{ Box::from_raw(core::slice::from_raw_parts_mut(self.data, self.datalen)) }};").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); if clonable { @@ -248,7 +258,7 @@ pub fn write_vec_block(w: &mut W, mangled_container: &str, in writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); writeln!(w, "\t\tlet mut res = Vec::new();").unwrap(); writeln!(w, "\t\tif self.datalen == 0 {{ return Self::from(res); }}").unwrap(); - writeln!(w, "\t\tres.extend_from_slice(unsafe {{ std::slice::from_raw_parts_mut(self.data, self.datalen) }});").unwrap(); + writeln!(w, "\t\tres.extend_from_slice(unsafe {{ core::slice::from_raw_parts_mut(self.data, self.datalen) }});").unwrap(); writeln!(w, "\t\tSelf::from(res)").unwrap(); writeln!(w, "\t}}").unwrap(); writeln!(w, "}}").unwrap(); @@ -297,7 +307,7 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, writeln!(w, "\tfn clone(&self) -> Self {{").unwrap(); writeln!(w, "\t\tSelf {{").unwrap(); for idx in 0..types.len() { - writeln!(w, "\t\t\t{}: self.{}.clone(),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap(); + writeln!(w, "\t\t\t{}: Clone::clone(&self.{}),", ('a' as u8 + idx as u8) as char, ('a' as u8 + idx as u8) as char).unwrap(); } writeln!(w, "\t\t}}").unwrap(); writeln!(w, "\t}}").unwrap(); @@ -305,7 +315,7 @@ pub fn write_tuple_block(w: &mut W, mangled_container: &str, writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Creates a new tuple which has the same data as `orig`").unwrap(); writeln!(w, "/// but with all dynamically-allocated buffers duplicated in new buffers.").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ orig.clone() }}", mangled_container, mangled_container, mangled_container).unwrap(); + writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ Clone::clone(&orig) }}", mangled_container, mangled_container, mangled_container).unwrap(); } writeln!(w, "/// Creates a new {} from the contained elements.", mangled_container).unwrap(); @@ -336,24 +346,38 @@ pub fn write_option_block(w: &mut W, mangled_container: &str, writeln!(w, "/// An enum which can either contain a {} or not", inner_type).unwrap(); writeln!(w, "pub enum {} {{", mangled_container).unwrap(); writeln!(w, "\t/// When we're in this state, this {} contains a {}", mangled_container, inner_type).unwrap(); - writeln!(w, "\tSome({}),", inner_type).unwrap(); + if inner_type != "" { + writeln!(w, "\tSome({}),", inner_type).unwrap(); + } else { + writeln!(w, "\tSome,").unwrap(); + } writeln!(w, "\t/// When we're in this state, this {} contains nothing", mangled_container).unwrap(); writeln!(w, "\tNone").unwrap(); writeln!(w, "}}").unwrap(); writeln!(w, "impl {} {{", mangled_container).unwrap(); writeln!(w, "\t#[allow(unused)] pub(crate) fn is_some(&self) -> bool {{").unwrap(); - writeln!(w, "\t\tif let Self::Some(_) = self {{ true }} else {{ false }}").unwrap(); + writeln!(w, "\t\tif let Self::None = self {{ false }} else {{ true }}").unwrap(); writeln!(w, "\t}}").unwrap(); - writeln!(w, "\t#[allow(unused)] pub(crate) fn take(mut self) -> {} {{", inner_type).unwrap(); - writeln!(w, "\t\tif let Self::Some(v) = self {{ v }} else {{ unreachable!() }}").unwrap(); + writeln!(w, "\t#[allow(unused)] pub(crate) fn is_none(&self) -> bool {{").unwrap(); + writeln!(w, "\t\t!self.is_some()").unwrap(); writeln!(w, "\t}}").unwrap(); + if inner_type != "" { + writeln!(w, "\t#[allow(unused)] pub(crate) fn take(mut self) -> {} {{", inner_type).unwrap(); + writeln!(w, "\t\tif let Self::Some(v) = self {{ v }} else {{ unreachable!() }}").unwrap(); + writeln!(w, "\t}}").unwrap(); + } writeln!(w, "}}").unwrap(); writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Constructs a new {} containing a {}", mangled_container, inner_type).unwrap(); - writeln!(w, "pub extern \"C\" fn {}_some(o: {}) -> {} {{", mangled_container, inner_type, mangled_container).unwrap(); - writeln!(w, "\t{}::Some(o)", mangled_container).unwrap(); + if inner_type != "" { + writeln!(w, "pub extern \"C\" fn {}_some(o: {}) -> {} {{", mangled_container, inner_type, mangled_container).unwrap(); + writeln!(w, "\t{}::Some(o)", mangled_container).unwrap(); + } else { + writeln!(w, "pub extern \"C\" fn {}_some() -> {} {{", mangled_container, mangled_container).unwrap(); + writeln!(w, "\t{}::Some", mangled_container).unwrap(); + } writeln!(w, "}}").unwrap(); writeln!(w, "#[no_mangle]").unwrap(); @@ -369,12 +393,38 @@ pub fn write_option_block(w: &mut W, mangled_container: &str, writeln!(w, "#[no_mangle]").unwrap(); writeln!(w, "/// Creates a new {} which has the same data as `orig`", mangled_container).unwrap(); writeln!(w, "/// but with all dynamically-allocated buffers duplicated in new buffers.").unwrap(); - writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ orig.clone() }}", mangled_container, mangled_container, mangled_container).unwrap(); + writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{ Clone::clone(&orig) }}", mangled_container, mangled_container, mangled_container).unwrap(); } } +/// Prints the docs from a given attribute list unless its tagged no export +pub fn writeln_fn_docs<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, args: I, ret: &syn::ReturnType) where I: Iterator { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, + args.filter_map(|arg| if let syn::FnArg::Typed(ty) = arg { + if let syn::Pat::Ident(id) = &*ty.pat { + Some((id.ident.to_string(), &*ty.ty)) + } else { unimplemented!() } + } else { None }), + if let syn::ReturnType::Type(_, ty) = ret { Some(&**ty) } else { None }, + None + ))); +} + /// Prints the docs from a given attribute list unless its tagged no export pub fn writeln_docs(w: &mut W, attrs: &[syn::Attribute], prefix: &str) { + writeln_docs_impl(w, attrs, prefix, None::<(_, _, std::vec::Drain<'_, (String, &syn::Type)>, _, _)>); +} + +pub fn writeln_arg_docs<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, args: I, ret: Option<&syn::Type>) where I: Iterator { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, args, ret, None))) +} + +pub fn writeln_field_docs(w: &mut W, attrs: &[syn::Attribute], prefix: &str, types: &mut TypeResolver, generics: Option<&GenericTypes>, field: &syn::Type) { + writeln_docs_impl(w, attrs, prefix, Some((types, generics, vec![].drain(..), None, Some(field)))) +} + +/// Prints the docs from a given attribute list unless its tagged no export +fn writeln_docs_impl<'a, W: std::io::Write, I>(w: &mut W, attrs: &[syn::Attribute], prefix: &str, method_args_ret: Option<(&mut TypeResolver, Option<&GenericTypes>, I, Option<&syn::Type>, Option<&syn::Type>)>) where I: Iterator { for attr in attrs.iter() { let tokens_clone = attr.tokens.clone(); let mut token_iter = tokens_clone.into_iter(); @@ -410,6 +460,56 @@ pub fn writeln_docs(w: &mut W, attrs: &[syn::Attribute], pref }, } } + if let Some((types, generics, inp, outp, field_ty)) = method_args_ret { + let mut nullable_found = false; + for (name, inp) in inp { + if types.skip_arg(inp, generics) { continue; } + if if let syn::Type::Reference(syn::TypeReference { elem, .. }) = inp { + if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + types.is_path_transparent_container(path, generics, true) + } else { false } + } else if let syn::Type::Path(syn::TypePath { ref path, .. }) = inp { + types.is_path_transparent_container(path, generics, true) + } else { false } { + // Note downstream clients match this text exactly so any changes may require + // changes in the Java and Swift bindings, at least. + if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); } + nullable_found = true; + writeln!(w, "{}/// Note that {} (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix, name).unwrap(); + } + } + if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = outp { + if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + types.is_path_transparent_container(path, generics, true) + } else { false } + } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = outp { + types.is_path_transparent_container(path, generics, true) + } else { false } { + // Note downstream clients match this text exactly so any changes may require + // changes in the Java and Swift bindings, at least. + if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); } + nullable_found = true; + writeln!(w, "{}/// Note that the return value (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap(); + } + let field = field_ty.map(|ty| generics.resolve_type(ty)); + if if let Some(syn::Type::Reference(syn::TypeReference { elem, .. })) = field { + if let syn::Type::Path(syn::TypePath { ref path, .. }) = &**elem { + let resolved_path = types.resolve_path(path, generics); + if types.crate_types.opaques.get(&resolved_path).is_some() { + writeln!(w, "{}/// Note that this field is expected to be a reference.", prefix).unwrap(); + } + types.is_path_transparent_container(path, generics, true) + } else { false } + } else if let Some(syn::Type::Path(syn::TypePath { ref path, .. })) = field { + types.is_path_transparent_container(path, generics, true) + } else { false } { + // Note downstream clients match this text exactly so any changes may require + // changes in the Java and Swift bindings, at least. + if !nullable_found { writeln!(w, "{}///", prefix).unwrap(); } + writeln!(w, "{}/// Note that this (or a relevant inner pointer) may be NULL or all-0s to represent None", prefix).unwrap(); + } + } + } /// Print the parameters in a method declaration, starting after the open parenthesis, through and @@ -476,7 +576,7 @@ pub fn write_method_params(w: &mut W, sig: &syn::Signature, t }, _ => unimplemented!(), } - w.write(&c_type).unwrap(); + w.write_all(&c_type).unwrap(); } } } @@ -622,7 +722,7 @@ pub fn write_method_call_params(w: &mut W, sig: &syn::Signatu write!(w, "ret").unwrap(); } else if !to_c && self_segs_iter.is_some() && self_segs_iter.unwrap().next().is_none() { // If we're returning "Self" (and not "Self::X"), just do it manually - write!(w, "{} {{ inner: Box::into_raw(Box::new(ret)), is_owned: true }}", this_type).unwrap(); + write!(w, "{} {{ inner: ObjOps::heap_alloc(ret), is_owned: true }}", this_type).unwrap(); } else if to_c { let new_var = types.write_from_c_conversion_new_var(w, &format_ident!("ret"), rtype, generics); if new_var { @@ -647,32 +747,70 @@ 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() { - write!(w, "<").unwrap(); - for (idx, generic) in generics.params.iter().enumerate() { - match generic { - syn::GenericParam::Type(type_param) => { - let mut printed_param = false; - for bound in type_param.bounds.iter() { - if let syn::TypeParamBound::Trait(trait_bound) = bound { - assert_simple_bound(&trait_bound); - write!(w, "{}{}", if idx != 0 { ", " } else { "" }, gen_types.maybe_resolve_ident(&type_param.ident).unwrap()).unwrap(); - if printed_param { - unimplemented!("Can't print generic params that have multiple non-lifetime bounds"); + if generics.params.is_empty() { return; } + for generic in generics.params.iter() { + match generic { + syn::GenericParam::Type(type_param) => { + for bound in type_param.bounds.iter() { + match bound { + syn::TypeParamBound::Trait(t) => { + if let Some(trait_bound) = types.maybe_resolve_path(&t.path, None) { + if types.skip_path(&trait_bound) { + // Just hope rust deduces generic params if some bounds are skipable. + return; + } } - printed_param = true; } + _ => {}, } - }, - syn::GenericParam::Lifetime(lt) => { - if concrete_lifetimes { - write!(w, "'static").unwrap(); - } else { - write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); + } + } + _ => {}, + } + } + + write!(w, "<").unwrap(); + for (idx, generic) in generics.params.iter().enumerate() { + match generic { + syn::GenericParam::Type(type_param) => { + write!(w, "{}", if idx != 0 { ", " } else { "" }).unwrap(); + let type_ident = &type_param.ident; + 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 { + write!(w, "'static").unwrap(); + } else { + write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); + } + }, + _ => unimplemented!(), + } + } + write!(w, ">").unwrap(); +} + +pub fn maybe_write_lifetime_generics(w: &mut W, generics: &syn::Generics, types: &TypeResolver) { + let mut gen_types = GenericTypes::new(None); + assert!(gen_types.learn_generics(generics, types)); + if generics.params.iter().any(|param| if let syn::GenericParam::Lifetime(_) = param { true } else { false }) { + write!(w, "<").unwrap(); + for (idx, generic) in generics.params.iter().enumerate() { + match generic { + syn::GenericParam::Type(_) => {}, + syn::GenericParam::Lifetime(lt) => { + write!(w, "{}'{}", if idx != 0 { ", " } else { "" }, lt.lifetime.ident).unwrap(); }, _ => unimplemented!(), } @@ -680,5 +818,3 @@ pub fn maybe_write_generics(w: &mut W, generics: &syn::Generi write!(w, ">").unwrap(); } } - -