Always implement WithUserSignals for user classes, if Base<T> field is present

Author: Bromeon

godot-core/src/obj/gd.rs

@@ -326,7 +326,8 @@ impl<T: GodotClass> Gd<T> {
 
     /// Equivalent to [`upcast::<Object>()`][Self::upcast], but without bounds.
     // Not yet public because it might need _mut/_ref overloads, and 6 upcast methods are a bit much...
-    pub(crate) fn upcast_object(self) -> Gd<classes::Object> {
+    #[doc(hidden)] // no public API, but used by #[signal].
+    pub fn upcast_object(self) -> Gd<classes::Object> {
         self.owned_cast()
             .expect("Upcast to Object failed. This is a bug; please report it.")
     }

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

@@ -211,7 +211,7 @@ pub fn make_signal_registrations(
     }
 
     #[cfg(since_api = "4.2")]
-    let signal_symbols = make_signal_symbols(class_name, collection_api);
+    let signal_symbols = Some(make_signal_symbols(class_name, collection_api));
     #[cfg(before_api = "4.2")]
     let signal_symbols = None;
 
@@ -311,7 +311,7 @@ impl SignalCollection {
             .push(make_signal_individual_struct(details))
     }
 
-    pub fn is_empty(&self) -> bool {
+    fn is_empty(&self) -> bool {
         self.individual_structs.is_empty()
     }
 }
@@ -380,18 +380,33 @@ fn make_signal_individual_struct(details: &SignalDetails) -> TokenStream {
 
 /// Generates symbolic API for signals:
 /// * collection (unspecified-name struct holding methods to access each signal)
+///   * can be absent if the class declares no own #[signal]s.
 /// * individual signal types
 /// * trait impls
 fn make_signal_symbols(
     class_name: &Ident,
     collection_api: SignalCollection,
     // max_visibility: SignalVisibility,
-) -> Option<TokenStream> {
-    // Future note: if we add Rust->Rust inheritance, then the WithSignals trait must be unconditionally implemented.
+) -> TokenStream {
+    // If class declares no own signals, just implement the traits, no collection APIs.
     if collection_api.is_empty() {
-        return None;
+        let with_signals_impl = make_with_signals_impl_delegated_to_base(class_name);
+        let base_field_macro = util::format_class_base_field_macro(class_name);
+
+        // base_field_macro! is a macro that expands to all input tokens if the class declares a Base<T> field, and to nothing otherwise.
+        // This makes sure that WithSignals is only implemented for classes with a base field, and avoids compile errors about it.
+        // Note: this doesn't work with `impl nested::MyClass` style remote impls, which can be enabled via #[hint(signals=true/false)].
+
+        return quote! {
+            #base_field_macro! {
+                #with_signals_impl
+            }
+        };
     }
 
+    // For the regular flow, we *expect* that a Base<T> field is present. Having a concise error message "missing Base<T> field" is
+    // better than magic tricks, since the user explicitly asked for #[signal] and thus should be guided to complete the missing parts.
+
     let collection_struct_name = format_ident!("__godot_Signals_{}", class_name);
     let collection_struct_methods = &collection_api.provider_methods;
     let with_signals_impl = make_with_signals_impl(class_name, &collection_struct_name);
@@ -455,9 +470,10 @@ fn make_signal_symbols(
         #( #individual_structs )*
     };
 
-    Some(code)
+    code
 }
 
+/// Declare `impl WithSignals` and `impl WithUserSignals` with own signal collection.
 fn make_with_signals_impl(class_name: &Ident, collection_struct_name: &Ident) -> TokenStream {
     quote! {
         impl ::godot::obj::WithSignals for #class_name {
@@ -467,10 +483,10 @@ fn make_with_signals_impl(class_name: &Ident, collection_struct_name: &Ident) ->
             type __SignalObj<'c> = ::godot::private::UserSignalObject<'c, Self>;
 
             #[doc(hidden)]
-            fn __signals_from_external(external: &mut Gd<Self>) -> Self::SignalCollection<'_, Self> {
+            fn __signals_from_external(external: &mut ::godot::obj::Gd<Self>) -> Self::SignalCollection<'_, Self> {
                 Self::SignalCollection {
                     __internal_obj: Some(::godot::private::UserSignalObject::External {
-                        gd: external.clone().upcast::<Object>()
+                        gd: external.clone().upcast_object()
                     })
                 }
             }
@@ -486,6 +502,39 @@ fn make_with_signals_impl(class_name: &Ident, collection_struct_name: &Ident) ->
     }
 }
 
+/// Declare `impl WithSignals` and `impl WithUserSignals`, but without own signal collection; instead delegate to base collection.
+fn make_with_signals_impl_delegated_to_base(class_name: &Ident) -> TokenStream {
+    quote! {
+        impl ::godot::obj::WithSignals for #class_name {
+            type SignalCollection<'c, C: ::godot::obj::WithSignals> =
+                <<Self as ::godot::obj::GodotClass>::Base as ::godot::obj::WithSignals>::SignalCollection<'c, C>;
+
+            #[doc(hidden)]
+            type __SignalObj<'c> =
+                <<Self as ::godot::obj::GodotClass>::Base as ::godot::obj::WithSignals>::__SignalObj<'c>;
+
+
+            #[doc(hidden)]
+            fn __signals_from_external(external: &mut ::godot::obj::Gd<Self>) -> Self::SignalCollection<'_, Self> {
+                // This will need updating when allowing Rust->Rust inheritance.
+                Self::SignalCollection {
+                    __internal_obj: Some(external.clone().upcast())
+                }
+            }
+        }
+
+        impl ::godot::obj::WithUserSignals for #class_name {
+            fn signals(&mut self) -> Self::SignalCollection<'_, Self> {
+                // This will need updating when allowing Rust->Rust inheritance.
+                let self_gd = <Self as ::godot::obj::WithBaseField>::to_gd(self);
+                Self::SignalCollection {
+                    __internal_obj: Some(self_gd.upcast()),
+                }
+            }
+        }
+    }
+}
+
 fn make_upcast_deref_impl(class_name: &Ident, collection_struct_name: &Ident) -> TokenStream {
     quote! {
         impl<'c, C: ::godot::obj::WithSignals> std::ops::Deref for #collection_struct_name<'c, C> {

godot-macros/src/class/derive_godot_class.rs

@@ -142,7 +142,9 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         pub struct #funcs_collection_struct_name {}
     };
 
+    // Note: one limitation is that macros don't work for `impl nested::MyClass` blocks.
     let visibility_macro = make_visibility_macro(class_name, class.vis_marker.as_ref());
+    let base_field_macro = make_base_field_macro(class_name, fields.base_field.is_some());
 
     Ok(quote! {
         impl ::godot::obj::GodotClass for #class_name {
@@ -174,6 +176,7 @@ pub fn derive_godot_class(item: venial::Item) -> ParseResult<TokenStream> {
         #user_class_impl
         #init_expecter
         #visibility_macro
+        #base_field_macro
         #( #deprecations )*
         #( #errors )*
 
@@ -211,6 +214,25 @@ fn make_visibility_macro(
     }
 }
 
+/// Generates code for a decl-macro, which evaluates to nothing if the class has no base field.
+fn make_base_field_macro(class_name: &Ident, has_base_field: bool) -> TokenStream {
+    let macro_name = util::format_class_base_field_macro(class_name);
+
+    if has_base_field {
+        quote! {
+            macro_rules! #macro_name {
+                ( $( $tt:tt )* ) => { $( $tt )* };
+            }
+        }
+    } else {
+        quote! {
+            macro_rules! #macro_name {
+                ( $( $tt:tt )* ) => {};
+            }
+        }
+    }
+}
+
 /// Checks at compile time that a function with the given name exists on `Self`.
 #[must_use]
 pub fn make_existence_check(ident: &Ident) -> TokenStream {

godot-macros/src/util/mod.rs

@@ -409,3 +409,8 @@ pub fn format_funcs_collection_struct(class_name: &Ident) -> Ident {
 pub fn format_class_visibility_macro(class_name: &Ident) -> Ident {
     format_ident!("__godot_{class_name}_vis_macro")
 }
+
+/// Returns the name of the macro used to communicate whether the `struct` (class) contains a base field.
+pub fn format_class_base_field_macro(class_name: &Ident) -> Ident {
+    format_ident!("__godot_{class_name}_has_base_field_macro")
+}

itest/rust/src/builtin_tests/containers/signal_test.rs

@@ -327,6 +327,53 @@ fn signal_symbols_engine_inherited_internal() {
     node.free();
 }
 
+// Test that Node signals are accessible from a derived class, when the class itself has no #[signal] declarations.
+// Verifies the code path that only generates the traits, no dedicated signal collection.
+#[cfg(since_api = "4.2")]
+#[itest]
+fn signal_symbols_engine_inherited_no_own_signals(ctx: &crate::framework::TestContext) {
+    let mut node = Receiver::new_alloc();
+
+    // Add to tree, so signals are propagated.
+    ctx.scene_tree.clone().add_child(&node);
+
+    let mut sig = node.signals().renamed();
+    sig.connect_self(|this: &mut Emitter| {
+        this.last_received_int = 887;
+    });
+
+    node.set_name("new name");
+
+    assert_eq!(node.bind().last_received_int, 887);
+
+    // Remove from tree for other tests.
+    node.free();
+}
+
+// Test that trait is implemented even without own #[signal] declarations (to access base signals).
+#[cfg(since_api = "4.2")]
+const fn __type_check<'c>() {
+    // Needs WithUserSignals, not just WithSignals, to allow self.signals().
+    const fn has_with_user_signals<T: godot::obj::WithUserSignals>() {}
+
+    trait SameType {}
+    impl<T> SameType for (T, T) {}
+    const fn is_same_type<T, U>()
+    where
+        (T, U): SameType,
+    {
+    }
+
+    has_with_user_signals::<Receiver>();
+
+    // Checks whether there is no new collection defined, but instead the base collection is reused.
+    // This reduces the amount of proc-macro generated code.
+    is_same_type::<
+        Receiver::SignalCollection<'c, Receiver>,
+        Object::SignalCollection<'c, Receiver>, //.
+    >();
+}
+
 #[itest]
 fn signal_construction_and_id() {
     let mut object = RefCounted::new_gd();
@@ -451,6 +498,8 @@ struct Receiver {
 
 #[godot_api]
 impl Receiver {
+    // Do not declare any #[signal]s here -- explicitly test this implements WithSignal without them.
+
     fn last_received(&self) -> LastReceived {
         self.last_received.get()
     }