X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Fmain.rs;h=956420be780a938e817d856392f928b443695257;hb=737b617b2db60132ef7c89713124460c60a3fcca;hp=a7f7a1e3896b16941064d3d273c0a54b2aa25540;hpb=177b19785026663c6c9c197750eb1108a0759328;p=ldk-c-bindings diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs index a7f7a1e..956420b 100644 --- a/c-bindings-gen/src/main.rs +++ b/c-bindings-gen/src/main.rs @@ -36,6 +36,7 @@ use blocks::*; const DEFAULT_IMPORTS: &'static str = " use alloc::str::FromStr; +use alloc::string::String; use core::ffi::c_void; use core::convert::Infallible; use bitcoin::hashes::Hash; @@ -73,7 +74,7 @@ fn maybe_convert_trait_impl(w: &mut W, trait_path: &syn::Path let mut for_obj_vec = Vec::new(); types.write_c_type(&mut for_obj_vec, for_ty, Some(generics), false); full_obj_path = String::from_utf8(for_obj_vec).unwrap(); - assert!(full_obj_path.starts_with(TypeResolver::generated_container_path())); + if !full_obj_path.starts_with(TypeResolver::generated_container_path()) { return; } for_obj = full_obj_path[TypeResolver::generated_container_path().len() + 2..].into(); } @@ -532,7 +533,11 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty syn::TypeParamBound::Trait(tr) => { writeln!(w, "\ttype {} = crate::{};", t.ident, $type_resolver.resolve_path(&tr.path, Some(&gen_types))).unwrap(); for bound in bounds_iter { - if let syn::TypeParamBound::Trait(_) = bound { panic!("11"); } + if let syn::TypeParamBound::Trait(t) = bound { + // We only allow for `Sized` here. + assert_eq!(t.path.segments.len(), 1); + assert_eq!(format!("{}", t.path.segments[0].ident), "Sized"); + } } break; }, @@ -549,8 +554,7 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap(); writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap(); - writeln!(w, "#[no_mangle]").unwrap(); - writeln!(w, "pub(crate) extern \"C\" fn {}_clone_fields(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap(); + writeln!(w, "pub(crate) fn {}_clone_fields(orig: &{}) -> {} {{", trait_name, trait_name, trait_name).unwrap(); writeln!(w, "\t{} {{", trait_name).unwrap(); writeln!(w, "\t\tthis_arg: orig.this_arg,").unwrap(); for (field, clone_fn, _) in generated_fields.iter() { @@ -642,6 +646,8 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty writeln!(w, "// directly as a Deref trait in higher-level structs:").unwrap(); writeln!(w, "impl core::ops::Deref for {} {{\n\ttype Target = Self;", trait_name).unwrap(); writeln!(w, "\tfn deref(&self) -> &Self {{\n\t\tself\n\t}}\n}}").unwrap(); + writeln!(w, "impl core::ops::DerefMut for {} {{", trait_name).unwrap(); + writeln!(w, "\tfn deref_mut(&mut self) -> &mut Self {{\n\t\tself\n\t}}\n}}").unwrap(); } writeln!(w, "/// Calls the free function if one is set").unwrap(); @@ -800,7 +806,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, define_field!(('a' as u8 + idx as u8) as char, ('0' as u8 + idx as u8) as char, field); } } - _ => unimplemented!() + syn::Fields::Unit => {}, } if all_fields_settable { @@ -823,7 +829,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, types.write_c_type(w, &field.ty, Some(&gen_types), false); } } - _ => unreachable!() + syn::Fields::Unit => {}, } write!(w, ") -> {} {{\n\t", struct_name).unwrap(); match &s.fields { @@ -843,7 +849,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, } } }, - _ => unreachable!() + syn::Fields::Unit => {}, } write!(w, "{} {{ inner: ObjOps::heap_alloc(", struct_name).unwrap(); match &s.fields { @@ -871,7 +877,7 @@ fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, } write!(w, "\t)").unwrap(); }, - _ => unreachable!() + syn::Fields::Unit => write!(w, "{}::{} {{}}", types.module_path, struct_name).unwrap(), } writeln!(w, "), is_owned: true }}\n}}").unwrap(); } @@ -940,9 +946,11 @@ fn writeln_impl(w: &mut W, w_uses: &mut HashSet(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]); }, } } } @@ -2307,9 +2319,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]); }, } } }