}
pub fn assert_simple_bound(bound: &syn::TraitBound) {
- if bound.paren_token.is_some() || bound.lifetimes.is_some() { unimplemented!(); }
+ if bound.paren_token.is_some() { unimplemented!(); }
if let syn::TraitBoundModifier::Maybe(_) = bound.modifier { unimplemented!(); }
}
}
/// Learn the generics in generics in the current context, given a TypeResolver.
- pub fn learn_generics<'b, 'c>(&mut self, generics: &'a syn::Generics, types: &'b TypeResolver<'a, 'c>) -> bool {
+ pub fn learn_generics_with_impls<'b, 'c>(&mut self, generics: &'a syn::Generics, impld_generics: &'a syn::PathArguments, types: &'b TypeResolver<'a, 'c>) -> bool {
let mut new_typed_generics = HashMap::new();
// First learn simple generics...
- for generic in generics.params.iter() {
+ for (idx, generic) in generics.params.iter().enumerate() {
match generic {
syn::GenericParam::Type(type_param) => {
let mut non_lifetimes_processed = false;
if let Some(default) = type_param.default.as_ref() {
assert!(type_param.bounds.is_empty());
self.default_generics.insert(&type_param.ident, (default.clone(), parse_quote!(&#default), parse_quote!(&mut #default)));
+ } else if type_param.bounds.is_empty() {
+ if let syn::PathArguments::AngleBracketed(args) = impld_generics {
+ match &args.args[idx] {
+ syn::GenericArgument::Type(ty) => {
+ self.default_generics.insert(&type_param.ident, (ty.clone(), parse_quote!(&#ty), parse_quote!(&mut #ty)));
+ }
+ _ => unimplemented!(),
+ }
+ }
}
},
_ => {},
for pred in wh.predicates.iter() {
if let syn::WherePredicate::Type(t) = pred {
if let syn::Type::Path(p) = &t.bounded_ty {
+ if first_seg_self(&t.bounded_ty).is_some() && p.path.segments.len() == 1 { continue; }
if p.qself.is_some() { return false; }
if p.path.leading_colon.is_some() { return false; }
let mut p_iter = p.path.segments.iter();
true
}
+ /// Learn the generics in generics in the current context, given a TypeResolver.
+ pub fn learn_generics<'b, 'c>(&mut self, generics: &'a syn::Generics, types: &'b TypeResolver<'a, 'c>) -> bool {
+ self.learn_generics_with_impls(generics, &syn::PathArguments::None, types)
+ }
+
/// Learn the associated types from the trait in the current context.
pub fn learn_associated_types<'b, 'c>(&mut self, t: &'a syn::ItemTrait, types: &'b TypeResolver<'a, 'c>) {
for item in t.items.iter() {
Some(format!("{}::{}{}", self.module_path, first_seg.ident, remaining))
} else if first_seg_is_stdlib(&first_seg_str) || self.dependencies.contains(&first_seg.ident) {
Some(first_seg_str + &remaining)
+ } else if first_seg_str == "crate" {
+ Some(self.crate_name.to_owned() + &remaining)
} else { None }
}
}
let modname = if module != "" {
module.clone() + "::" + &modident
} else {
+ self.dependencies.insert(m.ident);
modident.clone()
};
self.load_module(modname, m.attrs, m.content.unwrap().1);
"std::time::Duration"|"core::time::Duration" => Some("u64"),
"std::time::SystemTime" => Some("u64"),
- "std::io::Error"|"lightning::io::Error" => Some("crate::c_types::IOError"),
+ "std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some("crate::c_types::IOError"),
"core::fmt::Arguments" if is_ref => Some("crate::c_types::Str"),
"core::convert::Infallible" => Some("crate::c_types::NotConstructable"),
"bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some("crate::c_types::RecoverableSignature"),
"bitcoin::secp256k1::SecretKey" if is_ref => Some("*const [u8; 32]"),
"bitcoin::secp256k1::SecretKey" if !is_ref => Some("crate::c_types::SecretKey"),
+ "bitcoin::secp256k1::Scalar" if is_ref => Some("*const crate::c_types::BigEndianScalar"),
+ "bitcoin::secp256k1::Scalar" if !is_ref => Some("crate::c_types::BigEndianScalar"),
+ "bitcoin::secp256k1::ecdh::SharedSecret" if !is_ref => Some("crate::c_types::ThirtyTwoBytes"),
+
"bitcoin::blockdata::script::Script" if is_ref => Some("crate::c_types::u8slice"),
"bitcoin::blockdata::script::Script" if !is_ref => Some("crate::c_types::derived::CVec_u8Z"),
"bitcoin::blockdata::transaction::OutPoint" => Some("crate::lightning::chain::transaction::OutPoint"),
"str" if is_ref => Some(""),
"alloc::string::String"|"String" => Some(""),
- "std::io::Error"|"lightning::io::Error" => Some(""),
+ "std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some(""),
// Note that we'll panic for String if is_ref, as we only have non-owned memory, we
// cannot create a &String.
"bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some(""),
"bitcoin::secp256k1::SecretKey" if is_ref => Some("&::bitcoin::secp256k1::SecretKey::from_slice(&unsafe { *"),
"bitcoin::secp256k1::SecretKey" if !is_ref => Some(""),
+ "bitcoin::secp256k1::Scalar" if !is_ref => Some(""),
+ "bitcoin::secp256k1::ecdh::SharedSecret" if !is_ref => Some("::bitcoin::secp256k1::ecdh::SharedSecret::from_bytes("),
+
"bitcoin::blockdata::script::Script" if is_ref => Some("&::bitcoin::blockdata::script::Script::from(Vec::from("),
"bitcoin::blockdata::script::Script" if !is_ref => Some("::bitcoin::blockdata::script::Script::from("),
"bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" if is_ref => Some("&"),
"str" if is_ref => Some(".into_str()"),
"alloc::string::String"|"String" => Some(".into_string()"),
"std::io::Error"|"lightning::io::Error" => Some(".to_rust()"),
+ "lightning::io::ErrorKind" => Some(".to_rust_kind()"),
"core::convert::Infallible" => Some("\")"),
"bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some(".into_rust()"),
"bitcoin::secp256k1::SecretKey" if !is_ref => Some(".into_rust()"),
"bitcoin::secp256k1::SecretKey" if is_ref => Some("}[..]).unwrap()"),
+ "bitcoin::secp256k1::Scalar" if !is_ref => Some(".into_rust()"),
+ "bitcoin::secp256k1::ecdh::SharedSecret" if !is_ref => Some(".data)"),
+
"bitcoin::blockdata::script::Script" if is_ref => Some(".to_slice()))"),
"bitcoin::blockdata::script::Script" if !is_ref => Some(".into_rust())"),
"bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(".into_bitcoin()"),
"std::time::Duration"|"core::time::Duration" => Some(""),
"std::time::SystemTime" => Some(""),
"std::io::Error"|"lightning::io::Error" => Some("crate::c_types::IOError::from_rust("),
+ "lightning::io::ErrorKind" => Some("crate::c_types::IOError::from_rust_kind("),
"core::fmt::Arguments" => Some("alloc::format!(\"{}\", "),
"core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
"bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some("crate::c_types::RecoverableSignature::from_rust(&"),
"bitcoin::secp256k1::SecretKey" if is_ref => Some(""),
"bitcoin::secp256k1::SecretKey" if !is_ref => Some("crate::c_types::SecretKey::from_rust("),
+ "bitcoin::secp256k1::Scalar" if !is_ref => Some("crate::c_types::BigEndianScalar::from_rust("),
+ "bitcoin::secp256k1::ecdh::SharedSecret" if !is_ref => Some("crate::c_types::ThirtyTwoBytes { data: "),
+
"bitcoin::blockdata::script::Script" if is_ref => Some("crate::c_types::u8slice::from_slice(&"),
"bitcoin::blockdata::script::Script" if !is_ref => Some(""),
"bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" if is_ref => Some("crate::c_types::Transaction::from_bitcoin("),
"std::time::Duration"|"core::time::Duration" => Some(".as_secs()"),
"std::time::SystemTime" => Some(".duration_since(::std::time::SystemTime::UNIX_EPOCH).expect(\"Times must be post-1970\").as_secs()"),
- "std::io::Error"|"lightning::io::Error" => Some(")"),
+ "std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some(")"),
"core::fmt::Arguments" => Some(").into()"),
"core::convert::Infallible" => Some("\")"),
"bitcoin::secp256k1::ecdsa::RecoverableSignature" => Some(")"),
"bitcoin::secp256k1::SecretKey" if !is_ref => Some(")"),
"bitcoin::secp256k1::SecretKey" if is_ref => Some(".as_ref()"),
+ "bitcoin::secp256k1::Scalar" if !is_ref => Some(")"),
+ "bitcoin::secp256k1::ecdh::SharedSecret" if !is_ref => Some(".secret_bytes() }"),
+
"bitcoin::blockdata::script::Script" if is_ref => Some("[..])"),
"bitcoin::blockdata::script::Script" if !is_ref => Some(".into_bytes().into()"),
"bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(")"),
if let Some(resolved) = self.maybe_resolve_path(&p.path, generics) {
if self.c_type_has_inner_from_path(&resolved) { return true; }
if self.is_primitive(&resolved) { return false; }
- if self.c_type_from_path(&resolved, false, false).is_some() { true } else { false }
+ // We want to move to using `Option_` mappings where possible rather than
+ // manual mappings, as it makes downstream bindings simpler and is more
+ // clear for users. Thus, we default to false but override for a few
+ // types which had mappings defined when we were avoiding the `Option_`s.
+ match &resolved as &str {
+ "lightning::ln::PaymentSecret" => true,
+ "lightning::ln::PaymentHash" => true,
+ "lightning::ln::PaymentPreimage" => true,
+ "lightning::ln::channelmanager::PaymentId" => true,
+ "bitcoin::hash_types::BlockHash" => true,
+ "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => true,
+ _ => false,
+ }
} else { unimplemented!(); }
},
syn::Type::Tuple(_) => false,
(".is_none() { core::ptr::null_mut() } else { ".to_owned(), format!("({}.unwrap())", var_access))
], " }", ContainerPrefixLocation::OutsideConv));
}
- } else if self.is_primitive(&inner_path) || self.c_type_from_path(&inner_path, false, false).is_none() {
+ } else if !self.is_transparent_container("Option", is_ref, [single_contained.unwrap()].iter().map(|a| *a), generics) {
if self.is_primitive(&inner_path) || (!is_contained_ref && !is_ref) || only_contained_has_inner {
let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap();
return Some(("if ", vec![
}
if let Some(t) = single_contained {
if let syn::Type::Tuple(syn::TypeTuple { elems, .. }) = t {
- assert!(elems.is_empty());
let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap();
- return Some(("if ", vec![
- (format!(".is_none() {{ {}::None }} else {{ {}::Some /*",
- inner_name, inner_name), format!(""))
- ], " */}", ContainerPrefixLocation::PerConv));
+ if elems.is_empty() {
+ return Some(("if ", vec![
+ (format!(".is_none() {{ {}::None }} else {{ {}::Some /* ",
+ inner_name, inner_name), format!(""))
+ ], " */ }", ContainerPrefixLocation::PerConv));
+ } else {
+ return Some(("if ", vec![
+ (format!(".is_none() {{ {}::None }} else {{ {}::Some(",
+ inner_name, inner_name), format!("({}.unwrap())", var_access))
+ ], ") }", ContainerPrefixLocation::PerConv));
+ }
}
if let syn::Type::Reference(syn::TypeReference { elem, .. }) = t {
if let syn::Type::Slice(_) = &**elem {
write!(w, "{}", sliceconv(false, None)).unwrap();
}
}
+ } else if let syn::Type::Array(_) = &*s.elem {
+ write!(w, "{}", sliceconv(false, Some(".map(|a| *a)"))).unwrap();
} else { unimplemented!(); }
},
syn::Type::Tuple(t) => {
// For slices (and Options), we refuse to directly map them as is_ref when they
// aren't opaque types containing an inner pointer. This is due to the fact that,
// in both cases, the actual higher-level type is non-is_ref.
- let ty_has_inner = if $args_len == 1 {
+ let (ty_has_inner, ty_is_trait) = if $args_len == 1 {
let ty = $args_iter().next().unwrap();
if $container_type == "Slice" && to_c {
// "To C ptr_for_ref" means "return the regular object with is_owned
}
if let syn::Type::Reference(t) = ty {
if let syn::Type::Path(p) = &*t.elem {
- self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics))
- } else { false }
+ let resolved = self.resolve_path(&p.path, generics);
+ (self.c_type_has_inner_from_path(&resolved), self.crate_types.traits.get(&resolved).is_some())
+ } else { (false, false) }
} else if let syn::Type::Path(p) = ty {
- self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics))
- } else { false }
- } else { true };
+ let resolved = self.resolve_path(&p.path, generics);
+ (self.c_type_has_inner_from_path(&resolved), self.crate_types.traits.get(&resolved).is_some())
+ } else { (false, false) }
+ } else { (true, false) };
// Options get a bunch of special handling, since in general we map Option<>al
// types into the same C type as non-Option-wrapped types. This ends up being
// If the inner element contains an inner pointer, we will just use that,
// avoiding the need to map elements to references. Otherwise we'll need to
// do an extra mapping step.
- needs_ref_map = !only_contained_has_inner && $container_type == "Option";
+ needs_ref_map = !only_contained_has_inner && !ty_is_trait && $container_type == "Option";
} else {
only_contained_type = Some(arg);
only_contained_type_nonref = Some(arg);
ptr_for_ref = true;
convert_container!("Slice", 1, || ty.iter());
unimplemented!("convert_container should return true as container_lookup should succeed for slices");
+ } else if let syn::Type::Array(_) = &*s.elem {
+ is_ref = false;
+ ptr_for_ref = true;
+ let arr_elem = [(*s.elem).clone()];
+ convert_container!("Slice", 1, || arr_elem.iter());
+ unimplemented!("convert_container should return true as container_lookup should succeed for slices");
} else { unimplemented!() }
},
syn::Type::Tuple(t) => {
// ******************************************************
fn write_template_generics<'b, W: std::io::Write>(&self, w: &mut W, args: &mut dyn Iterator<Item=&'b syn::Type>, generics: Option<&GenericTypes>, is_ref: bool) -> bool {
- for (idx, t) in args.enumerate() {
+ for (idx, orig_t) in args.enumerate() {
if idx != 0 {
write!(w, ", ").unwrap();
}
+ let t = generics.resolve_type(orig_t);
if let syn::Type::Reference(r_arg) = t {
assert!(!is_ref); // We don't currently support outer reference types for non-primitive inners
if let syn::Type::Path(p_arg) = &*r_arg.elem {
let resolved = self.resolve_path(&p_arg.path, generics);
assert!(self.crate_types.opaques.get(&resolved).is_some() ||
+ self.crate_types.traits.get(&resolved).is_some() ||
self.c_type_from_path(&resolved, true, true).is_some(), "Template generics should be opaque or have a predefined mapping");
} else { unimplemented!(); }
} else if let syn::Type::Path(p_arg) = t {
let mut segments = syn::punctuated::Punctuated::new();
segments.push(parse_quote!(Vec<#args>));
self.write_c_type_intern(w, &syn::Type::Path(syn::TypePath { qself: None, path: syn::Path { leading_colon: None, segments } }), generics, false, is_mut, ptr_for_ref, with_ref_lifetime, c_ty)
+ } else if let syn::Type::Array(a) = &*s.elem {
+ if let syn::Expr::Lit(l) = &a.len {
+ if let syn::Lit::Int(i) = &l.lit {
+ let mut buf = Vec::new();
+ self.write_rust_type(&mut buf, generics, &*a.elem, false);
+ let arr_ty = String::from_utf8(buf).unwrap();
+
+ let arr_str = format!("[{}; {}]", arr_ty, i.base10_digits());
+ let ty = self.c_type_from_path(&arr_str, false, ptr_for_ref).unwrap()
+ .rsplitn(2, "::").next().unwrap();
+
+ let mangled_container = format!("CVec_{}Z", ty);
+ write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap();
+ self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false)
+ } else { false }
+ } else { false }
} else { false }
},
syn::Type::Tuple(t) => {