writeln!(w, "\t\t}}\n\t}}\n}}").unwrap();
write_cpp_wrapper(cpp_headers, &trait_name, true);
- types.trait_declared(&t.ident, t);
}
/// Write out a simple "opaque" type (eg structs) which contain a pointer to the native Rust type
write_cpp_wrapper(cpp_headers, &format!("{}", ident), true);
}
-fn declare_struct<'a, 'b>(s: &'a syn::ItemStruct, types: &mut TypeResolver<'b, 'a>) -> bool {
- let export = export_status(&s.attrs);
- match export {
- ExportStatus::Export => {},
- ExportStatus::TestOnly => return false,
- ExportStatus::NoExport => {
- types.struct_ignored(&s.ident);
- return false;
- }
- }
-
- types.struct_imported(&s.ident);
- true
-}
-
/// Writes out all the relevant mappings for a Rust struct, deferring to writeln_opaque to generate
/// the struct itself, and then writing getters and setters for public, understood-type fields and
/// a constructor if every field is public.
fn writeln_struct<'a, 'b, W: std::io::Write>(w: &mut W, s: &'a syn::ItemStruct, types: &mut TypeResolver<'b, 'a>, extra_headers: &mut File, cpp_headers: &mut File) {
- if !declare_struct(s, types) { return; }
+ if export_status(&s.attrs) != ExportStatus::Export { return; }
let struct_name = &format!("{}", s.ident);
writeln_opaque(w, &s.ident, struct_name, &s.generics, &s.attrs, types, extra_headers, cpp_headers);
}
}
-/// 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.
-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
-}
-
-fn declare_enum<'a, 'b>(e: &'a syn::ItemEnum, types: &mut TypeResolver<'b, 'a>) {
- match export_status(&e.attrs) {
- ExportStatus::Export => {},
- ExportStatus::NoExport|ExportStatus::TestOnly => return,
- }
-
- if is_enum_opaque(e) {
- types.enum_ignored(&e.ident);
- } else {
- types.mirrored_enum_declared(&e.ident);
- }
-}
/// Print a mapping of an enum. If all of the enum's fields are C-mapped in some form (or the enum
/// is unitary), we generate an equivalent enum with all types replaced with their C mapped
eprintln!("Converting {} entries...", module);
- let mut type_resolver = TypeResolver::new(orig_crate, module, crate_types);
-
- // First pass over the items and fill in imports and file-declared objects in the type resolver
- for item in items.iter() {
- match item {
- syn::Item::Use(u) => type_resolver.process_use(&mut out, &u),
- syn::Item::Struct(s) => {
- if let syn::Visibility::Public(_) = s.vis {
- declare_struct(&s, &mut type_resolver);
- }
- },
- syn::Item::Enum(e) => {
- if let syn::Visibility::Public(_) = e.vis {
- declare_enum(&e, &mut type_resolver);
- }
- },
- _ => {},
- }
- }
+ let import_resolver = ImportResolver::new(module, items);
+ let mut type_resolver = TypeResolver::new(orig_crate, module, import_resolver, crate_types);
for item in items.iter() {
match item {
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
declared: HashMap<syn::Ident, DeclType<'crate_lft>>,
}
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<syn::Ident, String>, u: &syn::UseTree, partial_path: &str) {
match u {
syn::UseTree::Path(p) => {
let new_path = format!("{}::{}", partial_path, p.ident);
- self.process_use_intern(&p.tree, &new_path);
+ Self::process_use_intern(imports, &p.tree, &new_path);
},
syn::UseTree::Name(n) => {
let full_path = format!("{}::{}", partial_path, n.ident);
- self.imports.insert(n.ident.clone(), full_path);
+ imports.insert(n.ident.clone(), full_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);
}
},
syn::UseTree::Rename(r) => {
let full_path = format!("{}::{}", partial_path, r.ident);
- self.imports.insert(r.rename.clone(), full_path);
+ imports.insert(r.rename.clone(), full_path);
},
syn::UseTree::Glob(_) => {
eprintln!("Ignoring * use for {} - this may result in resolution failures", partial_path);
}
}
- pub fn process_use(&mut self, u: &syn::ItemUse) {
+ pub fn process_use(imports: &mut HashMap<syn::Ident, String>, u: &syn::ItemUse) {
if let syn::Visibility::Public(_) = u.vis {
// We actually only use these for #[cfg(fuzztarget)]
eprintln!("Ignoring pub(use) tree!");
match &u.tree {
syn::UseTree::Path(p) => {
let new_path = format!("{}", p.ident);
- self.process_use_intern(&p.tree, &new_path);
+ Self::process_use_intern(imports, &p.tree, &new_path);
},
syn::UseTree::Name(n) => {
let full_path = format!("{}", n.ident);
- self.imports.insert(n.ident.clone(), full_path);
+ imports.insert(n.ident.clone(), full_path);
},
_ => unimplemented!(),
}
}
- 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);
- }
- 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:
+ 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());
+
+ let mut declared = HashMap::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));
+ }
+ },
+ _ => {},
+ }
+ }
+
+ Self { module_path, imports, declared }
}
+
pub fn get_declared_type(&self, ident: &syn::Ident) -> Option<&DeclType<'crate_lft>> {
self.declared.get(ident)
}
}
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 }
}
// *************************************************
// *** Type definition during main.rs processing ***
// *************************************************
- pub fn process_use<W: std::io::Write>(&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)
}
projects / rust-lightning / commitdiff