[bindings] Track all declared types in ImportResolver construction

[rust-lightning] / c-bindings-gen / src / main.rs

diff --git a/c-bindings-gen/src/main.rs b/c-bindings-gen/src/main.rs
index f8475bbdcf958ce40f90d57c16e0c3cbb6e3d41d..07948ed42fa4b737b8dc9584a81e0925783772d7 100644 (file)
--- a/c-bindings-gen/src/main.rs
+++ b/c-bindings-gen/src/main.rs
@@ -517,7 +517,6 @@ fn writeln_trait<'a, 'b, W: std::io::Write>(w: &mut W, t: &'a syn::ItemTrait, ty
        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
@@ -557,26 +556,11 @@ fn writeln_opaque<W: std::io::Write>(w: &mut W, ident: &syn::Ident, struct_name:
        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);
@@ -998,37 +982,6 @@ fn writeln_impl<W: std::io::Write>(w: &mut W, i: &syn::ItemImpl, types: &mut Typ
        }
 }
 
-/// 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
@@ -1274,25 +1227,8 @@ fn convert_file<'a, 'b>(libast: &'a FullLibraryAST, crate_types: &mut CrateTypes
 
                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 {