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();
+ }
- write!(&mut arg_conv, "\t").unwrap();
- if types.write_from_c_conversion_new_var(&mut arg_conv, &format_ident!("arg"), &args_ty, Some(generics)) {
- write!(&mut arg_conv, "\n\t").unwrap();
+ 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, "let 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();
ExportStatus::TestOnly => continue,
ExportStatus::NotImplementable => panic!("(C-not implementable) must only appear on traits"),
}
- if m.default.is_some() { unimplemented!(); }
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, types));
match item {
syn::TraitItem::Method(m) => {
if let ExportStatus::TestOnly = export_status(&m.attrs) { continue; }
- if m.default.is_some() { unimplemented!(); }
if m.sig.constness.is_some() || m.sig.asyncness.is_some() || m.sig.unsafety.is_some() ||
m.sig.abi.is_some() || m.sig.variadic.is_some() {
- unimplemented!();
+ panic!("1");
}
let mut meth_gen_types = gen_types.push_ctx();
assert!(meth_gen_types.learn_generics(&m.sig.generics, $type_resolver));
for inp in m.sig.inputs.iter() {
match inp {
syn::FnArg::Receiver(recv) => {
- if !recv.attrs.is_empty() || recv.reference.is_none() { unimplemented!(); }
+ if !recv.attrs.is_empty() || recv.reference.is_none() { panic!("2"); }
write!(w, "&").unwrap();
if let Some(lft) = &recv.reference.as_ref().unwrap().1 {
write!(w, "'{} ", lft.ident).unwrap();
}
},
syn::FnArg::Typed(arg) => {
- if !arg.attrs.is_empty() { unimplemented!(); }
+ if !arg.attrs.is_empty() { panic!("3"); }
match &*arg.pat {
syn::Pat::Ident(ident) => {
if !ident.attrs.is_empty() || ident.by_ref.is_some() ||
ident.mutability.is_some() || ident.subpat.is_some() {
- unimplemented!();
+ panic!("4");
}
write!(w, ", mut {}{}: ", if $type_resolver.skip_arg(&*arg.ty, Some(&meth_gen_types)) { "_" } else { "" }, ident.ident).unwrap();
}
- _ => unimplemented!(),
+ _ => panic!("5"),
}
$type_resolver.write_rust_type(w, Some(&gen_types), &*arg.ty);
}
write!(w, " {{\n\t\t").unwrap();
match export_status(&m.attrs) {
ExportStatus::NoExport => {
- unimplemented!();
+ panic!("6");
},
_ => {},
}
writeln!(w, "\n\t}}").unwrap();
},
&syn::TraitItem::Type(ref t) => {
- if t.default.is_some() || t.generics.lt_token.is_some() { unimplemented!(); }
+ if t.default.is_some() || t.generics.lt_token.is_some() { panic!("10"); }
let mut bounds_iter = t.bounds.iter();
loop {
match bounds_iter.next().unwrap() {
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 { unimplemented!(); }
+ if let syn::TypeParamBound::Trait(_) = bound { panic!("11"); }
}
break;
},
}
}
},
- _ => unimplemented!(),
+ _ => panic!("12"),
}
}
}
}
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, "\t}}\n}}\n").unwrap();
macro_rules! impl_meth {
- ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr) => {
+ ($m: expr, $trait_meth: expr, $trait_path: expr, $trait: expr, $indent: expr, $types: expr) => {
let trait_method = $trait.items.iter().filter_map(|item| {
if let syn::TraitItem::Method(t_m) = item { Some(t_m) } else { None }
}).find(|trait_meth| trait_meth.sig.ident == $m.sig.ident).unwrap();
}
write!(w, "extern \"C\" fn {}_{}_{}(", ident, $trait.ident, $m.sig.ident).unwrap();
let mut meth_gen_types = gen_types.push_ctx();
- assert!(meth_gen_types.learn_generics(&$m.sig.generics, types));
+ assert!(meth_gen_types.learn_generics(&$m.sig.generics, $types));
let mut uncallable_function = false;
for inp in $m.sig.inputs.iter() {
match inp {
syn::FnArg::Typed(arg) => {
- if types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { continue; }
+ if $types.skip_arg(&*arg.ty, Some(&meth_gen_types)) { continue; }
let mut c_type = Vec::new();
- types.write_c_type(&mut c_type, &*arg.ty, Some(&meth_gen_types), false);
+ $types.write_c_type(&mut c_type, &*arg.ty, Some(&meth_gen_types), false);
if is_type_unconstructable(&String::from_utf8(c_type).unwrap()) {
uncallable_function = true;
}
}
}
if uncallable_function {
- let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ let mut trait_resolver = get_module_type_resolver!(full_trait_path, $types.crate_libs, $types.crate_types);
write_method_params(w, &$trait_meth.sig, "c_void", &mut trait_resolver, Some(&meth_gen_types), true, true);
} else {
- write_method_params(w, &$m.sig, "c_void", types, Some(&meth_gen_types), true, true);
+ write_method_params(w, &$m.sig, "c_void", $types, Some(&meth_gen_types), true, true);
}
write!(w, " {{\n\t").unwrap();
if uncallable_function {
write!(w, "unreachable!();").unwrap();
} else {
- write_method_var_decl_body(w, &$m.sig, "", types, Some(&meth_gen_types), false);
+ write_method_var_decl_body(w, &$m.sig, "", $types, Some(&meth_gen_types), false);
let mut takes_self = false;
for inp in $m.sig.inputs.iter() {
if let syn::FnArg::Receiver(_) = inp {
},
_ => {},
}
- write_method_call_params(w, &$m.sig, "", types, Some(&meth_gen_types), &real_type, false);
+ write_method_call_params(w, &$m.sig, "", $types, Some(&meth_gen_types), &real_type, false);
}
write!(w, "\n}}\n").unwrap();
if let syn::ReturnType::Type(_, rtype) = &$m.sig.output {
writeln!(w, "\t// This is a bit race-y in the general case, but for our specific use-cases today, we're safe").unwrap();
writeln!(w, "\t// Specifically, we must ensure that the first time we're called it can never be in parallel").unwrap();
write!(w, "\tif ").unwrap();
- types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident));
+ $types.write_empty_rust_val_check(Some(&meth_gen_types), w, &*r.elem, &format!("trait_self_arg.{}", $m.sig.ident));
writeln!(w, " {{").unwrap();
writeln!(w, "\t\tunsafe {{ &mut *(trait_self_arg as *const {} as *mut {}) }}.{} = {}_{}_{}(trait_self_arg.this_arg);", $trait.ident, $trait.ident, $m.sig.ident, ident, $trait.ident, $m.sig.ident).unwrap();
writeln!(w, "\t}}").unwrap();
}
}
- 'impl_item_loop: for item in i.items.iter() {
- match item {
- syn::ImplItem::Method(m) => {
- for trait_item in trait_obj.items.iter() {
- match trait_item {
- syn::TraitItem::Method(meth) => {
+ 'impl_item_loop: for trait_item in trait_obj.items.iter() {
+ match trait_item {
+ syn::TraitItem::Method(meth) => {
+ for item in i.items.iter() {
+ match item {
+ syn::ImplItem::Method(m) => {
if meth.sig.ident == m.sig.ident {
- impl_meth!(m, meth, full_trait_path, trait_obj, "");
+ impl_meth!(m, meth, full_trait_path, trait_obj, "", types);
continue 'impl_item_loop;
}
},
- _ => {},
+ syn::ImplItem::Type(_) => {},
+ _ => unimplemented!(),
}
}
- unreachable!();
+ assert!(meth.default.is_some());
+ let old_gen_types = gen_types;
+ gen_types = GenericTypes::new(Some(resolved_path.clone()));
+ let mut trait_resolver = get_module_type_resolver!(full_trait_path, types.crate_libs, types.crate_types);
+ impl_meth!(meth, meth, full_trait_path, trait_obj, "", &mut trait_resolver);
+ gen_types = old_gen_types;
},
- syn::ImplItem::Type(_) => {},
- _ => unimplemented!(),
+ _ => {},
}
}
if requires_clone {
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);
if !gen_types.as_mut().unwrap().learn_generics(&i.generics, types) {
gen_types = None;
}
- 'alias_impls: for (alias, arguments) in aliases {
+ let alias_module = rsplit_once(&resolved_path, "::").unwrap().0;
+
+ 'alias_impls: for (alias_resolved, arguments) in aliases {
let mut new_ty_generics = Vec::new();
let mut need_generics = false;
- let alias_resolved = types.resolve_path(&alias, None);
+ let alias_resolver_override;
+ let alias_resolver = if alias_module != types.module_path {
+ alias_resolver_override = ImportResolver::new(types.types.crate_name, &types.crate_types.lib_ast.dependencies,
+ 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();*/
for (idx, gen) in i.generics.params.iter().enumerate() {
match gen {
syn::GenericParam::Type(type_param) => {
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) = types.maybe_resolve_path(&p.path, None) {
+ 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.resolve_path(&trait_bound.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(traits_impld) = types.crate_types.trait_impls.get(&generic_arg) {
for trait_impld in traits_impld {
if *trait_impld == generic_bound { continue 'bounds_check; }
}
}
let mut params = syn::punctuated::Punctuated::new();
+ let alias = string_path_to_syn_path(&alias_resolved);
let real_aliased =
if need_generics {
let alias_generics = types.crate_types.opaques.get(&alias_resolved).unwrap().1;
match item {
syn::Item::Mod(m) => convert_priv_mod(w, libast, crate_types, out_dir, &format!("{}::{}", mod_path, module.ident), m),
syn::Item::Impl(i) => {
- if let &syn::Type::Path(ref p) = &*i.self_ty {
- if p.path.get_ident().is_some() {
- writeln_impl(w, i, &mut types);
- }
- }
+ writeln_impl(w, i, &mut types);
},
_ => {},
}
type_resolver.crate_types.priv_structs.get(&real_ty).map(|r| *r)).unwrap();
let mut resolved_generics = t.generics.clone();
+ // Assume blindly that the bounds in the struct definition where
+ // clause matches any equivalent bounds on the type alias.
+ assert!(resolved_generics.where_clause.is_none());
+ resolved_generics.where_clause = real_generic_bounds.where_clause.clone();
+
if let syn::PathArguments::AngleBracketed(real_generics) = &p.path.segments.last().unwrap().arguments {
for (real_idx, real_param) in real_generics.args.iter().enumerate() {
if let syn::GenericArgument::Type(syn::Type::Path(real_param_path)) = real_param {
let type_path = format!("{}::{}", module, t.ident);
match &*t.ty {
syn::Type::Path(p) => {
- let t_ident = &t.ident;
-
// If its a path with no generics, assume we don't map the aliased type and map it opaque
- let path_obj = parse_quote!(#t_ident);
let args_obj = p.path.segments.last().unwrap().arguments.clone();
match crate_types.reverse_alias_map.entry(import_resolver.maybe_resolve_path(&p.path, None).unwrap()) {
- hash_map::Entry::Occupied(mut e) => { e.get_mut().push((path_obj, args_obj)); },
- hash_map::Entry::Vacant(e) => { e.insert(vec![(path_obj, args_obj)]); },
+ hash_map::Entry::Occupied(mut e) => { e.get_mut().push((type_path.clone(), args_obj)); },
+ hash_map::Entry::Vacant(e) => { e.insert(vec![(type_path.clone(), args_obj)]); },
}
- crate_types.opaques.insert(type_path, (t_ident, &t.generics));
+ crate_types.opaques.insert(type_path, (&t.ident, &t.generics));
},
_ => {
crate_types.type_aliases.insert(type_path, import_resolver.resolve_imported_refs((*t.ty).clone()));
projects / ldk-c-bindings / blobdiff