/// 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)| {
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]"),
// 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(""),
"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()"),
"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("),
"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(")"),
}
}
+ /// 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 ***
// ****************************
], " }", ContainerPrefixLocation::OutsideConv));
}
} else if self.is_primitive(&inner_path) || self.c_type_from_path(&inner_path, false, false).is_none() {
- let inner_name = inner_path.rsplit("::").next().unwrap();
+ let inner_name = self.get_c_mangled_container_type(vec![single_contained.unwrap()], generics, "Option").unwrap();
return Some(("if ", vec![
- (format!(".is_none() {{ {}::COption_{}Z::None }} else {{ {}::COption_{}Z::Some(",
- Self::generated_container_path(), inner_name, Self::generated_container_path(), inner_name),
+ (format!(".is_none() {{ {}::None }} else {{ {}::Some(",
+ inner_name, inner_name),
format!("{}.unwrap()", var_access))
], ") }", ContainerPrefixLocation::PerConv));
} else {
// If we're printing a generic argument, it needs to reference the crate, otherwise
// the original crate:
} else if self.maybe_resolve_path(&path, None).as_ref() == Some(&resolved) {
- write!(w, "{}", resolved).unwrap();
+ write!(w, "{}", self.real_rust_type_mapping(&resolved)).unwrap();
} else {
write!(w, "crate::{}", resolved).unwrap();
}
projects / ldk-c-bindings / blobdiff