Avoid duplicate symbols in gdnative::api; inner modules only have additional types (not the API class itself)

Author: Bromeon

bindings_generator/src/api.rs

@@ -406,9 +406,8 @@ impl Ty {
                 }
             }
             ty => {
-                let module = format_ident!("{}", module_name_from_class_name(ty));
                 let ty = format_ident!("{}", ty);
-                Ty::Object(syn::parse_quote! { crate::generated::#module::#ty })
+                Ty::Object(syn::parse_quote! { crate::generated::#ty })
             }
         }
     }

bindings_generator/src/classes.rs

@@ -9,17 +9,22 @@ use quote::{format_ident, quote};
 
 use std::collections::HashMap;
 
-pub(crate) fn generate_class_struct(class: &GodotClass) -> TokenStream {
+pub(crate) fn generate_class_struct(class: &GodotClass, class_doc: TokenStream) -> TokenStream {
     let class_name = format_ident!("{}", &class.name);
 
     // dead_code: 'this' might not be read
+    // mod private: hide the type in the #module_name module, export it only in gdnative::api
     quote! {
-        #[allow(non_camel_case_types)]
-        #[derive(Debug)]
-        pub struct #class_name {
-            #[allow(dead_code)]
-            this: RawObject<Self>,
+        pub(crate) mod private {
+            #class_doc
+            #[allow(non_camel_case_types)]
+            #[derive(Debug)]
+            pub struct #class_name {
+                #[allow(dead_code)]
+                pub(crate) this: super::RawObject<Self>,
+            }
         }
+        use private::#class_name;
     }
 }
 

bindings_generator/src/lib.rs

@@ -84,9 +84,8 @@ fn generate_class_bindings(
 ) -> TokenStream {
     // types and methods
     let types_and_methods = {
-        let documentation = generate_class_documentation(api, class);
-
-        let class_struct = generate_class_struct(class);
+        let class_doc = generate_class_documentation(api, class);
+        let class_struct = generate_class_struct(class, class_doc);
 
         let enums = generate_enums(class);
 
@@ -99,7 +98,6 @@ fn generate_class_bindings(
         let class_impl = generate_class_impl(class, icalls, docs);
 
         quote! {
-            #documentation
             #class_struct
             #enums
             #constants
@@ -195,17 +193,23 @@ pub(crate) mod test_prelude {
 
     #[test]
     fn sanity_test_generated_code() {
+        // Tests whether each generated snippet individually constitutes a valid AST representation of Rust code
+
         let api = Api::new(include_str!("../../gdnative-bindings/api.json"));
         let mut buffer = BufWriter::new(Vec::with_capacity(16384));
         for class in &api.classes {
             let mut icalls = HashMap::new();
 
-            let code = generate_class_documentation(&api, &class);
+            let code = generate_module_doc(&class);
+            write!(&mut buffer, "{}", code).unwrap();
+            validate_and_clear_buffer!(buffer);
+
+            let class_doc = generate_class_documentation(&api, &class);
             write!(&mut buffer, "{}", code).unwrap();
-            write!(&mut buffer, "{}", quote! { struct Docs {} }).unwrap();
+            write!(&mut buffer, "{}", quote! { struct StructWithDocs {} }).unwrap();
             validate_and_clear_buffer!(buffer);
 
-            let code = generate_class_struct(&class);
+            let code = generate_class_struct(&class, class_doc);
             write!(&mut buffer, "{}", code).unwrap();
             validate_and_clear_buffer!(buffer);
 

bindings_generator/src/special_methods.rs

@@ -154,11 +154,10 @@ pub fn generate_deref_impl(class: &GodotClass) -> TokenStream {
     );
 
     let class_name = format_ident!("{}", class.name);
-    let base_class_module = format_ident!("{}", class.base_class_module());
     let base_class = format_ident!("{}", class.base_class);
 
     let qualified_base_class = quote! {
-        crate::generated::#base_class_module::#base_class
+        crate::generated::#base_class
     };
 
     quote! {
@@ -190,11 +189,10 @@ pub fn generate_sub_class_impls<'a>(api: &'a Api, mut class: &'a GodotClass) ->
     let mut tokens = TokenStream::new();
 
     while let Some(base_class) = class.base_class(api) {
-        let base_class_module = format_ident!("{}", base_class.module());
         let base_class_ident = format_ident!("{}", base_class.name);
 
         tokens.extend(quote! {
-            unsafe impl SubClass<crate::generated::#base_class_module::#base_class_ident> for #class_name {}
+            unsafe impl SubClass<crate::generated::#base_class_ident> for #class_name {}
         });
 
         class = base_class;

gdnative-bindings/build.rs

@@ -58,7 +58,7 @@ fn generate(
                 use super::*;
                 {content}
             }}
-            pub use crate::generated::{mod_name}::{class_name};
+            pub use crate::generated::{mod_name}::private::{class_name};
             "#,
             mod_name = module_name_from_class_name(class_name),
             class_name = class_name,
@@ -101,7 +101,7 @@ fn generate(
             r#"
             #[path = {:?}]
             pub mod {mod_name};
-            pub use crate::generated::{mod_name}::{class_name};
+            pub use crate::generated::{mod_name}::private::{class_name};
             "#,
             mod_path.display(),
             mod_name = mod_name,