Fix secondary api blocks not registering docs.

Author: Houtamelo

godot-core/src/docs.rs

@@ -48,16 +48,16 @@ pub struct StructDocs {
 /// All fields are XML parts, escaped where necessary.
 #[derive(Default, Copy, Clone, Debug)]
 pub struct InherentImplDocs {
-    pub methods: &'static str,
-    pub signals_block: &'static str,
-    pub constants_block: &'static str,
+    pub methods: Vec<&'static str>,
+    pub signals: Vec<&'static str>,
+    pub constants: Vec<&'static str>,
 }
 
 #[derive(Default)]
 struct DocPieces {
     definition: StructDocs,
     inherent: InherentImplDocs,
-    virtual_methods: &'static str,
+    virtual_methods: Vec<&'static str>,
 }
 
 /// This function scours the registered plugins to find their documentation pieces,
@@ -79,51 +79,65 @@ pub fn gather_xml_docs() -> impl Iterator<Item = String> {
     crate::private::iterate_plugins(|x| {
         let class_name = x.class_name;
 
-        match x.item {
+        match &x.item {
             PluginItem::InherentImpl(InherentImpl { docs, .. }) => {
-                map.entry(class_name).or_default().inherent = docs
+                map.entry(class_name).or_default().inherent = docs.clone();
             }
-
             PluginItem::ITraitImpl(ITraitImpl {
                 virtual_method_docs,
                 ..
-            }) => map.entry(class_name).or_default().virtual_methods = virtual_method_docs,
+            }) => map
+                .entry(class_name)
+                .or_default()
+                .virtual_methods
+                .push(virtual_method_docs),
 
             PluginItem::Struct(Struct { docs, .. }) => {
-                map.entry(class_name).or_default().definition = docs
+                map.entry(class_name).or_default().definition = *docs;
             }
 
             _ => (),
         }
     });
 
     map.into_iter().map(|(class, pieces)| {
-            let StructDocs {
-                base,
-                description,
-                experimental,
-                deprecated,
-                members,
-            } = pieces.definition;
-
-            let InherentImplDocs {
-                methods,
-                signals_block,
-                constants_block,
-            } = pieces.inherent;
-
-            let virtual_methods = pieces.virtual_methods;
-            let methods_block = (virtual_methods.is_empty() && methods.is_empty())
-                .then(String::new)
-                .unwrap_or_else(|| format!("<methods>{methods}{virtual_methods}</methods>"));
-
-            let (brief, description) = match description
-                .split_once("[br]") {
-                    Some((brief, description)) => (brief, description.trim_start_matches("[br]")),
-                    None => (description, ""),
-                };
-
-            format!(r#"<?xml version="1.0" encoding="UTF-8"?>
+        let StructDocs {
+            base,
+            description,
+            experimental,
+            deprecated,
+            members,
+        } = pieces.definition;
+
+        let virtual_methods = pieces.virtual_methods;
+
+        let mut method_docs = String::from_iter(pieces.inherent.methods);
+        let signal_docs = String::from_iter(pieces.inherent.signals);
+        let constant_docs = String::from_iter(pieces.inherent.constants);
+
+        method_docs.extend(virtual_methods);
+        let methods_block = if method_docs.is_empty() {
+            String::new()
+        } else {
+            format!("<methods>{method_docs}</methods>")
+        };
+        let signals_block = if signal_docs.is_empty() {
+            String::new()
+        } else {
+            format!("<signals>{signal_docs}</signals>")
+        };
+        let constants_block = if constant_docs.is_empty() {
+            String::new()
+        } else {
+            format!("<constants>{constant_docs}</constants>")
+        };
+        let (brief, description) = match description
+            .split_once("[br]") {
+            Some((brief, description)) => (brief, description.trim_start_matches("[br]")),
+            None => (description, ""),
+        };
+
+        format!(r#"<?xml version="1.0" encoding="UTF-8"?>
 <class name="{class}" inherits="{base}"{deprecated}{experimental} xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
 <brief_description>{brief}</brief_description>
 <description>{description}</description>
@@ -132,8 +146,8 @@ pub fn gather_xml_docs() -> impl Iterator<Item = String> {
 {signals_block}
 <members>{members}</members>
 </class>"#)
-        },
-        )
+    },
+    )
 }
 
 /// # Safety

godot-core/src/private.rs

@@ -142,6 +142,22 @@ pub fn next_class_id() -> u16 {
     NEXT_CLASS_ID.fetch_add(1, atomic::Ordering::Relaxed)
 }
 
+// Don't touch unless you know what you're doing.
+#[doc(hidden)]
+pub fn edit_inherent_impl(class_name: crate::meta::ClassName, f: impl FnOnce(&mut InherentImpl)) {
+    let mut plugins = __GODOT_PLUGIN_REGISTRY.lock().unwrap();
+
+    for elem in plugins.iter_mut().filter(|p| p.class_name == class_name) {
+        match &mut elem.item {
+            PluginItem::InherentImpl(inherent_impl) => {
+                f(inherent_impl);
+                return;
+            }
+            PluginItem::Struct(_) | PluginItem::ITraitImpl(_) | PluginItem::DynTraitImpl(_) => {}
+        }
+    }
+}
+
 pub(crate) fn iterate_plugins(mut visitor: impl FnMut(&ClassPlugin)) {
     sys::plugin_foreach!(__GODOT_PLUGIN_REGISTRY; visitor);
 }

godot-core/src/registry/class.rs

@@ -115,7 +115,10 @@ impl ClassRegistrationInfo {
         // Note: when changing this match, make sure the array has sufficient size.
         let index = match item {
             PluginItem::Struct { .. } => 0,
-            PluginItem::InherentImpl(_) => 1,
+            PluginItem::InherentImpl(_) => {
+                // Inherent impls don't need to be unique.
+                return;
+            }
             PluginItem::ITraitImpl { .. } => 2,
 
             // Multiple dyn traits can be registered, thus don't validate for uniqueness.

godot-core/src/registry/plugin.rs

@@ -39,10 +39,10 @@ pub struct ClassPlugin {
     /// Incorrectly setting this value should not cause any UB but will likely cause errors during registration time.
     // Init-level is per ClassPlugin and not per PluginItem, because all components of all classes are mixed together in one
     // huge linker list. There is no per-class aggregation going on, so this allows to easily filter relevant classes.
-    pub(crate) init_level: InitLevel,
+    pub init_level: InitLevel,
 
     /// The actual item being registered.
-    pub(crate) item: PluginItem,
+    pub item: PluginItem,
 }
 
 impl ClassPlugin {
@@ -300,9 +300,7 @@ pub struct InherentImpl {
 }
 
 impl InherentImpl {
-    pub fn new<T: cap::ImplementsGodotApi>(
-        #[cfg(all(since_api = "4.3", feature = "register-docs"))] docs: InherentImplDocs,
-    ) -> Self {
+    pub fn new<T: cap::ImplementsGodotApi>() -> Self {
         Self {
             register_methods_constants_fn: ErasedRegisterFn {
                 raw: callbacks::register_user_methods_constants::<T>,
@@ -311,7 +309,7 @@ impl InherentImpl {
                 raw: callbacks::register_user_rpcs::<T>,
             }),
             #[cfg(all(since_api = "4.3", feature = "register-docs"))]
-            docs,
+            docs: Default::default(),
         }
     }
 }

godot-macros/src/class/data_models/inherent_impl.rs

@@ -93,8 +93,6 @@ pub fn transform_inherent_impl(
 
     #[cfg(all(feature = "register-docs", since_api = "4.3"))]
     let docs = crate::docs::document_inherent_impl(&funcs, &consts, &signals);
-    #[cfg(not(all(feature = "register-docs", since_api = "4.3")))]
-    let docs = quote! {};
 
     // Container struct holding names of all registered #[func]s.
     // The struct is declared by #[derive(GodotClass)].
@@ -127,17 +125,41 @@ pub fn transform_inherent_impl(
     let method_storage_name = format_ident!("__registration_methods_{class_name}");
     let constants_storage_name = format_ident!("__registration_constants_{class_name}");
 
-    let fill_storage = quote! {
-        ::godot::sys::plugin_execute_pre_main!({
-            #method_storage_name.lock().unwrap().push(|| {
-                #( #method_registrations )*
-                #( #signal_registrations )*
-            });
+    let fill_storage = {
+        #[cfg(all(feature = "register-docs", since_api = "4.3"))]
+        let push_docs = {
+            let crate::docs::InherentImplXmlDocs {
+                method_xml_elems,
+                constant_xml_elems,
+                signal_xml_elems,
+            } = docs;
+
+            quote! {
+                #prv::edit_inherent_impl(#class_name_obj, |inherent_impl| {
+                    inherent_impl.docs.methods.push(#method_xml_elems);
+                    inherent_impl.docs.constants.push(#constant_xml_elems);
+                    inherent_impl.docs.signals.push(#signal_xml_elems);
+                });
+            }
+        };
+
+        #[cfg(not(all(feature = "register-docs", since_api = "4.3")))]
+        let push_docs = TokenStream::new();
 
-            #constants_storage_name.lock().unwrap().push(|| {
-                #constant_registration
+        quote! {
+            ::godot::sys::plugin_execute_pre_main!({
+                #method_storage_name.lock().unwrap().push(|| {
+                    #( #method_registrations )*
+                    #( #signal_registrations )*
+                });
+
+                #constants_storage_name.lock().unwrap().push(|| {
+                    #constant_registration
+                });
+
+                #push_docs
             });
-        });
+        }
     };
 
     if !meta.secondary {
@@ -175,7 +197,7 @@ pub fn transform_inherent_impl(
 
         let class_registration = quote! {
             ::godot::sys::plugin_add!(#prv::__GODOT_PLUGIN_REGISTRY; #prv::ClassPlugin::new::<#class_name>(
-                #prv::PluginItem::InherentImpl(#prv::InherentImpl::new::<#class_name>(#docs))
+                #prv::PluginItem::InherentImpl(#prv::InherentImpl::new::<#class_name>())
             ));
         };
 

godot-macros/src/docs.rs

@@ -24,6 +24,12 @@ struct XmlParagraphs {
     deprecated_attr: String,
 }
 
+pub struct InherentImplXmlDocs {
+    pub method_xml_elems: String,
+    pub constant_xml_elems: String,
+    pub signal_xml_elems: String,
+}
+
 /// Returns code containing the doc information of a `#[derive(GodotClass)] struct MyClass` declaration iff class or any of its members is documented.
 pub fn document_struct(
     base: String,
@@ -59,39 +65,27 @@ pub fn document_inherent_impl(
     functions: &[FuncDefinition],
     constants: &[ConstDefinition],
     signals: &[SignalDefinition],
-) -> TokenStream {
-    let group_xml_block = |s: String, tag: &str| -> String {
-        if s.is_empty() {
-            s
-        } else {
-            format!("<{tag}>{s}</{tag}>")
-        }
-    };
-
+) -> InherentImplXmlDocs {
     let signal_xml_elems = signals
         .iter()
         .filter_map(format_signal_xml)
         .collect::<String>();
-    let signals_block = group_xml_block(signal_xml_elems, "signals");
 
     let constant_xml_elems = constants
         .iter()
         .map(|ConstDefinition { raw_constant }| raw_constant)
         .filter_map(format_constant_xml)
         .collect::<String>();
-    let constants_block = group_xml_block(constant_xml_elems, "constants");
 
     let method_xml_elems = functions
         .iter()
         .filter_map(format_method_xml)
         .collect::<String>();
 
-    quote! {
-        ::godot::docs::InherentImplDocs {
-            methods: #method_xml_elems,
-            signals_block: #signals_block,
-            constants_block: #constants_block,
-        }
+    InherentImplXmlDocs {
+        method_xml_elems,
+        constant_xml_elems,
+        signal_xml_elems,
     }
 }