X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=c-bindings-gen%2Fsrc%2Ftypes.rs;h=afe719ffe2ca11709f50f6942dbf629fc9920084;hb=b49781e8d81dc400033c1ea6660f06eda9a87347;hp=7e0099cfc47e516ad5e62bb25eb1b0e2ee8c1b4a;hpb=dd1ca585b30819b18b718711c45ec37cdb56a681;p=rust-lightning diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs index 7e0099cfc..afe719ffe 100644 --- a/c-bindings-gen/src/types.rs +++ b/c-bindings-gen/src/types.rs @@ -110,6 +110,25 @@ pub fn assert_simple_bound(bound: &syn::TraitBound) { if let syn::TraitBoundModifier::Maybe(_) = bound.modifier { unimplemented!(); } } +/// Returns true if the enum will be mapped as an opaue (ie struct with a pointer to the underlying +/// type), otherwise it is mapped into a transparent, C-compatible version of itself. +pub fn is_enum_opaque(e: &syn::ItemEnum) -> bool { + for var in e.variants.iter() { + if let syn::Fields::Unit = var.fields { + } else if let syn::Fields::Named(fields) = &var.fields { + for field in fields.named.iter() { + match export_status(&field.attrs) { + ExportStatus::Export|ExportStatus::TestOnly => {}, + ExportStatus::NoExport => return true, + } + } + } else { + return true; + } + } + false +} + /// A stack of sets of generic resolutions. /// /// This tracks the template parameters for a function, struct, or trait, allowing resolution into @@ -281,48 +300,32 @@ pub enum DeclType<'a> { pub struct ImportResolver<'mod_lifetime, 'crate_lft: 'mod_lifetime> { module_path: &'mod_lifetime str, - imports: HashMap, + imports: HashMap, declared: HashMap>, + priv_modules: HashSet, } impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'crate_lft> { - pub fn new(module_path: &'mod_lifetime str) -> Self { - let mut imports = HashMap::new(); - // Add primitives to the "imports" list: - imports.insert(syn::Ident::new("bool", Span::call_site()), "bool".to_string()); - imports.insert(syn::Ident::new("u64", Span::call_site()), "u64".to_string()); - imports.insert(syn::Ident::new("u32", Span::call_site()), "u32".to_string()); - imports.insert(syn::Ident::new("u16", Span::call_site()), "u16".to_string()); - imports.insert(syn::Ident::new("u8", Span::call_site()), "u8".to_string()); - imports.insert(syn::Ident::new("usize", Span::call_site()), "usize".to_string()); - imports.insert(syn::Ident::new("str", Span::call_site()), "str".to_string()); - imports.insert(syn::Ident::new("String", Span::call_site()), "String".to_string()); - - // These are here to allow us to print native Rust types in trait fn impls even if we don't - // have C mappings: - imports.insert(syn::Ident::new("Result", Span::call_site()), "Result".to_string()); - imports.insert(syn::Ident::new("Vec", Span::call_site()), "Vec".to_string()); - imports.insert(syn::Ident::new("Option", Span::call_site()), "Option".to_string()); - Self { module_path, imports, declared: HashMap::new() } - } - - fn process_use_intern(&mut self, u: &syn::UseTree, partial_path: &str) { + fn process_use_intern(imports: &mut HashMap, u: &syn::UseTree, partial_path: &str, mut path: syn::punctuated::Punctuated) { match u { syn::UseTree::Path(p) => { - let new_path = format!("{}::{}", partial_path, p.ident); - self.process_use_intern(&p.tree, &new_path); + let new_path = format!("{}{}::", partial_path, p.ident); + path.push(syn::PathSegment { ident: p.ident.clone(), arguments: syn::PathArguments::None }); + Self::process_use_intern(imports, &p.tree, &new_path, path); }, syn::UseTree::Name(n) => { - let full_path = format!("{}::{}", partial_path, n.ident); - self.imports.insert(n.ident.clone(), full_path); + let full_path = format!("{}{}", partial_path, n.ident); + path.push(syn::PathSegment { ident: n.ident.clone(), arguments: syn::PathArguments::None }); + imports.insert(n.ident.clone(), (full_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(i, partial_path); + Self::process_use_intern(imports, i, partial_path, path.clone()); } }, syn::UseTree::Rename(r) => { - let full_path = format!("{}::{}", partial_path, r.ident); - self.imports.insert(r.rename.clone(), full_path); + let full_path = format!("{}{}", partial_path, r.ident); + path.push(syn::PathSegment { ident: r.ident.clone(), arguments: syn::PathArguments::None }); + imports.insert(r.rename.clone(), (full_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); @@ -330,41 +333,80 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } } - pub fn process_use(&mut self, u: &syn::ItemUse) { + fn process_use(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; } - match &u.tree { - syn::UseTree::Path(p) => { - let new_path = format!("{}", p.ident); - self.process_use_intern(&p.tree, &new_path); - }, - syn::UseTree::Name(n) => { - let full_path = format!("{}", n.ident); - self.imports.insert(n.ident.clone(), full_path); - }, - _ => unimplemented!(), - } + Self::process_use_intern(imports, &u.tree, "", syn::punctuated::Punctuated::new()); } - pub fn mirrored_enum_declared(&mut self, ident: &syn::Ident) { - self.declared.insert(ident.clone(), DeclType::MirroredEnum); - } - pub fn enum_ignored(&mut self, ident: &'crate_lft syn::Ident) { - self.declared.insert(ident.clone(), DeclType::EnumIgnored); - } - pub fn struct_imported(&mut self, ident: &'crate_lft syn::Ident) { - self.declared.insert(ident.clone(), DeclType::StructImported); + fn insert_primitive(imports: &mut HashMap, id: &str) { + let ident = syn::Ident::new(id, Span::call_site()); + let mut path = syn::punctuated::Punctuated::new(); + path.push(syn::PathSegment { ident: ident.clone(), arguments: syn::PathArguments::None }); + imports.insert(ident, (id.to_owned(), syn::Path { leading_colon: Some(syn::Token![::](Span::call_site())), segments: path })); } - pub fn struct_ignored(&mut self, ident: &syn::Ident) { - self.declared.insert(ident.clone(), DeclType::StructIgnored); - } - pub fn trait_declared(&mut self, ident: &syn::Ident, t: &'crate_lft syn::ItemTrait) { - self.declared.insert(ident.clone(), DeclType::Trait(t)); + + pub fn new(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, "u64"); + Self::insert_primitive(&mut imports, "u32"); + Self::insert_primitive(&mut imports, "u16"); + Self::insert_primitive(&mut imports, "u8"); + Self::insert_primitive(&mut imports, "usize"); + Self::insert_primitive(&mut imports, "str"); + Self::insert_primitive(&mut imports, "String"); + + // These are here to allow us to print native Rust types in trait fn impls even if we don't + // have C mappings: + Self::insert_primitive(&mut imports, "Result"); + Self::insert_primitive(&mut imports, "Vec"); + Self::insert_primitive(&mut imports, "Option"); + + let mut declared = HashMap::new(); + let mut priv_modules = HashSet::new(); + + for item in contents.iter() { + match item { + syn::Item::Use(u) => Self::process_use(&mut imports, &u), + syn::Item::Struct(s) => { + if let syn::Visibility::Public(_) = s.vis { + match export_status(&s.attrs) { + ExportStatus::Export => { declared.insert(s.ident.clone(), DeclType::StructImported); }, + ExportStatus::NoExport => { declared.insert(s.ident.clone(), DeclType::StructIgnored); }, + ExportStatus::TestOnly => continue, + } + } + }, + syn::Item::Enum(e) => { + if let syn::Visibility::Public(_) = e.vis { + match export_status(&e.attrs) { + ExportStatus::Export if is_enum_opaque(e) => { declared.insert(e.ident.clone(), DeclType::EnumIgnored); }, + ExportStatus::Export => { declared.insert(e.ident.clone(), DeclType::MirroredEnum); }, + _ => continue, + } + } + }, + syn::Item::Trait(t) if export_status(&t.attrs) == ExportStatus::Export => { + if let syn::Visibility::Public(_) = t.vis { + declared.insert(t.ident.clone(), DeclType::Trait(t)); + } + }, + syn::Item::Mod(m) => { + priv_modules.insert(m.ident.clone()); + }, + _ => {}, + } + } + + Self { module_path, imports, declared, priv_modules } } + pub fn get_declared_type(&self, ident: &syn::Ident) -> Option<&DeclType<'crate_lft>> { self.declared.get(ident) } @@ -374,7 +416,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } pub fn maybe_resolve_ident(&self, id: &syn::Ident) -> Option { - if let Some(imp) = self.imports.get(id) { + if let Some((imp, _)) = self.imports.get(id) { Some(imp.clone()) } else if self.declared.get(id).is_some() { Some(self.module_path.to_string() + "::" + &format!("{}", id)) @@ -382,7 +424,7 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr } pub fn maybe_resolve_non_ignored_ident(&self, id: &syn::Ident) -> Option { - if let Some(imp) = self.imports.get(id) { + if let Some((imp, _)) = self.imports.get(id) { Some(imp.clone()) } else if let Some(decl_type) = self.declared.get(id) { match decl_type { @@ -415,15 +457,43 @@ impl<'mod_lifetime, 'crate_lft: 'mod_lifetime> ImportResolver<'mod_lifetime, 'cr let remaining: String = seg_iter.map(|seg| { format!("::{}", seg.ident) }).collect(); - if let Some(imp) = self.imports.get(&first_seg.ident) { + if let Some((imp, _)) = self.imports.get(&first_seg.ident) { if remaining != "" { Some(imp.clone() + &remaining) } else { Some(imp.clone()) } + } else if let Some(_) = self.priv_modules.get(&first_seg.ident) { + Some(format!("{}::{}{}", self.module_path, first_seg.ident, remaining)) } else { None } } } + + /// 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 { + syn::Type::Path(p) => { + if let Some(ident) = p.path.get_ident() { + if let Some((_, newpath)) = self.imports.get(ident) { + p.path = newpath.clone(); + } + } else { unimplemented!(); } + }, + syn::Type::Reference(r) => { + r.elem = Box::new(self.resolve_imported_refs((*r.elem).clone())); + }, + syn::Type::Slice(s) => { + s.elem = Box::new(self.resolve_imported_refs((*s.elem).clone())); + }, + syn::Type::Tuple(t) => { + for e in t.elems.iter_mut() { + *e = self.resolve_imported_refs(e.clone()); + } + }, + _ => unimplemented!(), + } + ty + } } // templates_defined is walked to write the C++ header, so if we use the default hashing it get @@ -477,8 +547,8 @@ enum EmptyValExpectedTy { } impl<'a, 'c: 'a> TypeResolver<'a, 'c> { - pub fn new(orig_crate: &'a str, module_path: &'a str, crate_types: &'a mut CrateTypes<'c>) -> Self { - Self { orig_crate, module_path, types: ImportResolver::new(module_path), crate_types } + pub fn new(orig_crate: &'a str, module_path: &'a str, types: ImportResolver<'a, 'c>, crate_types: &'a mut CrateTypes<'c>) -> Self { + Self { orig_crate, module_path, types, crate_types } } // ************************************************* @@ -985,25 +1055,6 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> { // *** Type definition during main.rs processing *** // ************************************************* - pub fn process_use(&mut self, w: &mut W, u: &syn::ItemUse) { - self.types.process_use(u); - } - - pub fn mirrored_enum_declared(&mut self, ident: &syn::Ident) { - self.types.mirrored_enum_declared(ident); - } - pub fn enum_ignored(&mut self, ident: &'c syn::Ident) { - self.types.enum_ignored(ident); - } - pub fn struct_imported(&mut self, ident: &'c syn::Ident) { - self.types.struct_imported(ident); - } - pub fn struct_ignored(&mut self, ident: &syn::Ident) { - self.types.struct_ignored(ident); - } - pub fn trait_declared(&mut self, ident: &syn::Ident, t: &'c syn::ItemTrait) { - self.types.trait_declared(ident, t); - } pub fn get_declared_type(&'a self, ident: &syn::Ident) -> Option<&'a DeclType<'c>> { self.types.get_declared_type(ident) }