/// concrete C container struct, etc).
#[must_use]
pub struct GenericTypes<'a, 'b> {
- self_ty: Option<(String, &'a syn::Path)>,
+ self_ty: Option<String>,
parent: Option<&'b GenericTypes<'b, 'b>>,
- typed_generics: HashMap<&'a syn::Ident, (String, Option<&'a syn::Path>)>,
+ typed_generics: HashMap<&'a syn::Ident, String>,
default_generics: HashMap<&'a syn::Ident, (syn::Type, syn::Type)>,
}
impl<'a, 'p: 'a> GenericTypes<'a, 'p> {
- pub fn new(self_ty: Option<(String, &'a syn::Path)>) -> Self {
+ pub fn new(self_ty: Option<String>) -> Self {
Self { self_ty, parent: None, typed_generics: HashMap::new(), default_generics: HashMap::new(), }
}
/// 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 {
+ let mut new_typed_generics = HashMap::new();
// First learn simple generics...
for generic in generics.params.iter() {
match generic {
if path_matches_nongeneric(&trait_bound.path, &["core", "clone", "Clone"]) { continue; }
assert_simple_bound(&trait_bound);
- if let Some(mut path) = types.maybe_resolve_path(&trait_bound.path, None) {
+ if let Some(path) = types.maybe_resolve_path(&trait_bound.path, None) {
if types.skip_path(&path) { continue; }
if path == "Sized" { continue; }
if non_lifetimes_processed { return false; }
non_lifetimes_processed = true;
- let new_ident = if path != "std::ops::Deref" && path != "core::ops::Deref" {
- path = "crate::".to_string() + &path;
- Some(&trait_bound.path)
+ if path != "std::ops::Deref" && path != "core::ops::Deref" {
+ new_typed_generics.insert(&type_param.ident, Some(path));
} else if trait_bound.path.segments.len() == 1 {
// If we're templated on Deref<Target = ConcreteThing>, store
// the reference type in `default_generics` which handles full
_ => unimplemented!(),
}
}
- None
- } else { None }
- } else { None };
- self.typed_generics.insert(&type_param.ident, (path, new_ident));
- } else { return false; }
+ } else {
+ new_typed_generics.insert(&type_param.ident, None);
+ }
+ }
+ }
}
}
if let Some(default) = type_param.default.as_ref() {
if p.qself.is_some() { return false; }
if p.path.leading_colon.is_some() { return false; }
let mut p_iter = p.path.segments.iter();
- if let Some(gen) = self.typed_generics.get_mut(&p_iter.next().unwrap().ident) {
- if gen.0 != "std::ops::Deref" && gen.0 != "core::ops::Deref" { return false; }
- if &format!("{}", p_iter.next().unwrap().ident) != "Target" { return false; }
+ if let Some(gen) = new_typed_generics.get_mut(&p_iter.next().unwrap().ident) {
+ if gen.is_some() { return false; }
+ if &format!("{}", p_iter.next().unwrap().ident) != "Target" {return false; }
let mut non_lifetimes_processed = false;
for bound in t.bounds.iter() {
if non_lifetimes_processed { return false; }
non_lifetimes_processed = true;
assert_simple_bound(&trait_bound);
- *gen = ("crate::".to_string() + &types.resolve_path(&trait_bound.path, None),
- Some(&trait_bound.path));
+ *gen = Some(types.resolve_path(&trait_bound.path, None));
}
}
} else { return false; }
}
}
}
- for (_, (_, ident)) in self.typed_generics.iter() {
- if ident.is_none() { return false; }
+ for (key, value) in new_typed_generics.drain() {
+ if let Some(v) = value {
+ assert!(self.typed_generics.insert(key, v).is_none());
+ } else { return false; }
}
true
}
match bounds_iter.next().unwrap() {
syn::TypeParamBound::Trait(tr) => {
assert_simple_bound(&tr);
- if let Some(mut path) = types.maybe_resolve_path(&tr.path, None) {
+ if let Some(path) = types.maybe_resolve_path(&tr.path, None) {
if types.skip_path(&path) { continue; }
// In general we handle Deref<Target=X> as if it were just X (and
// implement Deref<Target=Self> for relevant types). We don't
// bother to implement it for associated types, however, so we just
// ignore such bounds.
- let new_ident = if path != "std::ops::Deref" && path != "core::ops::Deref" {
- path = "crate::".to_string() + &path;
- Some(&tr.path)
- } else { None };
- self.typed_generics.insert(&t.ident, (path, new_ident));
+ if path != "std::ops::Deref" && path != "core::ops::Deref" {
+ self.typed_generics.insert(&t.ident, path);
+ }
} else { unimplemented!(); }
},
_ => unimplemented!(),
pub fn maybe_resolve_ident<'b>(&'b self, ident: &syn::Ident) -> Option<&'b String> {
if let Some(ty) = &self.self_ty {
if format!("{}", ident) == "Self" {
- return Some(&ty.0);
+ return Some(&ty);
}
}
- if let Some(res) = self.typed_generics.get(ident).map(|(a, _)| a) {
+ if let Some(res) = self.typed_generics.get(ident) {
return Some(res);
}
if let Some(parent) = self.parent {
/// Attempt to resolve a Path as a generic parameter and return the full path. as both a string
/// and syn::Path.
- pub fn maybe_resolve_path<'b>(&'b self, path: &syn::Path) -> Option<(&'b String, &'a syn::Path)> {
+ pub fn maybe_resolve_path<'b>(&'b self, path: &syn::Path) -> Option<&'b String> {
if let Some(ident) = path.get_ident() {
if let Some(ty) = &self.self_ty {
if format!("{}", ident) == "Self" {
- return Some((&ty.0, ty.1));
+ return Some(&ty);
}
}
- if let Some(res) = self.typed_generics.get(ident).map(|(a, b)| (a, b.unwrap())) {
+ if let Some(res) = self.typed_generics.get(ident) {
return Some(res);
}
} else {
let mut it = path.segments.iter();
if path.segments.len() == 2 && format!("{}", it.next().unwrap().ident) == "Self" {
let ident = &it.next().unwrap().ident;
- if let Some(res) = self.typed_generics.get(ident).map(|(a, b)| (a, b.unwrap())) {
+ if let Some(res) = self.typed_generics.get(ident) {
return Some(res);
}
}
} else { None }
}
- pub fn maybe_resolve_path(&self, p_arg: &syn::Path, generics: Option<&GenericTypes>) -> Option<String> {
- let p = if let Some(gen_types) = generics {
- if let Some((_, synpath)) = gen_types.maybe_resolve_path(p_arg) {
- synpath
- } else { p_arg }
- } else { p_arg };
+ pub fn maybe_resolve_path(&self, p: &syn::Path, generics: Option<&GenericTypes>) -> Option<String> {
+ if let Some(gen_types) = generics {
+ if let Some(resp) = gen_types.maybe_resolve_path(p) {
+ return Some(resp.clone());
+ }
+ }
if p.leading_colon.is_some() {
let mut res: String = p.segments.iter().enumerate().map(|(idx, seg)| {
enum EmptyValExpectedTy {
/// A type which has a flag for being empty (eg an array where we treat all-0s as empty).
NonPointer,
- /// A pointer that we want to dereference and move out of.
- OwnedPointer,
+ /// A Option mapped as a COption_*Z
+ OptionType,
/// A pointer which we want to convert to a reference.
ReferenceAsPointer,
}
return Some(full_path);
}
match full_path {
- "Result" => Some("crate::c_types::derived::CResult"),
- "Vec" if !is_ref => Some("crate::c_types::derived::CVec"),
- "Option" => Some(""),
-
// Note that no !is_ref types can map to an array because Rust and C's call semantics
// for arrays are different (https://github.com/eqrion/cbindgen/issues/528)
"std::time::SystemTime" => Some("u64"),
"std::io::Error" => Some("crate::c_types::IOError"),
+ "core::convert::Infallible" => Some("crate::c_types::NotConstructable"),
+
"bech32::u5" => Some("crate::c_types::u5"),
"core::num::NonZeroU8" => Some("u8"),
"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"),
- "bitcoin::blockdata::transaction::Transaction" => Some("crate::c_types::Transaction"),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some("crate::c_types::Transaction"),
"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some("crate::c_types::TxOut"),
"bitcoin::network::constants::Network" => Some("crate::bitcoin::network::Network"),
"bitcoin::blockdata::block::BlockHeader" if is_ref => Some("*const [u8; 80]"),
// Override the default since Records contain an fmt with a lifetime:
"lightning::util::logger::Record" => Some("*const std::os::raw::c_char"),
+ "lightning::io::Read" => Some("crate::c_types::u8slice"),
+
_ => None,
}
}
// Note that we'll panic for String if is_ref, as we only have non-owned memory, we
// cannot create a &String.
+ "core::convert::Infallible" => Some("panic!(\"You must never construct a NotConstructable! : "),
+
"std::time::Duration"|"core::time::Duration" => Some("std::time::Duration::from_secs("),
"std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("),
if !is_ref => Some(""),
"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" if is_ref => Some("&"),
- "bitcoin::blockdata::transaction::Transaction" => Some(""),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" if is_ref => Some("&"),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(""),
+ "bitcoin::blockdata::transaction::OutPoint" => Some("crate::c_types::C_to_bitcoin_outpoint("),
"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some(""),
"bitcoin::network::constants::Network" => Some(""),
"bitcoin::blockdata::block::BlockHeader" => Some("&::bitcoin::consensus::encode::deserialize(unsafe { &*"),
// List of traits we map (possibly during processing of other files):
"crate::util::logger::Logger" => Some(""),
+ "lightning::io::Read" => Some("&mut "),
+
_ => None,
}.map(|s| s.to_owned())
}
"alloc::string::String"|"String" => Some(".into_string()"),
"std::io::Error" if !is_ref => Some(".to_rust()"),
+ "core::convert::Infallible" => Some("\")"),
+
"std::time::Duration"|"core::time::Duration" => Some(")"),
"std::time::SystemTime" => Some("))"),
if is_ref => Some("}[..]).unwrap()"),
"bitcoin::blockdata::script::Script" if is_ref => Some(".to_slice()))"),
"bitcoin::blockdata::script::Script" if !is_ref => Some(".into_rust())"),
- "bitcoin::blockdata::transaction::Transaction" => Some(".into_bitcoin()"),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(".into_bitcoin()"),
+ "bitcoin::blockdata::transaction::OutPoint" => Some(")"),
"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some(".into_rust()"),
"bitcoin::network::constants::Network" => Some(".into_bitcoin()"),
"bitcoin::blockdata::block::BlockHeader" => Some(" }).unwrap()"),
// List of traits we map (possibly during processing of other files):
"crate::util::logger::Logger" => Some(""),
+ "lightning::io::Read" => Some(".to_reader()"),
+
_ => None,
}.map(|s| s.to_owned())
}
"std::time::SystemTime" => Some(""),
"std::io::Error" if !is_ref => Some("crate::c_types::IOError::from_rust("),
+ "core::convert::Infallible" => Some("panic!(\"Cannot construct an Infallible: "),
+
"bech32::u5" => Some(""),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
if !is_ref => Some("crate::c_types::Secp256k1Error::from_rust("),
"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" if is_ref => Some("crate::c_types::Transaction::from_bitcoin("),
- "bitcoin::blockdata::transaction::Transaction" => Some("crate::c_types::Transaction::from_bitcoin(&"),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" if is_ref => Some("crate::c_types::Transaction::from_bitcoin("),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some("crate::c_types::Transaction::from_bitcoin(&"),
"bitcoin::blockdata::transaction::OutPoint" => Some("crate::c_types::bitcoin_to_C_outpoint("),
"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some("crate::c_types::TxOut::from_rust("),
"bitcoin::network::constants::Network" => Some("crate::bitcoin::network::Network::from_bitcoin("),
// Override the default since Records contain an fmt with a lifetime:
"lightning::util::logger::Record" => Some("local_"),
+ "lightning::io::Read" => Some("crate::c_types::u8slice::from_vec(&crate::c_types::reader_to_vec("),
+
_ => None,
}.map(|s| s.to_owned())
}
"std::time::SystemTime" => Some(".duration_since(::std::time::SystemTime::UNIX_EPOCH).expect(\"Times must be post-1970\").as_secs()"),
"std::io::Error" if !is_ref => Some(")"),
+ "core::convert::Infallible" => Some("\")"),
+
"bech32::u5" => Some(".into()"),
"bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey"
if !is_ref => Some(")"),
"bitcoin::blockdata::script::Script" if is_ref => Some("[..])"),
"bitcoin::blockdata::script::Script" if !is_ref => Some(".into_bytes().into()"),
- "bitcoin::blockdata::transaction::Transaction" => Some(")"),
+ "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(")"),
"bitcoin::blockdata::transaction::OutPoint" => Some(")"),
"bitcoin::blockdata::transaction::TxOut" if !is_ref => Some(")"),
"bitcoin::network::constants::Network" => Some(")"),
// Override the default since Records contain an fmt with a lifetime:
"lightning::util::logger::Record" => Some(".as_ptr()"),
+ "lightning::io::Read" => Some("))"),
+
_ => None,
}.map(|s| s.to_owned())
}
}
}
+ /// When printing a reference to the source crate's rust type, if we need to map it to a
+ /// different "real" type, it can be done so here.
+ /// This is useful to work around limitations in the binding type resolver, where we reference
+ /// a non-public `use` alias.
+ /// TODO: We should never need to use this!
+ fn real_rust_type_mapping<'equiv>(&self, thing: &'equiv str) -> &'equiv str {
+ match thing {
+ "lightning::io::Read" => "std::io::Read",
+ _ => thing,
+ }
+ }
+
// ****************************
// *** Container Processing ***
// ****************************
/// Returns true if the path containing the given args is a "transparent" container, ie an
/// Option or a container which does not require a generated continer class.
- fn is_transparent_container<'i, I: Iterator<Item=&'i syn::Type>>(&self, full_path: &str, _is_ref: bool, mut args: I) -> bool {
+ fn is_transparent_container<'i, I: Iterator<Item=&'i syn::Type>>(&self, full_path: &str, _is_ref: bool, mut args: I, generics: Option<&GenericTypes>) -> bool {
if full_path == "Option" {
let inner = args.next().unwrap();
assert!(args.next().is_none());
match inner {
syn::Type::Reference(_) => true,
syn::Type::Path(p) => {
- if let Some(resolved) = self.maybe_resolve_path(&p.path, None) {
- if self.is_primitive(&resolved) { false } else { true }
+ 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 }
} else { true }
},
syn::Type::Tuple(_) => false,
}),
syn::PathArguments::Parenthesized(_) => unimplemented!(),
};
- self.is_transparent_container(&self.resolve_path(full_path, generics), is_ref, inner_iter)
+ self.is_transparent_container(&self.resolve_path(full_path, generics), is_ref, inner_iter, generics)
}
/// Returns true if this is a known, supported, non-transparent container.
fn is_known_container(&self, full_path: &str, is_ref: bool) -> bool {
} else { None }
} else { None };
if let Some(inner_path) = contained_struct {
- if self.is_primitive(&inner_path) {
- return Some(("if ", vec![
- (format!(".is_none() {{ {}::COption_{}Z::None }} else {{ ", Self::generated_container_path(), inner_path),
- format!("{}::COption_{}Z::Some({}.unwrap())", Self::generated_container_path(), inner_path, var_access))
- ], " }", ContainerPrefixLocation::NoPrefix));
- } else if self.c_type_has_inner_from_path(&inner_path) {
+ if self.c_type_has_inner_from_path(&inner_path) {
let is_inner_ref = if let Some(syn::Type::Reference(_)) = single_contained { true } else { false };
if is_ref {
return Some(("if ", vec![
(".is_none() { std::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() {
+ 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!("{}.unwrap()", var_access))
+ ], ") }", ContainerPrefixLocation::PerConv));
+ } else {
+ // If c_type_from_path is some (ie there's a manual mapping for the inner
+ // type), lean on write_empty_rust_val, below.
}
}
if let Some(t) = single_contained {
return Some(("if ", vec![
(format!("{} {{ None }} else {{ Some(", s), format!("unsafe {{ &mut *{} }}", var_access))
], ") }", ContainerPrefixLocation::NoPrefix)),
- EmptyValExpectedTy::OwnedPointer => {
- if let syn::Type::Slice(_) = t {
- panic!();
- }
- return Some(("if ", vec![
- (format!("{} {{ None }} else {{ Some(", s), format!("unsafe {{ *Box::from_raw({}) }}", var_access))
- ], ") }", ContainerPrefixLocation::NoPrefix));
- }
+ EmptyValExpectedTy::OptionType =>
+ return Some(("{ /* ", vec![
+ (format!("*/ let {}_opt = {};", var_name, var_access),
+ format!("}} if {}_opt{} {{ None }} else {{ Some({{ {}_opt.take()", var_name, s, var_name))
+ ], ") } }", ContainerPrefixLocation::PerConv)),
EmptyValExpectedTy::NonPointer =>
return Some(("if ", vec
projects / ldk-c-bindings / blobdiff