use alloc::{vec::Vec, boxed::Box};
";
+
+/// str.rsplit_once but with an older MSRV
+fn rsplit_once<'a>(inp: &'a str, pattern: &str) -> Option<(&'a str, &'a str)> {
+ let mut iter = inp.rsplitn(2, pattern);
+ let second_entry = iter.next().unwrap();
+ Some((iter.next().unwrap(), second_entry))
+}
+
// *************************************
// *** Manually-expanded conversions ***
// *************************************
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; }
+ let resolved_path = types.resolve_path(&p.path, Some(generics));
+ for_obj = format!("{}", p.path.segments.last().unwrap().ident);
+ full_obj_path = format!("crate::{}", resolved_path);
+ has_inner = types.c_type_has_inner_from_path(&resolved_path);
} else {
// We assume that anything that isn't a Path is somehow a generic that ends up in our
// derived-types module.
let mut arg_conv = Vec::new();
if t == "lightning::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);
+ macro_rules! write_arg_conv {
+ ($ty: expr, $arg_name: expr) => {
+ write!(w, ", {}: ", $arg_name).unwrap();
+ types.write_c_type(w, $ty, Some(generics), false);
+
+ write!(&mut arg_conv, "\t").unwrap();
+ if types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("{}", $arg_name), &$ty, Some(generics)) {
+ write!(&mut arg_conv, "\n\t").unwrap();
+ }
- assert!(!types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("arg"), &args_ty, Some(generics)));
+ write!(&mut arg_conv, "let {}_conv = ", $arg_name).unwrap();
+ types.write_from_c_conversion_prefix(&mut arg_conv, &$ty, Some(generics));
+ write!(&mut arg_conv, "{}", $arg_name).unwrap();
+ types.write_from_c_conversion_suffix(&mut arg_conv, &$ty, Some(generics));
+ write!(&mut arg_conv, ";\n").unwrap();
+ }
+ }
- 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));
+ if let syn::Type::Tuple(tup) = args_ty {
+ // Crack open tuples and make them separate arguments instead of
+ // converting the full tuple. This makes it substantially easier to
+ // reason about things like references in the tuple fields.
+ let mut arg_conv_res = Vec::new();
+ for (idx, elem) in tup.elems.iter().enumerate() {
+ let arg_name = format!("arg_{}", ('a' as u8 + idx as u8) as char);
+ write_arg_conv!(elem, arg_name);
+ write!(&mut arg_conv_res, "{}_conv{}", arg_name, if idx != tup.elems.len() - 1 { ", " } else { "" }).unwrap();
+ }
+ writeln!(&mut arg_conv, "\tlet arg_conv = ({});", String::from_utf8(arg_conv_res).unwrap()).unwrap();
+ } else {
+ write_arg_conv!(args_ty, "arg");
+ }
} else { unreachable!(); }
} else { unreachable!(); }
} else if t == "lightning::util::ser::MaybeReadable" {
if t == "lightning::util::ser::ReadableArgs" {
w.write(&arg_conv).unwrap();
- write!(w, ";\n").unwrap();
}
write!(w, "\tlet res: ").unwrap();
}
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) {
- if let Some(resolved_path) = types.maybe_resolve_non_ignored_ident(&ident) {
+ let ident = &p.path.segments.last().unwrap().ident;
+ if let Some(resolved_path) = types.maybe_resolve_path(&p.path, None) {
+ if types.crate_types.opaques.contains_key(&resolved_path) || types.crate_types.mirrored_enums.contains_key(&resolved_path) ||
+ // At least for core::infallible::Infallible we need to support mapping an
+ // out-of-crate trait implementation.
+ (types.understood_c_path(&p.path) && first_seg_is_stdlib(resolved_path.split("::").next().unwrap())) {
if !types.understood_c_path(&p.path) {
eprintln!("Not implementing anything for impl {} as the type is not understood (probably C-not exported)", ident);
return;
writeln!(w, "\torig.clone()").unwrap();
writeln!(w, "}}").unwrap();
} else if path_matches_nongeneric(&trait_path.1, &["FromStr"]) {
- if let Some(container) = types.get_c_mangled_container_type(
- vec![&*i.self_ty, &syn::Type::Tuple(syn::TypeTuple { paren_token: Default::default(), elems: syn::punctuated::Punctuated::new() })],
- Some(&gen_types), "Result") {
+ let mut err_opt = None;
+ for item in i.items.iter() {
+ match item {
+ syn::ImplItem::Type(ty) if format!("{}", ty.ident) == "Err" => {
+ err_opt = Some(&ty.ty);
+ },
+ _ => {}
+ }
+ }
+ let err_ty = err_opt.unwrap();
+ if let Some(container) = types.get_c_mangled_container_type(vec![&*i.self_ty, &err_ty], Some(&gen_types), "Result") {
writeln!(w, "#[no_mangle]").unwrap();
writeln!(w, "/// Read a {} object from a string", ident).unwrap();
writeln!(w, "pub extern \"C\" fn {}_from_str(s: crate::c_types::Str) -> {} {{", ident, container).unwrap();
writeln!(w, "\tmatch {}::from_str(s.into_str()) {{", resolved_path).unwrap();
+
writeln!(w, "\t\tOk(r) => {{").unwrap();
let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("r"), &*i.self_ty, Some(&gen_types), false);
write!(w, "\t\t\tcrate::c_types::CResultTempl::ok(\n\t\t\t\t").unwrap();
write!(w, "{}r", if new_var { "local_" } else { "" }).unwrap();
types.write_to_c_conversion_inline_suffix(w, &*i.self_ty, Some(&gen_types), false);
writeln!(w, "\n\t\t\t)\n\t\t}},").unwrap();
- writeln!(w, "\t\tErr(e) => crate::c_types::CResultTempl::err(()),").unwrap();
+
+ writeln!(w, "\t\tErr(e) => {{").unwrap();
+ let new_var = types.write_to_c_conversion_new_var(w, &format_ident!("e"), &err_ty, Some(&gen_types), false);
+ write!(w, "\t\t\tcrate::c_types::CResultTempl::err(\n\t\t\t\t").unwrap();
+ types.write_to_c_conversion_inline_prefix(w, &err_ty, Some(&gen_types), false);
+ write!(w, "{}e", if new_var { "local_" } else { "" }).unwrap();
+ types.write_to_c_conversion_inline_suffix(w, &err_ty, Some(&gen_types), false);
+ writeln!(w, "\n\t\t\t)\n\t\t}},").unwrap();
+
writeln!(w, "\t}}.into()\n}}").unwrap();
}
} else if path_matches_nongeneric(&trait_path.1, &["Display"]) {
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();
+ let is_opaque = types.crate_types.opaques.contains_key(&resolved_path);
+ let is_mirrored_enum = types.crate_types.mirrored_enums.contains_key(&resolved_path);
for item in i.items.iter() {
match item {
syn::ImplItem::Method(m) => {
writeln!(w, "#[must_use]").unwrap();
}
write!(w, "#[no_mangle]\npub extern \"C\" fn {}_{}(", ident, m.sig.ident).unwrap();
- let ret_type = match &declared_type {
- DeclType::MirroredEnum => format!("{}", ident),
- DeclType::StructImported {..} => format!("{}", ident),
- _ => unimplemented!(),
- };
+ let ret_type = format!("crate::{}", resolved_path);
write_method_params(w, &m.sig, &ret_type, types, Some(&meth_gen_types), false, true);
write!(w, " {{\n\t").unwrap();
write_method_var_decl_body(w, &m.sig, "", types, Some(&meth_gen_types), false);
if !takes_mut_self && !takes_self {
write!(w, "{}::{}(", resolved_path, m.sig.ident).unwrap();
} else {
- match &declared_type {
- DeclType::MirroredEnum => write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap(),
- DeclType::StructImported {..} => {
- if takes_owned_self {
- write!(w, "(*unsafe {{ Box::from_raw(this_arg.take_inner()) }}).{}(", m.sig.ident).unwrap();
- } else if takes_mut_self {
- write!(w, "unsafe {{ &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut native{})) }}.{}(", ident, m.sig.ident).unwrap();
- } else {
- write!(w, "unsafe {{ &*ObjOps::untweak_ptr(this_arg.inner) }}.{}(", m.sig.ident).unwrap();
- }
- },
- _ => unimplemented!(),
+ if is_mirrored_enum {
+ write!(w, "this_arg.to_native().{}(", m.sig.ident).unwrap();
+ } else if is_opaque {
+ if takes_owned_self {
+ write!(w, "(*unsafe {{ Box::from_raw(this_arg.take_inner()) }}).{}(", m.sig.ident).unwrap();
+ } else if takes_mut_self {
+ write!(w, "unsafe {{ &mut (*ObjOps::untweak_ptr(this_arg.inner as *mut crate::{}::native{})) }}.{}(", rsplit_once(&resolved_path, "::").unwrap().0, ident, m.sig.ident).unwrap();
+ } else {
+ write!(w, "unsafe {{ &*ObjOps::untweak_ptr(this_arg.inner) }}.{}(", m.sig.ident).unwrap();
+ }
+ } else {
+ unimplemented!();
}
}
write_method_call_params(w, &m.sig, "", types, Some(&meth_gen_types), &ret_type, false);
projects / ldk-c-bindings / blobdiff