move doc concatenation to runtime

Author: bend-n

godot-core/src/init/mod.rs

@@ -5,6 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+use std::collections::{hash_map::Entry, HashMap};
 use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
 
 use godot_ffi as sys;
@@ -13,6 +14,7 @@ use sys::GodotFfi;
 
 use crate::builtin::{GString, StringName};
 use crate::out;
+use crate::registry::plugin::PluginItem;
 
 pub use sys::GdextBuild;
 
@@ -119,6 +121,71 @@ unsafe extern "C" fn ffi_deinitialize_layer<E: ExtensionLibrary>(
     });
 }
 
+unsafe fn register() {
+    #[derive(Default)]
+    struct DocPieces {
+        /// base, description
+        definition: [&'static str; 2],
+        /// methods, signals, constants
+        inherent: [&'static str; 3],
+        imethods: &'static str,
+    }
+
+    let mut map = HashMap::<&'static str, DocPieces>::new();
+    crate::private::iterate_plugins(|x| match x.item {
+        PluginItem::InherentImpl { docs, .. } => match map.entry(x.class_name.as_str()) {
+            Entry::Occupied(x) => x.into_mut().inherent = docs,
+            Entry::Vacant(x) => drop(x.insert(DocPieces {
+                inherent: docs,
+                ..Default::default()
+            })),
+        },
+        PluginItem::ITraitImpl { docs, .. } => match map.entry(x.class_name.as_str()) {
+            Entry::Occupied(x) => x.into_mut().imethods = docs,
+            Entry::Vacant(x) => drop(x.insert(DocPieces {
+                imethods: docs,
+                ..Default::default()
+            })),
+        },
+        PluginItem::Struct { docs, .. } => match map.entry(x.class_name.as_str()) {
+            Entry::Occupied(x) => x.into_mut().definition = docs,
+            Entry::Vacant(x) => drop(x.insert(DocPieces {
+                definition: docs,
+                ..Default::default()
+            })),
+        },
+    });
+    for (
+        class,
+        DocPieces {
+            definition: [base, desc],
+            inherent: [methods, signals, constants],
+            imethods,
+        },
+    ) in map
+    {
+        let brief = desc.lines().next().unwrap_or_default();
+        let xml = format!(
+            r#"
+<?xml version="1.0" encoding="UTF-8"?>
+<class name="{class}" inherits="{base}" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+<brief_description>{brief}</brief_description>
+<description>{desc}</description>
+<members></members>
+<methods>{methods}{imethods}</methods>
+<constants>{constants}</constants>
+<signals>{signals}</signals>
+</class>"#
+        );
+        println!("{xml}");
+        // SAFETY: the godot binding is initialized
+        crate::sys::interface_fn!(editor_help_load_xml_from_utf8_chars_and_len)(
+            xml.as_ptr().cast(),
+            xml.len() as _,
+        );
+    }
+}
+
 /// Tasks needed to be done by gdext internally upon loading an initialization level. Called before user code.
 fn gdext_on_level_init(level: InitLevel) {
     // SAFETY: we are in the main thread, during initialization, no other logic is happening.
@@ -136,17 +203,8 @@ fn gdext_on_level_init(level: InitLevel) {
                 ensure_godot_features_compatible();
             }
             InitLevel::Editor => {
-                crate::private::iterate_plugins(|x| match x.item {
-                    crate::registry::plugin::PluginItem::InherentImpl {
-                        register_documentation,
-                        ..
-                    } => register_documentation(),
-                    // crate::registry::plugin::PluginItem::ITraitImpl {
-                    //     register_documentation,
-                    //     ..
-                    // } => register_documentation(),
-                    _ => (),
-                });
+                #[cfg(since_api = "4.3")]
+                register();
                 sys::load_class_method_table(sys::ClassApiLevel::Editor);
             }
         }

godot-core/src/registry/class.rs

@@ -232,6 +232,7 @@ fn fill_class_info(item: PluginItem, c: &mut ClassRegistrationInfo) {
             is_editor_plugin,
             is_hidden,
             is_instantiable,
+            ..
         } => {
             c.parent_class_name = Some(base_class_name);
             c.default_virtual_fn = default_get_virtual_fn;

godot-core/src/registry/plugin.rs

@@ -96,6 +96,8 @@ pub enum PluginItem {
 
         /// Whether the class has a default constructor.
         is_instantiable: bool,
+        /// Base, Description.
+        docs: [&'static str; 2],
     },
 
     /// Collected from `#[godot_api] impl MyClass`.
@@ -104,14 +106,14 @@ pub enum PluginItem {
         ///
         /// Always present since that's the entire point of this `impl` block.
         register_methods_constants_fn: ErasedRegisterFn,
-        /// Registers the documentation for this class.
-        register_documentation: unsafe fn(),
+        /// Method, Signal, Constant documentation.
+        docs: [&'static str; 3],
     },
 
     /// Collected from `#[godot_api] impl I... for MyClass`.
     ITraitImpl {
-        /// Registers the documentation for this class's virtual (`_ready`, …) methods.
-        register_documentation: unsafe fn(),
+        /// Virtual method documentation.
+        docs: &'static str,
         /// Callback to user-defined `register_class` function.
         user_register_fn: Option<ErasedRegisterFn>,
 

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

@@ -62,7 +62,7 @@ pub fn transform_inherent_impl(mut impl_block: venial::Impl) -> ParseResult<Toke
     let constant_registration =
         make_constant_registration(consts.clone(), &class_name, &class_name_obj)?;
 
-    let docs = crate::docs::class(funcs, None, consts, signals);
+    let docs = crate::docs::inherent_impl(funcs, consts, signals);
     let result = quote! {
         #impl_block
 
@@ -80,7 +80,7 @@ pub fn transform_inherent_impl(mut impl_block: venial::Impl) -> ParseResult<Toke
         ::godot::sys::plugin_add!(__GODOT_PLUGIN_REGISTRY in #prv; #prv::ClassPlugin {
             class_name: #class_name_obj,
             item: #prv::PluginItem::InherentImpl {
-                register_documentation: { #docs docs::<#class_name> },
+                docs: #docs,
                 register_methods_constants_fn: #prv::ErasedRegisterFn {
                     raw: #prv::callbacks::register_user_methods_constants::<#class_name>,
                 },

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

@@ -42,15 +42,10 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
     let mut virtual_method_names = vec![];
 
     let prv = quote! { ::godot::private };
-    let docs = crate::docs::class(
-        None,
-        original_impl.body_items.iter().filter_map(|x| match x {
-            venial::ImplMember::AssocFunction(f) => Some(f.clone()),
-            _ => None,
-        }),
-        None,
-        None,
-    );
+    let docs = crate::docs::virtual_impl(original_impl.body_items.iter().filter_map(|x| match x {
+        venial::ImplMember::AssocFunction(f) => Some(f.clone()),
+        _ => None,
+    }));
     for item in original_impl.body_items.iter() {
         let method = if let venial::ImplMember::AssocFunction(f) = item {
             f
@@ -396,7 +391,7 @@ pub fn transform_trait_impl(original_impl: venial::Impl) -> ParseResult<TokenStr
         ::godot::sys::plugin_add!(__GODOT_PLUGIN_REGISTRY in #prv; #prv::ClassPlugin {
             class_name: #class_name_obj,
             item: #prv::PluginItem::ITraitImpl {
-                register_documentation: { #docs docs::<#class_name> },
+                docs: #docs,
                 user_register_fn: #register_fn,
                 user_create_fn: #create_fn,
                 user_recreate_fn: #recreate_fn,

godot-macros/src/class/derive_godot_class.rs

@@ -104,18 +104,14 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
     };
 
     let is_tool = struct_cfg.is_tool;
-
-    let docs = crate::docs::docs(class.attributes.clone());
+    let docs = crate::docs::define(base_class.to_string(), class.attributes.clone());
     Ok(quote! {
         impl ::godot::obj::GodotClass for #class_name {
             type Base = #base_class;
 
             fn class_name() -> ::godot::meta::ClassName {
                 ::godot::meta::ClassName::from_ascii_cstr(#class_name_cstr)
             }
-
-            const __DOCS: &'static str = #docs;
-            const __BASE: ::core::option::Option<&'static str> = Some(stringify!(#base_ty));
         }
 
         unsafe impl ::godot::obj::Bounds for #class_name {
@@ -133,6 +129,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         ::godot::sys::plugin_add!(__GODOT_PLUGIN_REGISTRY in #prv; #prv::ClassPlugin {
             class_name: #class_name_obj,
             item: #prv::PluginItem::Struct {
+                docs: #docs,
                 base_class_name: #base_class_name_obj,
                 generated_create_fn: #create_fn,
                 generated_recreate_fn: #recreate_fn,

godot-macros/src/docs.rs

@@ -89,56 +89,28 @@ pub fn constant(cnst: Constant) -> String {
     format!(r#"<constant name="{name}" value="{value}">{docs}</constant>"#)
 }
 
-/// This will register the documentation.
-pub fn class(
+pub fn define(base: String, description: Vec<Attribute>) -> TokenStream {
+    let desc = docs(description);
+    quote::quote![[#base, #desc]]
+}
+
+pub fn inherent_impl(
     functions: impl IntoIterator<Item = FuncDefinition>,
-    imethods: impl IntoIterator<Item = Function>,
     constants: impl IntoIterator<Item = ConstDefinition>,
     signals: impl IntoIterator<Item = SignalDefinition>,
 ) -> TokenStream {
-    let methods = functions
-        .into_iter()
-        .map(method)
-        .chain(imethods.into_iter().map(imethod))
-        .collect::<String>();
-
+    let methods = functions.into_iter().map(method).collect::<String>();
+    let signals = signals.into_iter().map(signal).collect::<String>();
     let constants = constants
         .into_iter()
         .map(|ConstDefinition { raw_constant: x }| x)
         .map(constant)
         .collect::<String>();
+    quote::quote![[#methods, #signals, #constants]]
+}
 
-    let signals = signals.into_iter().map(signal).collect::<String>();
-
-    let init = format!(
-        r#"
-<?xml version="1.0" encoding="UTF-8" ?>
-<class name="CLASS⯂" inherits="BASE⯂"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
-  <brief_description>BRIEF⯂</brief_description>
-  <description>DESC⯂</description>
-  <methods>{methods}</methods>
-  <constants>{constants}</constants>
-  <signals>{signals}</signals>
-</class>
-    "#
-    );
-
-    quote::quote! {
-        unsafe fn docs<T: ::godot::prelude::GodotClass>() {
-        let xml = #init
-            .replace("CLASS⯂", T::class_name().as_str())
-            .replace("BASE⯂", T::__BASE.unwrap_or("Object"))
-            .replace("BRIEF⯂", T::__DOCS.lines().next().unwrap_or_default())
-            .replace("DESC⯂", T::__DOCS);
-        // SAFETY: the godot binding is initialized
-        // #[cfg(since_api = "4.3")]
-        ::godot::sys::interface_fn!(editor_help_load_xml_from_utf8_chars_and_len)(
-            xml.as_ptr().cast(),
-            xml.len() as _,
-        );
-        }
-    }
+pub fn virtual_impl(imethods: impl IntoIterator<Item = Function>) -> String {
+    imethods.into_iter().map(imethod).collect::<String>()
 }
 
 pub fn docs(doc: impl IntoIterator<Item = Attribute>) -> String {

itest/rust/src/register_tests/constant_test.rs

@@ -171,7 +171,7 @@ godot::sys::plugin_add!(
     ::godot::private::ClassPlugin {
         class_name: HasOtherConstants::class_name(),
         item: ::godot::private::PluginItem::InherentImpl {
-            register_documentation: { unsafe fn x() {} x },
+            docs: ["";3],
             register_methods_constants_fn: ::godot::private::ErasedRegisterFn {
                 raw: ::godot::private::callbacks::register_user_methods_constants::<HasOtherConstants>,
             },