X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=7132918f19bb44c293bf6cc22c8c81b232fd0a49;hp=aebeb487ece66605a3770677b9d386041bc29a13;hb=bcf07b1fad32d14e92c9c30976aa66b72a3860b0;hpb=18ac1ea0225fcf9d2073c1f7a03b13945572695d diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index aebeb48..7132918 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -65,6 +65,17 @@ pub fn path_matches_nongeneric(p: &syn::Path, exp: &[&str]) -> bool { true } +pub fn string_path_to_syn_path(path: &str) -> syn::Path { + let mut segments = syn::punctuated::Punctuated::new(); + for seg in path.split("::") { + segments.push(syn::PathSegment { + ident: syn::Ident::new(seg, Span::call_site()), + arguments: syn::PathArguments::None, + }); + } + syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments } +} + #[derive(Debug, PartialEq)] pub enum ExportStatus { Export, @@ -136,7 +147,7 @@ pub fn export_status(attrs: &[syn::Attribute]) -> ExportStatus { } 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!(); } } @@ -179,7 +190,7 @@ pub struct GenericTypes<'a, 'b> { self_ty: Option, parent: Option<&'b GenericTypes<'b, 'b>>, typed_generics: HashMap<&'a syn::Ident, String>, - default_generics: HashMap<&'a syn::Ident, (syn::Type, syn::Type)>, + default_generics: HashMap<&'a syn::Ident, (syn::Type, syn::Type, syn::Type)>, } impl<'a, 'p: 'a> GenericTypes<'a, 'p> { pub fn new(self_ty: Option) -> Self { @@ -194,10 +205,10 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { } /// 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; @@ -215,20 +226,25 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { if non_lifetimes_processed { return false; } non_lifetimes_processed = true; if path != "std::ops::Deref" && path != "core::ops::Deref" { + let p = string_path_to_syn_path(&path); + let ref_ty = parse_quote!(&#p); + let mut_ref_ty = parse_quote!(&mut #p); + self.default_generics.insert(&type_param.ident, (syn::Type::Path(syn::TypePath { qself: None, path: p }), ref_ty, mut_ref_ty)); new_typed_generics.insert(&type_param.ident, Some(path)); - } else if trait_bound.path.segments.len() == 1 { + } else { // If we're templated on Deref, store // the reference type in `default_generics` which handles full // types and not just paths. if let syn::PathArguments::AngleBracketed(ref args) = trait_bound.path.segments[0].arguments { + assert_eq!(trait_bound.path.segments.len(), 1); for subargument in args.args.iter() { match subargument { syn::GenericArgument::Lifetime(_) => {}, syn::GenericArgument::Binding(ref b) => { if &format!("{}", b.ident) != "Target" { return false; } let default = &b.ty; - self.default_generics.insert(&type_param.ident, (parse_quote!(&#default), parse_quote!(&#default))); + self.default_generics.insert(&type_param.ident, (parse_quote!(&#default), parse_quote!(&#default), parse_quote!(&mut #default))); break 'bound_loop; }, _ => unimplemented!(), @@ -243,7 +259,16 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { } 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))); + 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!(), + } + } } }, _ => {}, @@ -254,10 +279,12 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { 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(); - if let Some(gen) = new_typed_generics.get_mut(&p_iter.next().unwrap().ident) { + let p_ident = &p_iter.next().unwrap().ident; + if let Some(gen) = new_typed_generics.get_mut(p_ident) { if gen.is_some() { return false; } if &format!("{}", p_iter.next().unwrap().ident) != "Target" {return false; } @@ -270,7 +297,19 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { if non_lifetimes_processed { return false; } non_lifetimes_processed = true; assert_simple_bound(&trait_bound); - *gen = Some(types.resolve_path(&trait_bound.path, None)); + let resolved = types.resolve_path(&trait_bound.path, None); + let ty = syn::Type::Path(syn::TypePath { + qself: None, path: string_path_to_syn_path(&resolved) + }); + let ref_ty = parse_quote!(&#ty); + let mut_ref_ty = parse_quote!(&mut #ty); + if types.crate_types.traits.get(&resolved).is_some() { + self.default_generics.insert(p_ident, (ty, ref_ty, mut_ref_ty)); + } else { + self.default_generics.insert(p_ident, (ref_ty.clone(), ref_ty, mut_ref_ty)); + } + + *gen = Some(resolved); } } } else { return false; } @@ -286,6 +325,11 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { 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() { @@ -352,23 +396,27 @@ impl<'a, 'p: 'a> GenericTypes<'a, 'p> { } } -trait ResolveType<'a> { fn resolve_type(&'a self, ty: &'a syn::Type) -> &'a syn::Type; } +pub trait ResolveType<'a> { fn resolve_type(&'a self, ty: &'a syn::Type) -> &'a syn::Type; } impl<'a, 'b, 'c: 'a + 'b> ResolveType<'c> for Option<&GenericTypes<'a, 'b>> { fn resolve_type(&'c self, ty: &'c syn::Type) -> &'c syn::Type { if let Some(us) = self { match ty { syn::Type::Path(p) => { if let Some(ident) = p.path.get_ident() { - if let Some((ty, _)) = us.default_generics.get(ident) { - return ty; + if let Some((ty, _, _)) = us.default_generics.get(ident) { + return self.resolve_type(ty); } } }, - syn::Type::Reference(syn::TypeReference { elem, .. }) => { + syn::Type::Reference(syn::TypeReference { elem, mutability, .. }) => { if let syn::Type::Path(p) = &**elem { if let Some(ident) = p.path.get_ident() { - if let Some((_, refty)) = us.default_generics.get(ident) { - return refty; + if let Some((_, refty, mut_ref_ty)) = us.default_generics.get(ident) { + if mutability.is_some() { + return self.resolve_type(mut_ref_ty); + } else { + return self.resolve_type(refty); + } } } } @@ -391,17 +439,19 @@ pub enum DeclType<'a> { } pub struct ImportResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> { - crate_name: &'mod_lifetime str, - dependencies: &'mod_lifetime HashSet, + pub crate_name: &'mod_lifetime str, + library: &'crate_lft FullLibraryAST, module_path: &'mod_lifetime str, imports: HashMap, declared: HashMap>, priv_modules: HashSet, } impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'crate_lft> { - fn process_use_intern(crate_name: &str, module_path: &str, dependencies: &HashSet, imports: &mut HashMap, - u: &syn::UseTree, partial_path: &str, mut path: syn::punctuated::Punctuated) { - + fn walk_use_intern( + crate_name: &str, module_path: &str, dependencies: &HashSet, u: &syn::UseTree, + partial_path: &str, + mut path: syn::punctuated::Punctuated, handle_use: &mut F + ) { let new_path; macro_rules! push_path { ($ident: expr, $path_suffix: expr) => { @@ -427,6 +477,10 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr new_path = format!("{}::{}{}", crate_name, $ident, $path_suffix); let crate_name_ident = format_ident!("{}", crate_name); path.push(parse_quote!(#crate_name_ident)); + } else if format!("{}", $ident) == "self" { + let mut path_iter = partial_path.rsplitn(2, "::"); + path_iter.next().unwrap(); + new_path = path_iter.next().unwrap().to_owned(); } else { new_path = format!("{}{}{}", partial_path, $ident, $path_suffix); } @@ -437,20 +491,21 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr match u { syn::UseTree::Path(p) => { push_path!(p.ident, "::"); - Self::process_use_intern(crate_name, module_path, dependencies, imports, &p.tree, &new_path, path); + Self::walk_use_intern(crate_name, module_path, dependencies, &p.tree, &new_path, path, handle_use); }, syn::UseTree::Name(n) => { push_path!(n.ident, ""); - imports.insert(n.ident.clone(), (new_path, syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path })); + let imported_ident = syn::Ident::new(new_path.rsplitn(2, "::").next().unwrap(), Span::call_site()); + handle_use(imported_ident, (new_path, syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path })); }, syn::UseTree::Group(g) => { for i in g.items.iter() { - Self::process_use_intern(crate_name, module_path, dependencies, imports, i, partial_path, path.clone()); + Self::walk_use_intern(crate_name, module_path, dependencies, i, partial_path, path.clone(), handle_use); } }, syn::UseTree::Rename(r) => { push_path!(r.ident, ""); - imports.insert(r.rename.clone(), (new_path, syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path })); + handle_use(r.rename.clone(), (new_path, syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path })); }, syn::UseTree::Glob(_) => { eprintln!("Ignoring * use for {} - this may result in resolution failures", partial_path); @@ -458,12 +513,15 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } } + fn process_use_intern(crate_name: &str, module_path: &str, dependencies: &HashSet, + imports: &mut HashMap, u: &syn::UseTree, partial_path: &str, + path: syn::punctuated::Punctuated + ) { + Self::walk_use_intern(crate_name, module_path, dependencies, u, partial_path, path, + &mut |k, v| { imports.insert(k, v); }); + } + fn process_use(crate_name: &str, module_path: &str, dependencies: &HashSet, imports: &mut HashMap, u: &syn::ItemUse) { - if let syn::Visibility::Public(_) = u.vis { - // We actually only use these for #[cfg(fuzztarget)] - eprintln!("Ignoring pub(use) tree!"); - return; - } if u.leading_colon.is_some() { eprintln!("Ignoring leading-colon use!"); return; } Self::process_use_intern(crate_name, module_path, dependencies, imports, &u.tree, "", syn::punctuated::Punctuated::new()); } @@ -474,13 +532,14 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr imports.insert(ident, (id.to_owned(), path)); } - pub fn new(crate_name: &'mod_lifetime str, dependencies: &'mod_lifetime HashSet, module_path: &'mod_lifetime str, contents: &'crate_lft [syn::Item]) -> Self { - Self::from_borrowed_items(crate_name, dependencies, module_path, &contents.iter().map(|a| a).collect::>()) + pub fn new(crate_name: &'mod_lifetime str, library: &'crate_lft FullLibraryAST, module_path: &'mod_lifetime str, contents: &'crate_lft [syn::Item]) -> Self { + Self::from_borrowed_items(crate_name, library, module_path, &contents.iter().map(|a| a).collect::>()) } - pub fn from_borrowed_items(crate_name: &'mod_lifetime str, dependencies: &'mod_lifetime HashSet, module_path: &'mod_lifetime str, contents: &[&'crate_lft syn::Item]) -> Self { + pub fn from_borrowed_items(crate_name: &'mod_lifetime str, library: &'crate_lft FullLibraryAST, module_path: &'mod_lifetime str, contents: &[&'crate_lft syn::Item]) -> Self { let mut imports = HashMap::new(); // Add primitives to the "imports" list: Self::insert_primitive(&mut imports, "bool"); + Self::insert_primitive(&mut imports, "u128"); Self::insert_primitive(&mut imports, "u64"); Self::insert_primitive(&mut imports, "u32"); Self::insert_primitive(&mut imports, "u16"); @@ -500,7 +559,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr for item in contents.iter() { match item { - syn::Item::Use(u) => Self::process_use(crate_name, module_path, dependencies, &mut imports, &u), + syn::Item::Use(u) => Self::process_use(crate_name, module_path, &library.dependencies, &mut imports, &u), syn::Item::Struct(s) => { if let syn::Visibility::Public(_) = s.vis { match export_status(&s.attrs) { @@ -513,14 +572,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr }, syn::Item::Type(t) if export_status(&t.attrs) == ExportStatus::Export => { if let syn::Visibility::Public(_) = t.vis { - let mut process_alias = true; - for tok in t.generics.params.iter() { - if let syn::GenericParam::Lifetime(_) = tok {} - else { process_alias = false; } - } - if process_alias { - declared.insert(t.ident.clone(), DeclType::StructImported { generics: &t.generics }); - } + declared.insert(t.ident.clone(), DeclType::StructImported { generics: &t.generics }); } }, syn::Item::Enum(e) => { @@ -550,11 +602,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } } - Self { crate_name, dependencies, module_path, imports, declared, priv_modules } - } - - pub fn get_declared_type(&self, ident: &syn::Ident) -> Option<&DeclType<'crate_lft>> { - self.declared.get(ident) + Self { crate_name, library, module_path, imports, declared, priv_modules } } pub fn maybe_resolve_declared(&self, id: &syn::Ident) -> Option<&DeclType<'crate_lft>> { @@ -569,18 +617,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } else { None } } - pub fn maybe_resolve_non_ignored_ident(&self, id: &syn::Ident) -> Option { - if let Some((imp, _)) = self.imports.get(id) { - Some(imp.clone()) - } else if let Some(decl_type) = self.declared.get(id) { - match decl_type { - DeclType::StructIgnored => None, - _ => Some(self.module_path.to_string() + "::" + &format!("{}", id)), - } - } else { None } - } - - pub fn maybe_resolve_path(&self, p: &syn::Path, generics: Option<&GenericTypes>) -> Option { + fn maybe_resolve_imported_path(&self, p: &syn::Path, generics: Option<&GenericTypes>) -> Option { if let Some(gen_types) = generics { if let Some(resp) = gen_types.maybe_resolve_path(p) { return Some(resp.clone()); @@ -592,7 +629,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr format!("{}{}", if idx == 0 { "" } else { "::" }, seg.ident) }).collect(); let firstseg = p.segments.iter().next().unwrap(); - if !self.dependencies.contains(&firstseg.ident) { + if !self.library.dependencies.contains(&firstseg.ident) { res = self.crate_name.to_owned() + "::" + &res; } Some(res) @@ -617,12 +654,51 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } } else if let Some(_) = self.priv_modules.get(&first_seg.ident) { Some(format!("{}::{}{}", self.module_path, first_seg.ident, remaining)) - } else if first_seg_is_stdlib(&first_seg_str) || self.dependencies.contains(&first_seg.ident) { + } else if first_seg_is_stdlib(&first_seg_str) || self.library.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 } } } + pub fn maybe_resolve_path(&self, p: &syn::Path, generics: Option<&GenericTypes>) -> Option { + self.maybe_resolve_imported_path(p, generics).map(|mut path| { + loop { + // Now that we've resolved the path to the path as-imported, check whether the path + // is actually a pub(.*) use statement and map it to the real path. + let path_tmp = path.clone(); + let crate_name = path_tmp.splitn(1, "::").next().unwrap(); + let mut module_riter = path_tmp.rsplitn(2, "::"); + let obj = module_riter.next().unwrap(); + if let Some(module_path) = module_riter.next() { + if let Some(m) = self.library.modules.get(module_path) { + for item in m.items.iter() { + if let syn::Item::Use(syn::ItemUse { vis, tree, .. }) = item { + match vis { + syn::Visibility::Public(_)| + syn::Visibility::Crate(_)| + syn::Visibility::Restricted(_) => { + Self::walk_use_intern(crate_name, module_path, + &self.library.dependencies, tree, "", + syn::punctuated::Punctuated::new(), &mut |ident, (use_path, _)| { + if format!("{}", ident) == obj { + path = use_path; + } + }); + }, + syn::Visibility::Inherited => {}, + } + } + } + } + } + break; + } + path + }) + } + /// Map all the Paths in a Type into absolute paths given a set of imports (generated via process_use_intern) pub fn resolve_imported_refs(&self, mut ty: syn::Type) -> syn::Type { match &mut ty { @@ -689,6 +765,7 @@ impl FullLibraryAST { 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); @@ -721,15 +798,31 @@ impl FullLibraryAST { /// List of manually-generated types which are clonable fn initial_clonable_types() -> HashSet { let mut res = HashSet::new(); - res.insert("crate::c_types::u5".to_owned()); + res.insert("crate::c_types::U5".to_owned()); + res.insert("crate::c_types::U128".to_owned()); + res.insert("crate::c_types::FourBytes".to_owned()); + res.insert("crate::c_types::TwelveBytes".to_owned()); + res.insert("crate::c_types::SixteenBytes".to_owned()); + res.insert("crate::c_types::TwentyBytes".to_owned()); res.insert("crate::c_types::ThirtyTwoBytes".to_owned()); + res.insert("crate::c_types::SecretKey".to_owned()); res.insert("crate::c_types::PublicKey".to_owned()); res.insert("crate::c_types::Transaction".to_owned()); + res.insert("crate::c_types::Witness".to_owned()); res.insert("crate::c_types::TxOut".to_owned()); res.insert("crate::c_types::Signature".to_owned()); res.insert("crate::c_types::RecoverableSignature".to_owned()); + res.insert("crate::c_types::Bech32Error".to_owned()); res.insert("crate::c_types::Secp256k1Error".to_owned()); res.insert("crate::c_types::IOError".to_owned()); + res.insert("crate::c_types::Error".to_owned()); + res.insert("crate::c_types::Str".to_owned()); + + // Because some types are manually-mapped to CVec_u8Z we may end up checking if its clonable + // before we ever get to constructing the type fully via + // `write_c_mangled_container_path_intern` (which will add it here too), so we have to manually + // add it on startup. + res.insert("crate::c_types::derived::CVec_u8Z".to_owned()); res } @@ -738,6 +831,8 @@ pub struct CrateTypes<'a> { /// This may contain structs or enums, but only when either is mapped as /// struct X { inner: *mut originalX, .. } pub opaques: HashMap, + /// structs that weren't exposed + pub priv_structs: HashMap, /// Enums which are mapped as C enums with conversion functions pub mirrored_enums: HashMap, /// Traits which are mapped as a pointer + jump table @@ -745,7 +840,7 @@ pub struct CrateTypes<'a> { /// Aliases from paths to some other Type pub type_aliases: HashMap, /// Value is an alias to Key (maybe with some generics) - pub reverse_alias_map: HashMap>, + pub reverse_alias_map: HashMap>, /// Template continer types defined, map from mangled type name -> whether a destructor fn /// exists. /// @@ -767,7 +862,7 @@ impl<'a> CrateTypes<'a> { CrateTypes { opaques: HashMap::new(), mirrored_enums: HashMap::new(), traits: HashMap::new(), type_aliases: HashMap::new(), reverse_alias_map: HashMap::new(), - templates_defined: RefCell::new(HashMap::default()), + templates_defined: RefCell::new(HashMap::default()), priv_structs: HashMap::new(), clonable_types: RefCell::new(initial_clonable_types()), trait_impls: HashMap::new(), template_file: RefCell::new(template_file), lib_ast: &libast, } @@ -789,7 +884,7 @@ impl<'a> CrateTypes<'a> { pub struct TypeResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> { pub module_path: &'mod_lifetime str, pub crate_types: &'mod_lifetime CrateTypes<'crate_lft>, - types: ImportResolver<'mod_lifetime, 'crate_lft>, + pub types: ImportResolver<'mod_lifetime, 'crate_lft>, } /// Returned by write_empty_rust_val_check_suffix to indicate what type of dereferencing needs to @@ -835,7 +930,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { /// Returns true we if can just skip passing this to C entirely fn no_arg_path_to_rust(&self, full_path: &str) -> &str { if full_path == "bitcoin::secp256k1::Secp256k1" { - "secp256k1::SECP256K1" + "secp256k1::global::SECP256K1" } else { unimplemented!(); } } @@ -882,30 +977,40 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "std::time::Duration"|"core::time::Duration" => Some("u64"), "std::time::SystemTime" => Some("u64"), - "std::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::bech32::u5"|"bech32::u5" => Some("crate::c_types::u5"), - "core::num::NonZeroU8" => Some("u8"), - - "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey" - => Some("crate::c_types::PublicKey"), - "bitcoin::secp256k1::Signature" => Some("crate::c_types::Signature"), - "bitcoin::secp256k1::recovery::RecoverableSignature" => Some("crate::c_types::RecoverableSignature"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if is_ref => Some("*const [u8; 32]"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if !is_ref => Some("crate::c_types::SecretKey"), + "bitcoin::bech32::Error"|"bech32::Error" + if !is_ref => Some("crate::c_types::Bech32Error"), "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some("crate::c_types::Secp256k1Error"), + + "core::num::ParseIntError" => Some("crate::c_types::Error"), + "core::str::Utf8Error" => Some("crate::c_types::Error"), + + "bitcoin::bech32::u5"|"bech32::u5" => Some("crate::c_types::U5"), + "u128" => Some("crate::c_types::U128"), + "core::num::NonZeroU8" => Some("u8"), + + "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => Some("crate::c_types::PublicKey"), + "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::Signature"), + "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"), "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some("crate::c_types::Transaction"), + "bitcoin::Witness" => Some("crate::c_types::Witness"), "bitcoin::blockdata::transaction::TxOut" if !is_ref => Some("crate::c_types::TxOut"), "bitcoin::network::constants::Network" => Some("crate::bitcoin::network::Network"), + "bitcoin::util::address::WitnessVersion" => Some("crate::c_types::WitnessVersion"), "bitcoin::blockdata::block::BlockHeader" if is_ref => Some("*const [u8; 80]"), "bitcoin::blockdata::block::Block" if is_ref => Some("crate::c_types::u8slice"), @@ -959,36 +1064,45 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "str" if is_ref => Some(""), "alloc::string::String"|"String" => Some(""), - "std::io::Error" if !is_ref => 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. "core::convert::Infallible" => Some("panic!(\"You must never construct a NotConstructable! : "), + "bitcoin::bech32::Error"|"bech32::Error" if !is_ref => Some(""), + "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some(""), + + "core::num::ParseIntError" => Some("u8::from_str_radix(\" a\", 10).unwrap_err() /*"), + "core::str::Utf8Error" => Some("core::str::from_utf8(&[0xff]).unwrap_err() /*"), + "std::time::Duration"|"core::time::Duration" => Some("core::time::Duration::from_secs("), "std::time::SystemTime" => Some("(::std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs("), "bitcoin::bech32::u5"|"bech32::u5" => Some(""), + "u128" => Some(""), "core::num::NonZeroU8" => Some("core::num::NonZeroU8::new("), - "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey" - if is_ref => Some("&"), - "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey" - => Some(""), - "bitcoin::secp256k1::Signature" if is_ref => Some("&"), - "bitcoin::secp256k1::Signature" => Some(""), - "bitcoin::secp256k1::recovery::RecoverableSignature" => Some(""), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if is_ref => Some("&::bitcoin::secp256k1::key::SecretKey::from_slice(&unsafe { *"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if !is_ref => Some(""), + "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" if is_ref => Some("&"), + "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(""), + "bitcoin::secp256k1::ecdsa::Signature" if is_ref => Some("&"), + "bitcoin::secp256k1::ecdsa::Signature" => Some(""), + "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("&"), "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some(""), + "bitcoin::Witness" if is_ref => Some("&"), + "bitcoin::Witness" => 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::util::address::WitnessVersion" => Some(""), "bitcoin::blockdata::block::BlockHeader" => Some("&::bitcoin::consensus::encode::deserialize(unsafe { &*"), "bitcoin::blockdata::block::Block" if is_ref => Some("&::bitcoin::consensus::encode::deserialize("), @@ -1043,30 +1157,40 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "str" if is_ref => Some(".into_str()"), "alloc::string::String"|"String" => Some(".into_string()"), - "std::io::Error" if !is_ref => Some(".to_rust()"), + "std::io::Error"|"lightning::io::Error" => Some(".to_rust()"), + "lightning::io::ErrorKind" => Some(".to_rust_kind()"), "core::convert::Infallible" => Some("\")"), + "bitcoin::bech32::Error"|"bech32::Error" if !is_ref => Some(".into_rust()"), + "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some(".into_rust()"), + + "core::num::ParseIntError" => Some("*/"), + "core::str::Utf8Error" => Some("*/"), + "std::time::Duration"|"core::time::Duration" => Some(")"), "std::time::SystemTime" => Some("))"), "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"), + "u128" => Some(".into()"), "core::num::NonZeroU8" => Some(").expect(\"Value must be non-zero\")"), - "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey" - => Some(".into_rust()"), - "bitcoin::secp256k1::Signature" => Some(".into_rust()"), - "bitcoin::secp256k1::recovery::RecoverableSignature" => Some(".into_rust()"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if !is_ref => Some(".into_rust()"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if is_ref => Some("}[..]).unwrap()"), + "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(".into_rust()"), + "bitcoin::secp256k1::ecdsa::Signature" => Some(".into_rust()"), + "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()"), + "bitcoin::Witness" => 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::util::address::WitnessVersion" => Some(".into()"), "bitcoin::blockdata::block::BlockHeader" => Some(" }).unwrap()"), "bitcoin::blockdata::block::Block" => Some(".to_slice()).unwrap()"), @@ -1132,30 +1256,41 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "std::time::Duration"|"core::time::Duration" => Some(""), "std::time::SystemTime" => Some(""), - "std::io::Error" if !is_ref => Some("crate::c_types::IOError::from_rust("), + "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::bech32::u5"|"bech32::u5" => Some(""), - - "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey" - => Some("crate::c_types::PublicKey::from_rust(&"), - "bitcoin::secp256k1::Signature" => Some("crate::c_types::Signature::from_rust(&"), - "bitcoin::secp256k1::recovery::RecoverableSignature" => Some("crate::c_types::RecoverableSignature::from_rust(&"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if is_ref => Some(""), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if !is_ref => Some("crate::c_types::SecretKey::from_rust("), + "bitcoin::bech32::Error"|"bech32::Error" + if !is_ref => Some("crate::c_types::Bech32Error::from_rust("), "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some("crate::c_types::Secp256k1Error::from_rust("), + + "core::num::ParseIntError" => Some("crate::c_types::Error { _dummy: 0 } /*"), + "core::str::Utf8Error" => Some("crate::c_types::Error { _dummy: 0 } /*"), + + "bitcoin::bech32::u5"|"bech32::u5" => Some(""), + "u128" => Some(""), + + "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some("crate::c_types::PublicKey::from_rust(&"), + "bitcoin::secp256k1::ecdsa::Signature" => Some("crate::c_types::Signature::from_rust(&"), + "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("), "bitcoin::blockdata::transaction::Transaction"|"bitcoin::Transaction" => Some("crate::c_types::Transaction::from_bitcoin(&"), + "bitcoin::Witness" if is_ref => Some("crate::c_types::Witness::from_bitcoin("), + "bitcoin::Witness" if !is_ref => Some("crate::c_types::Witness::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("), + "bitcoin::util::address::WitnessVersion" => Some(""), "bitcoin::blockdata::block::BlockHeader" if is_ref => Some("&local_"), "bitcoin::blockdata::block::Block" if is_ref => Some("crate::c_types::u8slice::from_slice(&local_"), @@ -1205,29 +1340,38 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "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" if !is_ref => Some(")"), + "std::io::Error"|"lightning::io::Error"|"lightning::io::ErrorKind" => Some(")"), "core::fmt::Arguments" => Some(").into()"), "core::convert::Infallible" => Some("\")"), - "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"), - - "bitcoin::secp256k1::key::PublicKey"|"bitcoin::secp256k1::PublicKey"|"secp256k1::key::PublicKey" - => Some(")"), - "bitcoin::secp256k1::Signature" => Some(")"), - "bitcoin::secp256k1::recovery::RecoverableSignature" => Some(")"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" + "bitcoin::secp256k1::Error"|"bech32::Error" if !is_ref => Some(")"), - "bitcoin::secp256k1::key::SecretKey"|"bitcoin::secp256k1::SecretKey" - if is_ref => Some(".as_ref()"), "bitcoin::secp256k1::Error"|"secp256k1::Error" if !is_ref => Some(")"), + + "core::num::ParseIntError" => Some("*/"), + "core::str::Utf8Error" => Some("*/"), + + "bitcoin::bech32::u5"|"bech32::u5" => Some(".into()"), + "u128" => Some(".into()"), + + "bitcoin::secp256k1::PublicKey"|"secp256k1::PublicKey" => Some(")"), + "bitcoin::secp256k1::ecdsa::Signature" => 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(")"), + "bitcoin::Witness" => Some(")"), "bitcoin::blockdata::transaction::OutPoint" => Some(")"), "bitcoin::blockdata::transaction::TxOut" if !is_ref => Some(")"), "bitcoin::network::constants::Network" => Some(")"), + "bitcoin::util::address::WitnessVersion" => Some(".into()"), "bitcoin::blockdata::block::BlockHeader" if is_ref => Some(""), "bitcoin::blockdata::block::Block" if is_ref => Some(")"), @@ -1255,8 +1399,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { fn empty_val_check_suffix_from_path(&self, full_path: &str) -> Option<&str> { match full_path { "lightning::ln::PaymentSecret" => Some(".data == [0; 32]"), - "secp256k1::key::PublicKey"|"bitcoin::secp256k1::key::PublicKey" => Some(".is_null()"), - "bitcoin::secp256k1::Signature" => Some(".is_null()"), + "secp256k1::PublicKey"|"bitcoin::secp256k1::PublicKey" => Some(".is_null()"), + "bitcoin::secp256k1::ecdsa::Signature" => Some(".is_null()"), _ => None } } @@ -1288,20 +1432,33 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { "crate::c_types" } + /// This should just be a closure, but doing so gets an error like + /// error: reached the recursion limit while instantiating `types::TypeResolver::is_transpar...c/types.rs:1358:104: 1358:110]>>` + /// which implies the concrete function instantiation of `is_transparent_container` ends up + /// being recursive. + fn deref_type<'one, 'b: 'one> (obj: &'one &'b syn::Type) -> &'b syn::Type { *obj } + /// 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>(&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, + match generics.resolve_type(inner) { + syn::Type::Reference(r) => { + let elem = &*r.elem; + match elem { + syn::Type::Path(_) => + self.is_transparent_container(full_path, true, [elem].iter().map(Self::deref_type), generics), + _ => true, + } + }, syn::Type::Array(a) => { if let syn::Expr::Lit(l) = &a.len { if let syn::Lit::Int(i) = &l.lit { if i.base10_digits().parse::().unwrap() >= 32 { let mut buf = Vec::new(); - self.write_rust_type(&mut buf, generics, &a.elem); + self.write_rust_type(&mut buf, generics, &a.elem, false); let ty = String::from_utf8(buf).unwrap(); ty == "u8" } else { @@ -1316,8 +1473,20 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { 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 } + // 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, _ => unimplemented!(), @@ -1368,14 +1537,17 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } }, "Option" => { + let mut is_contained_ref = false; let contained_struct = if let Some(syn::Type::Path(p)) = single_contained { Some(self.resolve_path(&p.path, generics)) } else if let Some(syn::Type::Reference(r)) = single_contained { + is_contained_ref = true; if let syn::Type::Path(p) = &*r.elem { Some(self.resolve_path(&p.path, generics)) } else { None } } else { None }; if let Some(inner_path) = contained_struct { + let only_contained_has_inner = 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 { @@ -1388,13 +1560,20 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { (".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() { - 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 !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![ + (format!(".is_none() {{ {}::None }} else {{ {}::Some(", inner_name, inner_name), + format!("{}.unwrap()", var_access)) + ], ") }", ContainerPrefixLocation::PerConv)); + } else { + 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(/* WARNING: CLONING CONVERSION HERE! &Option is otherwise un-expressable. */", inner_name, inner_name), + format!("{}.clone().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. @@ -1402,12 +1581,18 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } 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 { @@ -1435,6 +1620,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // Returns prefix + Vec<(prefix, var-name-to-inline-convert)> + suffix // expecting one element in the vec per generic type, each of which is inline-converted -> Option<(&'b str, Vec<(String, String)>, &'b str, ContainerPrefixLocation)> { + let mut only_contained_has_inner = false; + let only_contained_resolved = if let Some(syn::Type::Path(p)) = single_contained { + let res = self.resolve_path(&p.path, generics); + only_contained_has_inner = self.c_type_has_inner_from_path(&res); + Some(res) + } else { None }; match full_path { "Result" if !is_ref => { Some(("match ", @@ -1442,18 +1633,17 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { ("), false => Err(".to_string(), format!("(*unsafe {{ Box::from_raw(<*mut _>::take_ptr(&mut {}.contents.err)) }})", var_access))], ")}", ContainerPrefixLocation::PerConv)) }, - "Slice" if is_ref => { + "Slice" if is_ref && only_contained_has_inner => { Some(("Vec::new(); for mut item in ", vec![(format!(".as_slice().iter() {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv)) }, "Vec"|"Slice" => { Some(("Vec::new(); for mut item in ", vec![(format!(".into_rust().drain(..) {{ local_{}.push(", var_name), "item".to_string())], "); }", ContainerPrefixLocation::PerConv)) }, "Option" => { - if let Some(syn::Type::Path(p)) = single_contained { - let inner_path = self.resolve_path(&p.path, generics); - if self.is_primitive(&inner_path) { + if let Some(resolved) = only_contained_resolved { + if self.is_primitive(&resolved) { return Some(("if ", vec![(".is_some() { Some(".to_string(), format!("{}.take()", var_access))], ") } else { None }", ContainerPrefixLocation::NoPrefix)) - } else if self.c_type_has_inner_from_path(&inner_path) { + } else if only_contained_has_inner { if is_ref { return Some(("if ", vec![(".inner.is_null() { None } else { Some((*".to_string(), format!("{}", var_access))], ").clone()) }", ContainerPrefixLocation::PerConv)) } else { @@ -1464,7 +1654,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if let Some(t) = single_contained { match t { - syn::Type::Reference(_)|syn::Type::Path(_)|syn::Type::Slice(_) => { + syn::Type::Reference(_)|syn::Type::Path(_)|syn::Type::Slice(_)|syn::Type::Array(_) => { let mut v = Vec::new(); let ret_ref = self.write_empty_rust_val_check_suffix(generics, &mut v, t); let s = String::from_utf8(v).unwrap(); @@ -1542,9 +1732,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // *** Type definition during main.rs processing *** // ************************************************* - pub fn get_declared_type(&'a self, ident: &syn::Ident) -> Option<&'a DeclType<'c>> { - self.types.get_declared_type(ident) - } /// Returns true if the object at the given path is mapped as X { inner: *mut origX, .. }. pub fn c_type_has_inner_from_path(&self, full_path: &str) -> bool { self.crate_types.opaques.get(full_path).is_some() @@ -1569,10 +1756,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { self.types.maybe_resolve_ident(id) } - pub fn maybe_resolve_non_ignored_ident(&self, id: &syn::Ident) -> Option { - self.types.maybe_resolve_non_ignored_ident(id) - } - pub fn maybe_resolve_path(&self, p_arg: &syn::Path, generics: Option<&GenericTypes>) -> Option { self.types.maybe_resolve_path(p_arg, generics) } @@ -1593,7 +1776,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } } - fn write_rust_path(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, path: &syn::Path) { + fn write_rust_path(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, path: &syn::Path, with_ref_lifetime: bool, generated_crate_ref: bool) { if let Some(resolved) = self.maybe_resolve_path(&path, generics_resolver) { if self.is_primitive(&resolved) { write!(w, "{}", path.get_ident().unwrap()).unwrap(); @@ -1602,16 +1785,16 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // checking for "bitcoin" explicitly. if resolved.starts_with("bitcoin::") || Self::in_rust_prelude(&resolved) { write!(w, "{}", resolved).unwrap(); - // 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) { + } else if !generated_crate_ref { + // If we're printing a generic argument, it needs to reference the crate, otherwise + // the original crate. write!(w, "{}", self.real_rust_type_mapping(&resolved)).unwrap(); } else { write!(w, "crate::{}", resolved).unwrap(); } } if let syn::PathArguments::AngleBracketed(args) = &path.segments.iter().last().unwrap().arguments { - self.write_rust_generic_arg(w, generics_resolver, args.args.iter()); + self.write_rust_generic_arg(w, generics_resolver, args.args.iter(), with_ref_lifetime); } } else { if path.leading_colon.is_some() { @@ -1621,7 +1804,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if idx != 0 { write!(w, "::").unwrap(); } write!(w, "{}", seg.ident).unwrap(); if let syn::PathArguments::AngleBracketed(args) = &seg.arguments { - self.write_rust_generic_arg(w, generics_resolver, args.args.iter()); + self.write_rust_generic_arg(w, generics_resolver, args.args.iter(), with_ref_lifetime); } } } @@ -1641,7 +1824,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { match bound { syn::TypeParamBound::Trait(tb) => { if tb.paren_token.is_some() || tb.lifetimes.is_some() { unimplemented!(); } - self.write_rust_path(w, generics_resolver, &tb.path); + self.write_rust_path(w, generics_resolver, &tb.path, false, false); }, _ => unimplemented!(), } @@ -1654,38 +1837,46 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if had_params { write!(w, ">").unwrap(); } } - pub fn write_rust_generic_arg<'b, W: std::io::Write>(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, generics: impl Iterator) { + pub fn write_rust_generic_arg<'b, W: std::io::Write>(&self, w: &mut W, generics_resolver: Option<&GenericTypes>, generics: impl Iterator, with_ref_lifetime: bool) { write!(w, "<").unwrap(); for (idx, arg) in generics.enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } match arg { - syn::GenericArgument::Type(t) => self.write_rust_type(w, generics_resolver, t), + syn::GenericArgument::Type(t) => self.write_rust_type(w, generics_resolver, t, with_ref_lifetime), _ => unimplemented!(), } } write!(w, ">").unwrap(); } - pub fn write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type) { - match t { + fn do_write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type, with_ref_lifetime: bool, force_crate_ref: bool) { + let real_ty = generics.resolve_type(t); + let mut generate_crate_ref = force_crate_ref || t != real_ty; + match real_ty { syn::Type::Path(p) => { if p.qself.is_some() { unimplemented!(); } - self.write_rust_path(w, generics, &p.path); + if let Some(resolved_ty) = self.maybe_resolve_path(&p.path, generics) { + generate_crate_ref |= self.maybe_resolve_path(&p.path, None).as_ref() != Some(&resolved_ty); + if self.crate_types.traits.get(&resolved_ty).is_none() { generate_crate_ref = false; } + } + self.write_rust_path(w, generics, &p.path, with_ref_lifetime, generate_crate_ref); }, syn::Type::Reference(r) => { write!(w, "&").unwrap(); if let Some(lft) = &r.lifetime { write!(w, "'{} ", lft.ident).unwrap(); + } else if with_ref_lifetime { + write!(w, "'static ").unwrap(); } if r.mutability.is_some() { write!(w, "mut ").unwrap(); } - self.write_rust_type(w, generics, &*r.elem); + self.do_write_rust_type(w, generics, &*r.elem, with_ref_lifetime, generate_crate_ref); }, syn::Type::Array(a) => { write!(w, "[").unwrap(); - self.write_rust_type(w, generics, &a.elem); + self.do_write_rust_type(w, generics, &a.elem, with_ref_lifetime, generate_crate_ref); if let syn::Expr::Lit(l) = &a.len { if let syn::Lit::Int(i) = &l.lit { write!(w, "; {}]", i).unwrap(); @@ -1694,20 +1885,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } syn::Type::Slice(s) => { write!(w, "[").unwrap(); - self.write_rust_type(w, generics, &s.elem); + self.do_write_rust_type(w, generics, &s.elem, with_ref_lifetime, generate_crate_ref); write!(w, "]").unwrap(); }, syn::Type::Tuple(s) => { write!(w, "(").unwrap(); for (idx, t) in s.elems.iter().enumerate() { if idx != 0 { write!(w, ", ").unwrap(); } - self.write_rust_type(w, generics, &t); + self.do_write_rust_type(w, generics, &t, with_ref_lifetime, generate_crate_ref); } write!(w, ")").unwrap(); }, _ => unimplemented!(), } } + pub fn write_rust_type(&self, w: &mut W, generics: Option<&GenericTypes>, t: &syn::Type, with_ref_lifetime: bool) { + self.do_write_rust_type(w, generics, t, with_ref_lifetime, false); + } + /// Prints a constructor for something which is "uninitialized" (but obviously not actually /// unint'd memory). @@ -1767,7 +1962,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { syn::Type::Path(p) => { let resolved = self.resolve_path(&p.path, generics); if let Some(arr_ty) = self.is_real_type_array(&resolved) { - write!(w, ".data").unwrap(); return self.write_empty_rust_val_check_suffix(generics, w, &arr_ty); } if self.crate_types.opaques.get(&resolved).is_some() { @@ -1787,7 +1981,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { syn::Type::Array(a) => { if let syn::Expr::Lit(l) = &a.len { if let syn::Lit::Int(i) = &l.lit { - write!(w, " == [0; {}]", i.base10_digits()).unwrap(); + write!(w, ".data == [0; {}]", i.base10_digits()).unwrap(); EmptyValExpectedTy::NonPointer } else { unimplemented!(); } } else { unimplemented!(); } @@ -1955,6 +2149,8 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { 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) => { @@ -2118,7 +2314,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // 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 @@ -2128,12 +2324,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } 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 @@ -2157,14 +2355,14 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // 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); } } - if let Some((prefix, conversions, suffix, prefix_location)) = container_lookup(&$container_type, is_ref && ty_has_inner, only_contained_type, ident, var) { + if let Some((prefix, conversions, suffix, prefix_location)) = container_lookup(&$container_type, is_ref, only_contained_type, ident, var) { assert_eq!(conversions.len(), $args_len); write!(w, "let mut local_{}{} = ", ident, if (!to_c && needs_ref_map) || (to_c && $container_type == "Option" && contains_slice) {"_base"} else { "" }).unwrap(); @@ -2305,6 +2503,12 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { 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) => { @@ -2336,6 +2540,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } write!(w, "let mut local_{} = (", ident).unwrap(); for (idx, elem) in t.elems.iter().enumerate() { + let real_elem = generics.resolve_type(&elem); let ty_has_inner = { if to_c { // "To C ptr_for_ref" means "return the regular object with @@ -2343,16 +2548,16 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // if we're about to set ty_has_inner. ptr_for_ref = true; } - if let syn::Type::Reference(t) = elem { + if let syn::Type::Reference(t) = real_elem { if let syn::Type::Path(p) = &*t.elem { self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)) } else { false } - } else if let syn::Type::Path(p) = elem { + } else if let syn::Type::Path(p) = real_elem { self.c_type_has_inner_from_path(&self.resolve_path(&p.path, generics)) } else { false } }; if idx != 0 { write!(w, ", ").unwrap(); } - var_prefix(w, elem, generics, is_ref && ty_has_inner, ptr_for_ref, false); + var_prefix(w, real_elem, generics, is_ref && ty_has_inner, ptr_for_ref, false); if is_ref && ty_has_inner { // For ty_has_inner, the regular var_prefix mapping will take a // reference, so deref once here to make sure we keep the original ref. @@ -2364,7 +2569,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // hope the type is Clonable and use that. write!(w, ".clone()").unwrap(); } - var_suffix(w, elem, generics, is_ref && ty_has_inner, ptr_for_ref, false); + var_suffix(w, real_elem, generics, is_ref && ty_has_inner, ptr_for_ref, false); } write!(w, "){};", if to_c { ".into()" } else { "" }).unwrap(); true @@ -2375,7 +2580,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } pub fn write_to_c_conversion_new_var_inner(&self, w: &mut W, ident: &syn::Ident, var_access: &str, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool, from_ownable_ref: bool) -> bool { - self.write_conversion_new_var_intern(w, ident, var_access, t, generics, false, ptr_for_ref, true, from_ownable_ref, + self.write_conversion_new_var_intern(w, ident, var_access, t, generics, from_ownable_ref, ptr_for_ref, true, from_ownable_ref, &|a, b| self.to_c_conversion_new_var_from_path(a, b), &|a, b, c, d, e| self.to_c_conversion_container_new_var(generics, a, b, c, d, e), // We force ptr_for_ref here since we can't generate a ref on one line and use it later @@ -2404,14 +2609,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // ****************************************************** fn write_template_generics<'b, W: std::io::Write>(&self, w: &mut W, args: &mut dyn Iterator, 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 !self.write_c_type_intern(w, &*r_arg.elem, generics, false, false, false, false) { return false; } + if !self.write_c_type_intern(w, &*r_arg.elem, generics, false, false, false, true, true) { return false; } // While write_c_type_intern, above is correct, we don't want to blindly convert a // reference to something stupid, so check that the container is either opaque or a @@ -2419,6 +2625,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { 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 { @@ -2429,7 +2636,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } else { assert!(!is_ref); // We don't currently support outer reference types for non-primitive inners } - if !self.write_c_type_intern(w, t, generics, false, false, false, false) { return false; } + if !self.write_c_type_intern(w, t, generics, false, false, false, true, true) { return false; } } else { // We don't currently support outer reference types for non-primitive inners, // except for the empty tuple. @@ -2438,7 +2645,7 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } else { assert!(!is_ref); } - if !self.write_c_type_intern(w, t, generics, false, false, false, false) { return false; } + if !self.write_c_type_intern(w, t, generics, false, false, false, true, true) { return false; } } } true @@ -2537,13 +2744,13 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { if self.is_transparent_container(ident, is_ref, args.iter().map(|a| *a), generics) { if !in_type { if self.c_type_has_inner_from_path(&subtype) { - if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref, false) { return false; } + if !self.write_c_path_intern(w, &$p_arg.path, generics, is_ref, is_mut, ptr_for_ref, false, true) { return false; } } else { if let Some(arr_ty) = self.is_real_type_array(&subtype) { - if !self.write_c_type_intern(w, &arr_ty, generics, false, true, false, false) { return false; } + if !self.write_c_type_intern(w, &arr_ty, generics, false, true, false, false, true) { return false; } } else { // Option needs to be converted to a *mut T, ie mut ptr-for-ref - if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true, false) { return false; } + if !self.write_c_path_intern(w, &$p_arg.path, generics, true, true, true, false, true) { return false; } } } } else { @@ -2667,13 +2874,16 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // *** C Type Equivalent Printing *** // ********************************** - fn write_c_path_intern(&self, w: &mut W, path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool) -> bool { + fn write_c_path_intern(&self, w: &mut W, path: &syn::Path, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool, c_ty: bool) -> bool { let full_path = match self.maybe_resolve_path(&path, generics) { Some(path) => path, None => return false }; if let Some(c_type) = self.c_type_from_path(&full_path, is_ref, ptr_for_ref) { write!(w, "{}", c_type).unwrap(); true } else if self.crate_types.traits.get(&full_path).is_some() { + // Note that we always use the crate:: prefix here as we are always referring to a + // concrete object which is of the generated type, it just implements the upstream + // type. if is_ref && ptr_for_ref { write!(w, "*{} crate::{}", if is_mut { "mut" } else { "const" }, full_path).unwrap(); } else if is_ref { @@ -2684,29 +2894,35 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } true } else if self.crate_types.opaques.get(&full_path).is_some() || self.crate_types.mirrored_enums.get(&full_path).is_some() { + let crate_pfx = if c_ty { "crate::" } else { "" }; if is_ref && ptr_for_ref { // ptr_for_ref implies we're returning the object, which we can't really do for // opaque or mirrored types without box'ing them, which is quite a waste, so return // the actual object itself (for opaque types we'll set the pointer to the actual // type and note that its a reference). - write!(w, "crate::{}", full_path).unwrap(); + write!(w, "{}{}", crate_pfx, full_path).unwrap(); } else if is_ref && with_ref_lifetime { assert!(!is_mut); // If we're concretizing something with a lifetime parameter, we have to pick a // lifetime, of which the only real available choice is `static`, obviously. - write!(w, "&'static ").unwrap(); - self.write_rust_path(w, generics, path); + write!(w, "&'static {}", crate_pfx).unwrap(); + if !c_ty { + self.write_rust_path(w, generics, path, with_ref_lifetime, false); + } else { + // We shouldn't be mapping references in types, so panic here + unimplemented!(); + } } else if is_ref { - write!(w, "&{}crate::{}", if is_mut { "mut " } else { "" }, full_path).unwrap(); + write!(w, "&{}{}{}", if is_mut { "mut " } else { "" }, crate_pfx, full_path).unwrap(); } else { - write!(w, "crate::{}", full_path).unwrap(); + write!(w, "{}{}", crate_pfx, full_path).unwrap(); } true } else { false } } - fn write_c_type_intern(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool) -> bool { + fn write_c_type_intern(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, is_ref: bool, is_mut: bool, ptr_for_ref: bool, with_ref_lifetime: bool, c_ty: bool) -> bool { match generics.resolve_type(t) { syn::Type::Path(p) => { if p.qself.is_some() { @@ -2717,24 +2933,24 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { return self.write_c_mangled_container_path(w, Self::path_to_generic_args(&p.path), generics, &full_path, is_ref, is_mut, ptr_for_ref); } if let Some(aliased_type) = self.crate_types.type_aliases.get(&full_path).cloned() { - return self.write_c_type_intern(w, &aliased_type, None, is_ref, is_mut, ptr_for_ref, with_ref_lifetime); + return self.write_c_type_intern(w, &aliased_type, None, is_ref, is_mut, ptr_for_ref, with_ref_lifetime, c_ty); } } - self.write_c_path_intern(w, &p.path, generics, is_ref, is_mut, ptr_for_ref, with_ref_lifetime) + self.write_c_path_intern(w, &p.path, generics, is_ref, is_mut, ptr_for_ref, with_ref_lifetime, c_ty) }, syn::Type::Reference(r) => { - self.write_c_type_intern(w, &*r.elem, generics, true, r.mutability.is_some(), ptr_for_ref, with_ref_lifetime) + self.write_c_type_intern(w, &*r.elem, generics, true, r.mutability.is_some(), ptr_for_ref, with_ref_lifetime, c_ty) }, syn::Type::Array(a) => { if is_ref && is_mut { write!(w, "*mut [").unwrap(); - if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime) { return false; } + if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime, c_ty) { return false; } } else if is_ref { write!(w, "*const [").unwrap(); - if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime) { return false; } + if !self.write_c_type_intern(w, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime, c_ty) { return false; } } else { let mut typecheck = Vec::new(); - if !self.write_c_type_intern(&mut typecheck, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime) { return false; } + if !self.write_c_type_intern(&mut typecheck, &a.elem, generics, false, false, ptr_for_ref, with_ref_lifetime, c_ty) { return false; } if typecheck[..] != ['u' as u8, '8' as u8] { return false; } } if let syn::Expr::Lit(l) = &a.len { @@ -2760,13 +2976,13 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { true } else { let mut inner_c_ty = Vec::new(); - assert!(self.write_c_path_intern(&mut inner_c_ty, &p.path, generics, true, false, ptr_for_ref, with_ref_lifetime)); - if self.is_clonable(&String::from_utf8(inner_c_ty).unwrap()) { - if let Some(id) = p.path.get_ident() { - let mangled_container = format!("CVec_{}Z", id); - write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap(); - self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false) - } else { false } + assert!(self.write_c_path_intern(&mut inner_c_ty, &p.path, generics, true, false, ptr_for_ref, with_ref_lifetime, c_ty)); + let inner_ty_str = String::from_utf8(inner_c_ty).unwrap(); + if self.is_clonable(&inner_ty_str) { + let inner_ty_ident = inner_ty_str.rsplitn(2, "::").next().unwrap(); + let mangled_container = format!("CVec_{}Z", inner_ty_ident); + write!(w, "{}::{}", Self::generated_container_path(), mangled_container).unwrap(); + self.check_create_container(mangled_container, "Vec", vec![&*s.elem], generics, false) } else { false } } } else if let syn::Type::Reference(r) = &*s.elem { @@ -2802,7 +3018,23 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { args.push(syn::GenericArgument::Type((*s.elem).clone())); 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) + 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) => { @@ -2817,16 +3049,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { } } pub fn write_c_type(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) { - assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, false)); + assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, false, true)); } pub fn write_c_type_in_generic_param(&self, w: &mut W, t: &syn::Type, generics: Option<&GenericTypes>, ptr_for_ref: bool) { - assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, true)); + assert!(self.write_c_type_intern(w, t, generics, false, false, ptr_for_ref, true, false)); } pub fn understood_c_path(&self, p: &syn::Path) -> bool { - if p.leading_colon.is_some() { return false; } - self.write_c_path_intern(&mut std::io::sink(), p, None, false, false, false, false) + self.write_c_path_intern(&mut std::io::sink(), p, None, false, false, false, false, true) } pub fn understood_c_type(&self, t: &syn::Type, generics: Option<&GenericTypes>) -> bool { - self.write_c_type_intern(&mut std::io::sink(), t, generics, false, false, false, false) + self.write_c_type_intern(&mut std::io::sink(), t, generics, false, false, false, false, true) } }