//! It also generates relevant memory-management functions and free-standing functions with
//! parameters mapped.
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
use std::env;
use std::fs::File;
use std::io::{Read, Write};
if let Some(s) = types.maybe_resolve_ident(&struct_for) {
if !types.crate_types.opaques.get(&s).is_some() { return; }
writeln!(w, "#[no_mangle]").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_write(obj: *const {}) -> crate::c_types::derived::CVec_u8Z {{", struct_for, struct_for).unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_write(obj: &{}) -> crate::c_types::derived::CVec_u8Z {{", struct_for, struct_for).unwrap();
writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &(*(*obj).inner) }})").unwrap();
writeln!(w, "}}").unwrap();
writeln!(w, "#[no_mangle]").unwrap();
}
}
-/// Convert "impl trait_path for for_obj { .. }" for manually-mapped types (ie (de)serialization)
-fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path, for_obj: &syn::Ident, types: &TypeResolver) {
- if let Some(t) = types.maybe_resolve_path(&trait_path, None) {
- let s = types.maybe_resolve_ident(for_obj).unwrap();
- if !types.crate_types.opaques.get(&s).is_some() { return; }
+/// Convert "impl trait_path for for_ty { .. }" for manually-mapped types (ie (de)serialization)
+fn maybe_convert_trait_impl<W: std::io::Write>(w: &mut W, trait_path: &syn::Path, for_ty: &syn::Type, types: &mut TypeResolver, generics: &GenericTypes) {
+ if let Some(t) = types.maybe_resolve_path(&trait_path, Some(generics)) {
+ let for_obj;
+ let full_obj_path;
+ let mut has_inner = false;
+ if let syn::Type::Path(ref p) = for_ty {
+ if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
+ for_obj = format!("{}", ident);
+ full_obj_path = for_obj.clone();
+ has_inner = types.c_type_has_inner_from_path(&types.resolve_path(&p.path, Some(generics)));
+ } else { return; }
+ } else {
+ // We assume that anything that isn't a Path is somehow a generic that ends up in our
+ // derived-types module.
+ 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()));
+ for_obj = full_obj_path[TypeResolver::generated_container_path().len() + 2..].into();
+ }
+
match &t as &str {
"util::ser::Writeable" => {
writeln!(w, "#[no_mangle]").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_write(obj: *const {}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, for_obj).unwrap();
- writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &(*(*obj).inner) }})").unwrap();
- writeln!(w, "}}").unwrap();
- writeln!(w, "#[no_mangle]").unwrap();
- writeln!(w, "pub(crate) extern \"C\" fn {}_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {{", for_obj).unwrap();
- writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &*(obj as *const native{}) }})", for_obj).unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_write(obj: &{}) -> crate::c_types::derived::CVec_u8Z {{", for_obj, full_obj_path).unwrap();
+
+ let ref_type = syn::Type::Reference(syn::TypeReference {
+ and_token: syn::Token!(&)(Span::call_site()), lifetime: None, mutability: None,
+ elem: Box::new(for_ty.clone()) });
+ assert!(!types.write_from_c_conversion_new_var(w, &syn::Ident::new("obj", Span::call_site()), &ref_type, Some(generics)));
+
+ write!(w, "\tcrate::c_types::serialize_obj(").unwrap();
+ types.write_from_c_conversion_prefix(w, &ref_type, Some(generics));
+ write!(w, "unsafe {{ &*obj }}").unwrap();
+ types.write_from_c_conversion_suffix(w, &ref_type, Some(generics));
+ writeln!(w, ")").unwrap();
+
writeln!(w, "}}").unwrap();
+ if has_inner {
+ writeln!(w, "#[no_mangle]").unwrap();
+ writeln!(w, "pub(crate) extern \"C\" fn {}_write_void(obj: *const c_void) -> crate::c_types::derived::CVec_u8Z {{", for_obj).unwrap();
+ writeln!(w, "\tcrate::c_types::serialize_obj(unsafe {{ &*(obj as *const native{}) }})", for_obj).unwrap();
+ writeln!(w, "}}").unwrap();
+ }
},
- "util::ser::Readable" => {
+ "util::ser::Readable"|"util::ser::ReadableArgs" => {
+ // Create the Result<Object, DecodeError> syn::Type
+ let mut err_segs = syn::punctuated::Punctuated::new();
+ err_segs.push(syn::PathSegment { ident: syn::Ident::new("ln", Span::call_site()), arguments: syn::PathArguments::None });
+ err_segs.push(syn::PathSegment { ident: syn::Ident::new("msgs", Span::call_site()), arguments: syn::PathArguments::None });
+ err_segs.push(syn::PathSegment { ident: syn::Ident::new("DecodeError", Span::call_site()), arguments: syn::PathArguments::None });
+ let mut args = syn::punctuated::Punctuated::new();
+ args.push(syn::GenericArgument::Type(for_ty.clone()));
+ args.push(syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
+ qself: None, path: syn::Path {
+ leading_colon: Some(syn::Token)), segments: err_segs,
+ }
+ })));
+ let mut res_segs = syn::punctuated::Punctuated::new();
+ res_segs.push(syn::PathSegment {
+ ident: syn::Ident::new("Result", Span::call_site()),
+ arguments: syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
+ colon2_token: None, lt_token: syn::Token), args, gt_token: syn::Token),
+ })
+ });
+ let res_ty = syn::Type::Path(syn::TypePath { qself: None, path: syn::Path {
+ leading_colon: None, segments: res_segs } });
+
writeln!(w, "#[no_mangle]").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_read(ser: crate::c_types::u8slice) -> {} {{", for_obj, for_obj).unwrap();
- writeln!(w, "\tif let Ok(res) = crate::c_types::deserialize_obj(ser) {{").unwrap();
- writeln!(w, "\t\t{} {{ inner: Box::into_raw(Box::new(res)), is_owned: true }}", for_obj).unwrap();
- writeln!(w, "\t}} else {{").unwrap();
- writeln!(w, "\t\t{} {{ inner: std::ptr::null_mut(), is_owned: true }}", for_obj).unwrap();
- writeln!(w, "\t}}\n}}").unwrap();
+ write!(w, "pub extern \"C\" fn {}_read(ser: crate::c_types::u8slice", for_obj).unwrap();
+
+ let mut arg_conv = Vec::new();
+ if t == "util::ser::ReadableArgs" {
+ write!(w, ", arg: ").unwrap();
+ assert!(trait_path.leading_colon.is_none());
+ let args_seg = trait_path.segments.iter().last().unwrap();
+ assert_eq!(format!("{}", args_seg.ident), "ReadableArgs");
+ if let syn::PathArguments::AngleBracketed(args) = &args_seg.arguments {
+ assert_eq!(args.args.len(), 1);
+ if let syn::GenericArgument::Type(args_ty) = args.args.iter().next().unwrap() {
+ types.write_c_type(w, args_ty, Some(generics), false);
+
+ assert!(!types.write_from_c_conversion_new_var(&mut arg_conv, &syn::Ident::new("arg", Span::call_site()), &args_ty, Some(generics)));
+
+ write!(&mut arg_conv, "\tlet arg_conv = ").unwrap();
+ types.write_from_c_conversion_prefix(&mut arg_conv, &args_ty, Some(generics));
+ write!(&mut arg_conv, "arg").unwrap();
+ types.write_from_c_conversion_suffix(&mut arg_conv, &args_ty, Some(generics));
+ } else { unreachable!(); }
+ } else { unreachable!(); }
+ }
+ write!(w, ") -> ").unwrap();
+ types.write_c_type(w, &res_ty, Some(generics), false);
+ writeln!(w, " {{").unwrap();
+
+ if t == "util::ser::ReadableArgs" {
+ w.write(&arg_conv).unwrap();
+ write!(w, ";\n\tlet res: ").unwrap();
+ // At least in one case we need type annotations here, so provide them.
+ types.write_rust_type(w, Some(generics), &res_ty);
+ writeln!(w, " = crate::c_types::deserialize_obj_arg(ser, arg_conv);").unwrap();
+ } else {
+ writeln!(w, "\tlet res = crate::c_types::deserialize_obj(ser);").unwrap();
+ }
+ write!(w, "\t").unwrap();
+ if types.write_to_c_conversion_new_var(w, &syn::Ident::new("res", Span::call_site()), &res_ty, Some(generics), false) {
+ write!(w, "\n\t").unwrap();
+ }
+ types.write_to_c_conversion_inline_prefix(w, &res_ty, Some(generics), false);
+ write!(w, "res").unwrap();
+ types.write_to_c_conversion_inline_suffix(w, &res_ty, Some(generics), false);
+ writeln!(w, "\n}}").unwrap();
},
_ => {},
}
}
// First try to resolve path to find in-crate traits, but if that doesn't work
// assume its a prelude trait (eg Clone, etc) and just use the single ident.
- if let Some(path) = $types.maybe_resolve_path(&supertrait.path, None) {
- match (&path as &str, &supertrait.path.segments.iter().last().unwrap().ident) {
- $( $pat => $e, )*
+ 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) {
+ $( $pat => $e, )*
+ }
+ continue;
}
- } else if let Some(ident) = supertrait.path.get_ident() {
+ }
+ if let Some(ident) = supertrait.path.get_ident() {
match (&format!("{}", ident) as &str, &ident) {
$( $pat => $e, )*
}
- } else {
+ } else if types_opt.is_some() {
panic!("Supertrait unresolvable and not single-ident");
}
},
}
}
// Add functions which may be required for supertrait implementations.
- walk_supertraits!(t, types, (
+ walk_supertraits!(t, Some(&types), (
("Clone", _) => {
writeln!(w, "\tpub clone: Option<extern \"C\" fn (this_arg: *const c_void) -> *mut c_void>,").unwrap();
generated_fields.push("clone".to_owned());
generated_fields.push("free".to_owned());
writeln!(w, "}}").unwrap();
// Implement supertraits for the C-mapped struct.
- walk_supertraits!(t, types, (
+ walk_supertraits!(t, Some(&types), (
("Send", _) => writeln!(w, "unsafe impl Send for {} {{}}", trait_name).unwrap(),
("Sync", _) => writeln!(w, "unsafe impl Sync for {} {{}}", trait_name).unwrap(),
("std::cmp::Eq", _) => {
writeln!(w, "#[allow(unused)]").unwrap();
writeln!(w, "/// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy").unwrap();
writeln!(w, "impl {} {{", struct_name).unwrap();
- writeln!(w, "\tpub(crate) fn take_ptr(mut self) -> *mut native{} {{", struct_name).unwrap();
+ writeln!(w, "\tpub(crate) fn take_inner(mut self) -> *mut native{} {{", struct_name).unwrap();
writeln!(w, "\t\tassert!(self.is_owned);").unwrap();
writeln!(w, "\t\tlet ret = self.inner;").unwrap();
writeln!(w, "\t\tself.inner = std::ptr::null_mut();").unwrap();
writeln!(w, "\t\tret").unwrap();
writeln!(w, "\t}}\n}}").unwrap();
- 'attr_loop: for attr in attrs.iter() {
- let tokens_clone = attr.tokens.clone();
- let mut token_iter = tokens_clone.into_iter();
- if let Some(token) = token_iter.next() {
- match token {
- TokenTree::Group(g) => {
- if format!("{}", single_ident_generic_path_to_ident(&attr.path).unwrap()) == "derive" {
- for id in g.stream().into_iter() {
- if let TokenTree::Ident(i) = id {
- if i == "Clone" {
- writeln!(w, "impl Clone for {} {{", struct_name).unwrap();
- writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
- writeln!(w, "\t\tSelf {{").unwrap();
- writeln!(w, "\t\t\tinner: Box::into_raw(Box::new(unsafe {{ &*self.inner }}.clone())),").unwrap();
- writeln!(w, "\t\t\tis_owned: true,").unwrap();
- writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
- writeln!(w, "#[allow(unused)]").unwrap();
- writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap();
- writeln!(w, "pub(crate) extern \"C\" fn {}_clone_void(this_ptr: *const c_void) -> *mut c_void {{", struct_name).unwrap();
- writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *mut native{})).clone() }})) as *mut c_void", struct_name).unwrap();
- writeln!(w, "}}").unwrap();
- writeln!(w, "#[no_mangle]").unwrap();
- writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", struct_name, struct_name, struct_name).unwrap();
- writeln!(w, "\t{} {{ inner: Box::into_raw(Box::new(unsafe {{ &*orig.inner }}.clone())), is_owned: true }}", struct_name).unwrap();
- writeln!(w, "}}").unwrap();
- break 'attr_loop;
- }
- }
- }
- }
- },
- _ => {},
- }
- }
+ if attrs_derives_clone(attrs) {
+ writeln!(w, "impl Clone for {} {{", struct_name).unwrap();
+ writeln!(w, "\tfn clone(&self) -> Self {{").unwrap();
+ writeln!(w, "\t\tSelf {{").unwrap();
+ writeln!(w, "\t\t\tinner: Box::into_raw(Box::new(unsafe {{ &*self.inner }}.clone())),").unwrap();
+ writeln!(w, "\t\t\tis_owned: true,").unwrap();
+ writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
+ writeln!(w, "#[allow(unused)]").unwrap();
+ writeln!(w, "/// Used only if an object of this type is returned as a trait impl by a method").unwrap();
+ writeln!(w, "pub(crate) extern \"C\" fn {}_clone_void(this_ptr: *const c_void) -> *mut c_void {{", struct_name).unwrap();
+ writeln!(w, "\tBox::into_raw(Box::new(unsafe {{ (*(this_ptr as *mut native{})).clone() }})) as *mut c_void", struct_name).unwrap();
+ writeln!(w, "}}").unwrap();
+ writeln!(w, "#[no_mangle]").unwrap();
+ writeln!(w, "pub extern \"C\" fn {}_clone(orig: &{}) -> {} {{", struct_name, struct_name, struct_name).unwrap();
+ writeln!(w, "\t{} {{ inner: Box::into_raw(Box::new(unsafe {{ &*orig.inner }}.clone())), is_owned: true }}", struct_name).unwrap();
+ writeln!(w, "}}").unwrap();
}
write_cpp_wrapper(cpp_headers, &format!("{}", ident), true);
///
/// A few non-crate Traits are hard-coded including Default.
fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut TypeResolver) {
+ match export_status(&i.attrs) {
+ ExportStatus::Export => {},
+ ExportStatus::NoExport|ExportStatus::TestOnly => return,
+ }
+
+ if let syn::Type::Tuple(_) = &*i.self_ty {
+ if types.understood_c_type(&*i.self_ty, None) {
+ let mut gen_types = GenericTypes::new();
+ if !gen_types.learn_generics(&i.generics, types) {
+ eprintln!("Not implementing anything for `impl (..)` due to not understood generics");
+ return;
+ }
+
+ if i.defaultness.is_some() || i.unsafety.is_some() { unimplemented!(); }
+ if let Some(trait_path) = i.trait_.as_ref() {
+ if trait_path.0.is_some() { unimplemented!(); }
+ if types.understood_c_path(&trait_path.1) {
+ eprintln!("Not implementing anything for `impl Trait for (..)` - we only support manual defines");
+ return;
+ } else {
+ // Just do a manual implementation:
+ maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types);
+ }
+ } else {
+ eprintln!("Not implementing anything for plain `impl (..)` block - we only support `impl Trait for (..)` blocks");
+ return;
+ }
+ }
+ return;
+ }
if let &syn::Type::Path(ref p) = &*i.self_ty {
if p.qself.is_some() { unimplemented!(); }
if let Some(ident) = single_ident_generic_path_to_ident(&p.path) {
writeln!(w, "\t\tret.free = Some({}_free_void);", ident).unwrap();
writeln!(w, "\t\tret\n\t}}\n}}").unwrap();
- write!(w, "#[no_mangle]\npub extern \"C\" fn {}_as_{}(this_arg: *const {}) -> crate::{} {{\n", ident, trait_obj.ident, ident, full_trait_path).unwrap();
+ write!(w, "#[no_mangle]\npub extern \"C\" fn {}_as_{}(this_arg: &{}) -> crate::{} {{\n", ident, trait_obj.ident, ident, full_trait_path).unwrap();
writeln!(w, "\tcrate::{} {{", full_trait_path).unwrap();
writeln!(w, "\t\tthis_arg: unsafe {{ (*this_arg).inner as *mut c_void }},").unwrap();
writeln!(w, "\t\tfree: None,").unwrap();
_ => {},
}
}
- walk_supertraits!(trait_obj, types, (
+ walk_supertraits!(trait_obj, Some(&types), (
("Clone", _) => {
writeln!(w, "\t\tclone: Some({}_clone_void),", ident).unwrap();
},
_ => unimplemented!(),
}
}
- walk_supertraits!(trait_obj, types, (
+ walk_supertraits!(trait_obj, Some(&types), (
(s, t) => {
if let Some(supertrait_obj) = types.crate_types.traits.get(s).cloned() {
writeln!(w, "use {}::{} as native{}Trait;", types.orig_crate, s, t).unwrap();
},
"PartialEq" => {},
// If we have no generics, try a manual implementation:
- _ if p.path.get_ident().is_some() => maybe_convert_trait_impl(w, &trait_path.1, &ident, types),
- _ => {},
+ _ => maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types),
}
- } else if p.path.get_ident().is_some() {
+ } else {
// If we have no generics, try a manual implementation:
- maybe_convert_trait_impl(w, &trait_path.1, &ident, types);
+ maybe_convert_trait_impl(w, &trait_path.1, &*i.self_ty, types, &gen_types);
}
} else {
let declared_type = (*types.get_declared_type(&ident).unwrap()).clone();
ExportStatus::NoExport|ExportStatus::TestOnly => continue,
}
let struct_path = format!("{}::{}", module, s.ident);
+ if attrs_derives_clone(&s.attrs) {
+ crate_types.clonable_types.insert("crate::".to_owned() + &struct_path);
+ }
+
crate_types.opaques.insert(struct_path, &s.ident);
}
},
ExportStatus::NoExport|ExportStatus::TestOnly => continue,
}
let trait_path = format!("{}::{}", module, t.ident);
+ walk_supertraits!(t, None, (
+ ("Clone", _) => {
+ crate_types.clonable_types.insert("crate::".to_owned() + &trait_path);
+ },
+ (_, _) => {}
+ ) );
crate_types.traits.insert(trait_path, &t);
}
},
ExportStatus::NoExport|ExportStatus::TestOnly => continue,
}
let enum_path = format!("{}::{}", module, e.ident);
+ if attrs_derives_clone(&e.attrs) {
+ crate_types.clonable_types.insert("crate::".to_owned() + &enum_path);
+ }
crate_types.opaques.insert(enum_path, &e.ident);
}
},
ExportStatus::NoExport|ExportStatus::TestOnly => continue,
}
let enum_path = format!("{}::{}", module, e.ident);
+ if attrs_derives_clone(&e.attrs) {
+ crate_types.clonable_types.insert("crate::".to_owned() + &enum_path);
+ }
crate_types.mirrored_enums.insert(enum_path, &e);
}
},
let mut cpp_header_file = std::fs::OpenOptions::new().write(true).create(true).truncate(true)
.open(&args[6]).expect("Unable to open new header file");
- writeln!(header_file, "#if defined(__GNUC__)\n#define MUST_USE_STRUCT __attribute__((warn_unused))").unwrap();
- writeln!(header_file, "#else\n#define MUST_USE_STRUCT\n#endif").unwrap();
- writeln!(header_file, "#if defined(__GNUC__)\n#define MUST_USE_RES __attribute__((warn_unused_result))").unwrap();
- writeln!(header_file, "#else\n#define MUST_USE_RES\n#endif").unwrap();
+ writeln!(header_file, "#if defined(__GNUC__)").unwrap();
+ writeln!(header_file, "#define MUST_USE_STRUCT __attribute__((warn_unused))").unwrap();
+ writeln!(header_file, "#define MUST_USE_RES __attribute__((warn_unused_result))").unwrap();
+ writeln!(header_file, "#else").unwrap();
+ writeln!(header_file, "#define MUST_USE_STRUCT").unwrap();
+ writeln!(header_file, "#define MUST_USE_RES").unwrap();
+ writeln!(header_file, "#endif").unwrap();
+ writeln!(header_file, "#if defined(__clang__)").unwrap();
+ writeln!(header_file, "#define NONNULL_PTR _Nonnull").unwrap();
+ writeln!(header_file, "#else").unwrap();
+ writeln!(header_file, "#define NONNULL_PTR").unwrap();
+ writeln!(header_file, "#endif").unwrap();
writeln!(cpp_header_file, "#include <string.h>\nnamespace LDK {{").unwrap();
// First parse the full crate's ASTs, caching them so that we can hold references to the AST
// ...then walk the ASTs tracking what types we will map, and how, so that we can resolve them
// when parsing other file ASTs...
let mut libtypes = CrateTypes { traits: HashMap::new(), opaques: HashMap::new(), mirrored_enums: HashMap::new(),
- type_aliases: HashMap::new(), templates_defined: HashMap::default(), template_file: &mut derived_templates };
+ type_aliases: HashMap::new(), templates_defined: HashMap::default(), template_file: &mut derived_templates,
+ clonable_types: HashSet::new() };
walk_ast(&args[1], "/lib.rs", "".to_string(), &libast, &mut libtypes);
// ... finally, do the actual file conversion/mapping, writing out types as we go.
projects / rust-lightning / blobdiff