Merge pull request #840 from godot-rust/qol/export-codegen

Rewrite `#[var]` + `#[export]` registration to use type-safe API behind scenes

Author: Bromeon

godot-core/src/registry/godot_register_wrappers.rs

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+//! Internal registration machinery used by proc-macro APIs.
+
+use crate::builtin::StringName;
+use crate::global::PropertyUsageFlags;
+use crate::meta::{ClassName, GodotConvert, GodotType, PropertyHintInfo, PropertyInfo};
+use crate::obj::GodotClass;
+use crate::registry::property::Var;
+use crate::sys;
+use godot_ffi::GodotFfi;
+
+pub fn register_var_or_export<C: GodotClass, T: Var>(
+    property_name: &str,
+    getter_name: &str,
+    setter_name: &str,
+    hint_info: PropertyHintInfo,
+    usage: PropertyUsageFlags,
+) {
+    let info = PropertyInfo {
+        variant_type: <<T as GodotConvert>::Via as GodotType>::Ffi::variant_type(),
+        class_name: <T as GodotConvert>::Via::class_name(),
+        property_name: StringName::from(property_name),
+        hint_info,
+        usage,
+    };
+
+    let class_name = C::class_name();
+
+    register_var_or_export_inner(info, class_name, getter_name, setter_name);
+}
+
+fn register_var_or_export_inner(
+    info: PropertyInfo,
+    class_name: ClassName,
+    getter_name: &str,
+    setter_name: &str,
+) {
+    let getter_name = StringName::from(getter_name);
+    let setter_name = StringName::from(setter_name);
+
+    let property_info_sys = info.property_sys();
+
+    unsafe {
+        sys::interface_fn!(classdb_register_extension_class_property)(
+            sys::get_library(),
+            class_name.string_sys(),
+            std::ptr::addr_of!(property_info_sys),
+            setter_name.string_sys(),
+            getter_name.string_sys(),
+        );
+    }
+}

godot-core/src/registry/method.rs

@@ -11,6 +11,7 @@ use sys::interface_fn;
 use crate::builtin::{StringName, Variant};
 use crate::global::MethodFlags;
 use crate::meta::{ClassName, PropertyInfo, VarcallSignatureTuple};
+use crate::obj::GodotClass;
 
 /// Info relating to an argument or return type in a method.
 pub struct MethodParamOrReturnInfo {
@@ -52,14 +53,13 @@ impl ClassMethodInfo {
     /// `call_func` and `ptrcall_func`, if provided, must:
     ///
     /// - Follow the behavior expected from the `method_flags`.
-    pub unsafe fn from_signature<S: VarcallSignatureTuple>(
-        class_name: ClassName,
+    pub unsafe fn from_signature<C: GodotClass, S: VarcallSignatureTuple>(
         method_name: StringName,
         call_func: sys::GDExtensionClassMethodCall,
         ptrcall_func: sys::GDExtensionClassMethodPtrCall,
         method_flags: MethodFlags,
         param_names: &[&str],
-        default_arguments: Vec<Variant>,
+        // default_arguments: Vec<Variant>, - not yet implemented
     ) -> Self {
         let return_value = S::return_info();
         let mut arguments = Vec::new();
@@ -79,13 +79,14 @@ impl ClassMethodInfo {
             }))
         }
 
+        let default_arguments = vec![]; // not yet implemented.
         assert!(
             default_arguments.len() <= arguments.len(),
             "cannot have more default arguments than arguments"
         );
 
         Self {
-            class_name,
+            class_name: C::class_name(),
             method_name,
             call_func,
             ptrcall_func,

godot-core/src/registry/mod.rs

@@ -14,3 +14,6 @@ pub mod constant;
 pub mod method;
 pub mod plugin;
 pub mod property;
+
+#[doc(hidden)]
+pub mod godot_register_wrappers;

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

@@ -118,20 +118,16 @@ pub fn make_method_registration(
             #varcall_fn_decl;
             #ptrcall_fn_decl;
 
-            // SAFETY:
-            // `get_varcall_func` upholds all the requirements for `call_func`.
-            // `get_ptrcall_func` upholds all the requirements for `ptrcall_func`
+            // SAFETY: varcall_fn + ptrcall_fn interpret their in/out parameters correctly.
             let method_info = unsafe {
-                ClassMethodInfo::from_signature::<Sig>(
-                    #class_name::class_name(),
+                ClassMethodInfo::from_signature::<#class_name, Sig>(
                     method_name,
                     Some(varcall_fn),
                     Some(ptrcall_fn),
                     #method_flags,
                     &[
                         #( #param_ident_strs ),*
                     ],
-                    Vec::new()
                 )
             };
 

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

@@ -8,7 +8,6 @@
 //! Parsing the `var` and `export` attributes on fields.
 
 use crate::class::{Field, FieldVar, Fields, GetSet, GetterSetterImpl, UsageFlags};
-use crate::util;
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 
@@ -38,8 +37,6 @@ impl FieldHint {
 }
 
 pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
-    let class_name_obj = util::class_name_obj(class_name);
-
     let mut getter_setter_impls = Vec::new();
     let mut export_tokens = Vec::new();
 
@@ -66,8 +63,6 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
             continue;
         };
 
-        let field_variant_type = util::property_variant_type(field_type);
-        let field_class_name = util::property_variant_class_name(field_type);
         let field_name = field_ident.to_string();
 
         let FieldVar {
@@ -104,47 +99,32 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
         let hint = match hint {
             FieldHint::Inferred => {
                 if let Some(export_hint) = export_hint {
-                    quote! {
-                        {
-                            let ::godot::meta::PropertyHintInfo { hint, hint_string } = #export_hint;
-                            (hint, hint_string)
-                        }
-                    }
+                    quote! { #export_hint }
                 } else if export.is_some() {
-                    quote! {
-                        {
-                            let export_hint = <#field_type as ::godot::register::property::Export>::export_hint();
-                            (export_hint.hint, export_hint.hint_string)
-                        }
-                    }
+                    quote! { <#field_type as ::godot::register::property::Export>::export_hint() }
                 } else {
-                    quote! {
-                        {
-                            let export_hint = <#field_type as ::godot::register::property::Var>::var_hint();
-                            (export_hint.hint, export_hint.hint_string)
-                        }
-                    }
+                    quote! { <#field_type as ::godot::register::property::Var>::var_hint() }
                 }
             }
             FieldHint::Hint(hint) => {
                 let hint_string = if let Some(export_hint) = export_hint {
                     quote! { #export_hint.hint_string }
                 } else {
-                    quote! { :godot::builtin::GString::new() }
+                    quote! { ::godot::builtin::GString::new() }
                 };
 
                 quote! {
-                    (
-                        ::godot::global::PropertyHint::#hint,
-                        #hint_string
-                    )
+                    ::godot::meta::PropertyHintInfo {
+                        hint: ::godot::global::PropertyHint::#hint,
+                        hint_string: #hint_string,
+                    }
                 }
             }
             FieldHint::HintWithString { hint, hint_string } => quote! {
-                (
-                    ::godot::global::PropertyHint::#hint,
-                    ::godot::builtin::GString::from(#hint_string)
-                )
+                ::godot::meta::PropertyHintInfo {
+                    hint: ::godot::global::PropertyHint::#hint,
+                    hint_string: ::godot::builtin::GString::from(#hint_string),
+                }
             },
         };
 
@@ -160,36 +140,13 @@ pub fn make_property_impl(class_name: &Ident, fields: &Fields) -> TokenStream {
         );
 
         export_tokens.push(quote! {
-            use ::godot::sys::GodotFfi;
-
-            let (hint, hint_string) = #hint;
-            let usage = #usage_flags;
-
-            let property_info = ::godot::meta::PropertyInfo {
-                variant_type: #field_variant_type,
-                class_name: #field_class_name,
-                property_name: #field_name.into(),
-                hint_info: ::godot::meta::PropertyHintInfo {
-                    hint,
-                    hint_string,
-                },
-                usage,
-            };
-
-            let getter_name = ::godot::builtin::StringName::from(#getter_name);
-            let setter_name = ::godot::builtin::StringName::from(#setter_name);
-
-            let property_info_sys = property_info.property_sys();
-
-            unsafe {
-                ::godot::sys::interface_fn!(classdb_register_extension_class_property)(
-                    ::godot::sys::get_library(),
-                    #class_name_obj.string_sys(),
-                    std::ptr::addr_of!(property_info_sys),
-                    setter_name.string_sys(),
-                    getter_name.string_sys(),
-                );
-            }
+            ::godot::register::private::register_var_or_export::<#class_name, #field_type>(
+                #field_name,
+                #getter_name,
+                #setter_name,
+                #hint,
+                #usage_flags,
+            );
         });
     }
 

godot-macros/src/util/mod.rs

@@ -32,16 +32,6 @@ pub fn class_name_obj(class: &impl ToTokens) -> TokenStream {
     quote! { <#class as ::godot::obj::GodotClass>::class_name() }
 }
 
-pub fn property_variant_type(property_type: &impl ToTokens) -> TokenStream {
-    let property_type = property_type.to_token_stream();
-    quote! { <<#property_type as ::godot::meta::GodotConvert>::Via as ::godot::meta::GodotType>::Ffi::variant_type() }
-}
-
-pub fn property_variant_class_name(property_type: &impl ToTokens) -> TokenStream {
-    let property_type = property_type.to_token_stream();
-    quote! { <<#property_type as ::godot::meta::GodotConvert>::Via as ::godot::meta::GodotType>::class_name() }
-}
-
 pub fn bail_fn<R, T>(msg: impl AsRef<str>, tokens: T) -> ParseResult<R>
 where
     T: Spanned,

godot/src/lib.rs

@@ -178,6 +178,7 @@ pub mod register {
     /// Re-exports used by proc-macro API.
     #[doc(hidden)]
     pub mod private {
+        pub use godot_core::registry::godot_register_wrappers::*;
         pub use godot_core::registry::{constant, method};
     }
 }