X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=508d39293738941d90887432378e89a402065dad;hb=6cc86203e1c1108db5cee5bf0173e7cd50e8984d;hp=7e77810c361398f4f27a2cb0936ce66e2a4c8a77;hpb=0dcc7fcda393868ee8760fc48ac37f46b2cdf5eb;p=ldk-c-bindings

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index 7e77810..508d392 100644
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -22,6 +22,7 @@ use std::collections::{HashMap, hash_map};
 use std::env;
 use std::fs::File;
 use std::io::{Read, Write};
+use std::iter::FromIterator;
 use std::process;
 
 use proc_macro2::Span;
@@ -596,7 +597,16 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
 		(s, i) => {
 			if let Some(supertrait) = types.crate_types.traits.get(s) {
 				let resolver = get_module_type_resolver!(s, types.crate_libs, types.crate_types);
-				writeln!(w, "impl {} for {} {{", s, trait_name).unwrap();
+
+				// Blindly assume that the same imports where `supertrait` is defined are also
+				// imported here. This will almost certainly break at some point, but it should be
+				// a compilation failure when it does so.
+				write!(w, "impl").unwrap();
+				maybe_write_lifetime_generics(w, &supertrait.generics, types);
+				write!(w, " {}", s).unwrap();
+				maybe_write_generics(w, &supertrait.generics, types, false);
+				writeln!(w, " for {} {{", trait_name).unwrap();
+
 				impl_trait_for_c!(supertrait, format!(".{}", i), &resolver);
 				writeln!(w, "}}").unwrap();
 			} else {
@@ -1382,6 +1392,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 
 					'alias_impls: for (alias_resolved, arguments) in aliases {
 						let mut new_ty_generics = Vec::new();
+						let mut new_ty_bounds = Vec::new();
 						let mut need_generics = false;
 
 						let alias_resolver_override;
@@ -1390,6 +1401,10 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 								alias_module, &types.crate_types.lib_ast.modules.get(alias_module).unwrap().items);
 							&alias_resolver_override
 						} else { &types.types };/*.maybe_resolve_path(&alias, None).unwrap();*/
+						let mut where_clause = Some(syn::WhereClause {
+							where_token: syn::Token![where](Span::call_site()),
+							predicates: syn::punctuated::Punctuated::new()
+						});
 						for (idx, gen) in i.generics.params.iter().enumerate() {
 							match gen {
 								syn::GenericParam::Type(type_param) => {
@@ -1398,11 +1413,11 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 											if let syn::PathArguments::AngleBracketed(ref t) = &arguments {
 												assert!(idx < t.args.len());
 												if let syn::GenericArgument::Type(syn::Type::Path(p)) = &t.args[idx] {
-													if let Some(generic_arg) = alias_resolver.maybe_resolve_path(&p.path, None) {
+													let generic_bound = types.maybe_resolve_path(&trait_bound.path, None)
+														.unwrap_or_else(|| format!("{}::{}", types.module_path, single_ident_generic_path_to_ident(&trait_bound.path).unwrap()));
 
+													if let Some(generic_arg) = alias_resolver.maybe_resolve_path(&p.path, None) {
 														new_ty_generics.push((type_param.ident.clone(), syn::Type::Path(p.clone())));
-														let generic_bound = types.maybe_resolve_path(&trait_bound.path, None)
-															.unwrap_or_else(|| format!("{}::{}", types.module_path, single_ident_generic_path_to_ident(&trait_bound.path).unwrap()));
 														if let Some(traits_impld) = types.crate_types.trait_impls.get(&generic_arg) {
 															for trait_impld in traits_impld {
 																if *trait_impld == generic_bound { continue 'bounds_check; }
@@ -1414,8 +1429,29 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 															continue 'alias_impls;
 														}
 													} else if gen_types.is_some() {
-														new_ty_generics.push((type_param.ident.clone(),
-															gen_types.as_ref().resolve_type(&syn::Type::Path(p.clone())).clone()));
+														let resp =  types.maybe_resolve_path(&p.path, gen_types.as_ref());
+														if generic_bound == "core::ops::Deref" && resp.is_some() {
+															new_ty_bounds.push((type_param.ident.clone(),
+																string_path_to_syn_path("core::ops::Deref")));
+															let mut bounds = syn::punctuated::Punctuated::new();
+															bounds.push(syn::TypeParamBound::Trait(syn::TraitBound {
+																paren_token: None,
+																modifier: syn::TraitBoundModifier::None,
+																lifetimes: None,
+																path: string_path_to_syn_path(&types.resolve_path(&p.path, gen_types.as_ref())),
+															}));
+															let mut path = string_path_to_syn_path(&format!("{}::Target", type_param.ident));
+															path.leading_colon = None;
+															where_clause.as_mut().unwrap().predicates.push(syn::WherePredicate::Type(syn::PredicateType {
+																lifetimes: None,
+																bounded_ty: syn::Type::Path(syn::TypePath { qself: None, path }),
+																colon_token: syn::Token![:](Span::call_site()),
+																bounds,
+															}));
+														} else {
+															new_ty_generics.push((type_param.ident.clone(),
+																gen_types.as_ref().resolve_type(&syn::Type::Path(p.clone())).clone()));
+														}
 														need_generics = true;
 													} else {
 														unimplemented!();
@@ -1436,7 +1472,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 								let alias_generics = types.crate_types.opaques.get(&alias_resolved).unwrap().1;
 
 								// If we need generics on the alias, create impl generic bounds...
-								assert_eq!(new_ty_generics.len(), i.generics.params.len());
+								assert_eq!(new_ty_generics.len() + new_ty_bounds.len(), i.generics.params.len());
 								let mut args = syn::punctuated::Punctuated::new();
 								for (ident, param) in new_ty_generics.drain(..) {
 									// TODO: We blindly assume that generics in the type alias and
@@ -1455,6 +1491,28 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 										default: Some(param),
 									}));
 								}
+								for (ident, param) in new_ty_bounds.drain(..) {
+									// TODO: We blindly assume that generics in the type alias and
+									// the aliased type have the same names, which we really shouldn't.
+									if alias_generics.params.iter().any(|generic|
+										if let syn::GenericParam::Type(t) = generic { t.ident == ident } else { false })
+									{
+										args.push(parse_quote!(#ident));
+									}
+									params.push(syn::GenericParam::Type(syn::TypeParam {
+										attrs: Vec::new(),
+										ident,
+										colon_token: Some(syn::token::Colon(Span::call_site())),
+										bounds: syn::punctuated::Punctuated::from_iter(
+											Some(syn::TypeParamBound::Trait(syn::TraitBound {
+												path: param, paren_token: None, lifetimes: None,
+												modifier: syn::TraitBoundModifier::None,
+											}))
+										),
+										eq_token: None,
+										default: None,
+									}));
+								}
 								// ... and swap the last segment of the impl self_ty to use the generic bounds.
 								let mut res = alias.clone();
 								res.segments.last_mut().unwrap().arguments = syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
@@ -1473,7 +1531,7 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
 								lt_token: None,
 								params,
 								gt_token: None,
-								where_clause: None,
+								where_clause,
 							},
 							impl_token: syn::Token![impl](Span::call_site()),
 							items: i.items.clone(),
@@ -1552,15 +1610,15 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 				writeln_field_docs(w, &field.attrs, "\t\t", types, Some(&gen_types), &field.ty);
 				write!(w, "\t\t{}: ", field.ident.as_ref().unwrap()).unwrap();
 				write!(&mut constr, "{}{}: ", if idx != 0 { ", " } else { "" }, field.ident.as_ref().unwrap()).unwrap();
-				types.write_c_type(w, &field.ty, Some(&gen_types), false);
-				types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false);
+				types.write_c_type(w, &field.ty, Some(&gen_types), true);
+				types.write_c_type(&mut constr, &field.ty, Some(&gen_types), true);
 				writeln!(w, ",").unwrap();
 			}
 			write!(w, "\t}}").unwrap();
 		} else if let syn::Fields::Unnamed(fields) = &var.fields {
 			if fields.unnamed.len() == 1 {
 				let mut empty_check = Vec::new();
-				types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false);
+				types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), true);
 				if empty_check.is_empty() {
 					empty_tuple_variant = true;
 				}
@@ -1571,7 +1629,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 				for (idx, field) in fields.unnamed.iter().enumerate() {
 					if export_status(&field.attrs) == ExportStatus::TestOnly { continue; }
 					write!(&mut constr, "{}: ", ('a' as u8 + idx as u8) as char).unwrap();
-					types.write_c_type(w, &field.ty, Some(&gen_types), false);
+					types.write_c_type(w, &field.ty, Some(&gen_types), true);
 					types.write_c_type(&mut constr, &field.ty, Some(&gen_types), false);
 					if idx != fields.unnamed.len() - 1 {
 						write!(w, ",").unwrap();
@@ -1592,8 +1650,19 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 		} else if let syn::Fields::Unnamed(fields) = &var.fields {
 			if !empty_tuple_variant {
 				write!(&mut constr, "(").unwrap();
-				for idx in 0..fields.unnamed.len() {
-					write!(&mut constr, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
+				for (idx, field) in fields.unnamed.iter().enumerate() {
+					let mut ref_c_ty = Vec::new();
+					let mut nonref_c_ty = Vec::new();
+					types.write_c_type(&mut ref_c_ty, &field.ty, Some(&gen_types), false);
+					types.write_c_type(&mut nonref_c_ty, &field.ty, Some(&gen_types), true);
+
+					if ref_c_ty != nonref_c_ty {
+						// We blindly assume references in field types are always opaque types, and
+						// print out an opaque reference -> owned reference conversion here.
+						write!(&mut constr, "{} {{ inner: {}.inner, is_owned: false }}, ", String::from_utf8(nonref_c_ty).unwrap(), ('a' as u8 + idx as u8) as char).unwrap();
+					} else {
+						write!(&mut constr, "{}, ", ('a' as u8 + idx as u8) as char).unwrap();
+					}
 				}
 				writeln!(&mut constr, ")").unwrap();
 			} else {
@@ -1603,7 +1672,10 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 		writeln!(&mut constr, "}}").unwrap();
 		writeln!(w, ",").unwrap();
 	}
-	writeln!(w, "}}\nuse {}::{} as native{};\nimpl {} {{", types.module_path, e.ident, e.ident, e.ident).unwrap();
+	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);
+	writeln!(w, ";\n\nimpl {} {{", e.ident).unwrap();
 
 	macro_rules! write_conv {
 		($fn_sig: expr, $to_c: expr, $ref: expr) => {
@@ -1621,7 +1693,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 				} else if let syn::Fields::Unnamed(fields) = &var.fields {
 					if fields.unnamed.len() == 1 {
 						let mut empty_check = Vec::new();
-						types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), false);
+						types.write_c_type(&mut empty_check, &fields.unnamed[0].ty, Some(&gen_types), true);
 						if empty_check.is_empty() {
 							empty_tuple_variant = true;
 						}
@@ -1643,7 +1715,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 						let mut sink = ::std::io::sink();
 						let mut out: &mut dyn std::io::Write = if $ref { &mut sink } else { w };
 						let new_var = if $to_c {
-							types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types), false)
+							types.write_to_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types), true)
 						} else {
 							types.write_from_c_conversion_new_var(&mut out, $field_ident, &$field.ty, Some(&gen_types))
 						};
@@ -1653,7 +1725,7 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 								if new_var {
 									let nonref_ident = format_ident!("{}_nonref", $field_ident);
 									if $to_c {
-										types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types), false);
+										types.write_to_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types), true);
 									} else {
 										types.write_from_c_conversion_new_var(w, &nonref_ident, &$field.ty, Some(&gen_types));
 									}
@@ -1685,14 +1757,14 @@ fn writeln_enum<'a, 'b, W: std::io::Write>(w: &mut W, e: &'a syn::ItemEnum, type
 					($field: expr, $field_ident: expr) => { {
 						if export_status(&$field.attrs) == ExportStatus::TestOnly { continue; }
 						if $to_c {
-							types.write_to_c_conversion_inline_prefix(w, &$field.ty, Some(&gen_types), false);
+							types.write_to_c_conversion_inline_prefix(w, &$field.ty, Some(&gen_types), true);
 						} else {
 							types.write_from_c_conversion_prefix(w, &$field.ty, Some(&gen_types));
 						}
 						write!(w, "{}{}", $field_ident,
 							if $ref { "_nonref" } else { "" }).unwrap();
 						if $to_c {
-							types.write_to_c_conversion_inline_suffix(w, &$field.ty, Some(&gen_types), false);
+							types.write_to_c_conversion_inline_suffix(w, &$field.ty, Some(&gen_types), true);
 						} else {
 							types.write_from_c_conversion_suffix(w, &$field.ty, Some(&gen_types));
 						}