fix: Allow generated methods to be reused by other properties

- Add list of methods pending generation
- Perform a lookup in the pending methods if they aren't found in the bridge
- Use name of pending method if found

Author: BenFordTytherington

crates/cxx-qt-gen/src/generator/naming/property.rs

@@ -126,32 +126,32 @@ fn capitalise_first(str: String) -> String {
 }
 
 /// For a given property name generate the getter name
-fn getter_name_from_property(name: &Name) -> Name {
+pub fn getter_name_from_property(name: &Name) -> Name {
     name.clone()
         .with_cxx_name(format!("get{}", capitalise_first(name.cxx_unqualified())))
 }
 
 /// For a given property name generate the setter name
-fn setter_name_from_property(name: &Name) -> Name {
+pub fn setter_name_from_property(name: &Name) -> Name {
     name.clone()
         .with_rust_name(format_ident!("set_{}", name.rust_unqualified()))
         .with_cxx_name(format!("set{}", capitalise_first(name.cxx_unqualified())))
 }
 
 /// For a given property name generate the notify signal name
-fn notify_name_from_property(name: &Name) -> Name {
+pub fn notify_name_from_property(name: &Name) -> Name {
     name.clone()
         .with_rust_name(format_ident!("{}_changed", name.rust_unqualified()))
         .with_cxx_name(format!("{}Changed", name.cxx_unqualified()))
 }
 
 #[cfg(test)]
 pub mod tests {
-    use syn::parse_quote;
-
     use super::*;
     use crate::parser::property::QPropertyFlags;
     use crate::parser::qobject::ParsedQObject;
+    use crate::parser::CaseConversion;
+    use syn::{parse_quote, ItemStruct};
 
     pub fn create_i32_qpropertyname() -> QPropertyNames {
         let property = ParsedQProperty {
@@ -167,6 +167,21 @@ pub mod tests {
             .expect("Failed to create QPropertyNames")
     }
 
+    #[test]
+    fn test_invalid_custom_signal() {
+        let input: ItemStruct = parse_quote! {
+            #[qproperty(T, reused_prop, READ, WRITE, NOTIFY = unknown_signal)]
+            struct MyStruct;
+        };
+        let property = ParsedQProperty::parse(&input.attrs[0], CaseConversion::none()).unwrap();
+
+        let obj = ParsedQObject::mock();
+
+        let structured_qobject = StructuredQObject::mock(&obj);
+        let qproperty_names = QPropertyNames::try_from_property(&property, &structured_qobject);
+        assert!(qproperty_names.is_err());
+    }
+
     #[test]
     fn test_parsed_property() {
         let names = create_i32_qpropertyname();

crates/cxx-qt-gen/src/generator/structuring/qobject.rs

@@ -22,6 +22,8 @@ pub struct StructuredQObject<'a> {
     pub inherited_methods: Vec<&'a ParsedInheritedMethod>,
     pub signals: Vec<&'a ParsedSignal>,
     pub constructors: Vec<&'a Constructor>,
+    pub pending_methods: Vec<Name>,
+    pub pending_signals: Vec<Name>,
     pub threading: bool,
 }
 
@@ -40,13 +42,27 @@ impl<'a> StructuredQObject<'a> {
 
     /// Creates a [StructuredQObject] from a [ParsedQObject] with empty enum, method and signal collections
     pub fn from_qobject(qobject: &'a ParsedQObject) -> Self {
+        let pending_methods = qobject
+            .properties
+            .iter()
+            .flat_map(|property| property.pending_methods())
+            .collect();
+
+        let pending_signals = qobject
+            .properties
+            .iter()
+            .flat_map(|property| property.pending_signals())
+            .collect();
+
         Self {
             declaration: qobject,
             qenums: vec![],
             methods: vec![],
             inherited_methods: vec![],
             signals: vec![],
             constructors: vec![],
+            pending_methods,
+            pending_signals,
             threading: false,
         }
     }
@@ -55,12 +71,14 @@ impl<'a> StructuredQObject<'a> {
     pub fn method_lookup(&self, id: &Ident) -> Result<Name> {
         lookup(&self.methods, id, |method| &method.name)
             .or_else(|| lookup(&self.inherited_methods, id, |inherited| &inherited.name)) // fallback to searching inherited methods
+            .or_else(|| lookup(&self.pending_methods, id, |pending| pending))
             .ok_or_else(|| not_found_error("Method", id))
     }
 
     /// Returns the name of the signal with the provided Rust ident if it exists, or an error
     pub fn signal_lookup(&self, id: &Ident) -> Result<Name> {
         lookup(&self.signals, id, |signal| &signal.name)
+            .or_else(|| lookup(&self.pending_signals, id, |pending| pending))
             .ok_or_else(|| not_found_error("Signal", id))
     }
 

crates/cxx-qt-gen/src/parser/property.rs

@@ -13,6 +13,9 @@ use syn::{
     Attribute, Expr, Ident, Meta, MetaNameValue, Result, Token, Type,
 };
 
+use crate::generator::naming::property::{
+    getter_name_from_property, notify_name_from_property, setter_name_from_property,
+};
 #[cfg(test)]
 use syn::ItemStruct;
 
@@ -224,6 +227,32 @@ impl ParsedQProperty {
             }
         })
     }
+
+    /// Generates a list of method names which will be generated for this property
+    pub fn pending_methods(&self) -> Vec<Name> {
+        let mut pending = vec![];
+
+        if let FlagState::Auto = &self.flags.read {
+            pending.push(getter_name_from_property(&self.name));
+        }
+
+        if let Some(FlagState::Auto) = &self.flags.write {
+            pending.push(setter_name_from_property(&self.name));
+        }
+
+        pending
+    }
+
+    /// Generates a list of signal names which will be generated for this property
+    pub fn pending_signals(&self) -> Vec<Name> {
+        let mut pending = vec![];
+
+        if let Some(FlagState::Auto) = &self.flags.notify {
+            pending.push(notify_name_from_property(&self.name));
+        }
+
+        pending
+    }
 }
 #[cfg(test)]
 pub fn mock_property(input: ItemStruct) -> ParsedQProperty {

crates/cxx-qt-gen/test_inputs/properties.rs

@@ -20,6 +20,7 @@ mod ffi {
             cxx_name = "renamedProperty",
             rust_name = "renamed_property"
         )]
+        #[qproperty(i32, reused_signal_prop, READ, WRITE, NOTIFY = trivial_changed)]
         #[qproperty(i32, named_prop_2, rust_name = "renamed_property_2")]
         #[qproperty(i32, custom_on_changed_prop, cxx_name = "customOnChangedProp", READ, WRITE, NOTIFY = my_on_changed)]
         #[qproperty(i32, const_prop, cxx_name = "constProp", READ, CONSTANT)]

crates/cxx-qt-gen/test_outputs/properties.h

@@ -132,6 +132,8 @@ class MyObject
   Q_PROPERTY(::std::int32_t readonlyProp READ getReadonlyProp)
   Q_PROPERTY(::std::int32_t renamedProperty READ getRenamedProperty WRITE
                setRenamedProperty NOTIFY renamedPropertyChanged)
+  Q_PROPERTY(::std::int32_t reusedSignalProp READ getReusedSignalProp WRITE
+               setReusedSignalProp NOTIFY trivialChanged)
   Q_PROPERTY(::std::int32_t named_prop_2 READ getNamed_prop_2 WRITE
                setNamed_prop_2 NOTIFY named_prop_2Changed)
   Q_PROPERTY(::std::int32_t customOnChangedProp READ getCustomOnChangedProp
@@ -156,6 +158,8 @@ class MyObject
   ::std::int32_t const& getReadonlyProp() const noexcept;
   ::std::int32_t const& getRenamedProperty() const noexcept;
   Q_SLOT void setRenamedProperty(::std::int32_t value) noexcept;
+  ::std::int32_t const& getReusedSignalProp() const noexcept;
+  Q_SLOT void setReusedSignalProp(::std::int32_t value) noexcept;
   ::std::int32_t const& getNamed_prop_2() const noexcept;
   Q_SLOT void setNamed_prop_2(::std::int32_t value) noexcept;
   ::std::int32_t const& getCustomOnChangedProp() const noexcept;

crates/cxx-qt-gen/test_outputs/properties.rs

@@ -82,6 +82,16 @@ mod ffi {
         #[namespace = "cxx_qt::my_object"]
         fn set_renamed_property(self: Pin<&mut MyObject>, value: i32);
     }
+    extern "Rust" {
+        #[cxx_name = "getReusedSignalProp"]
+        #[namespace = "cxx_qt::my_object"]
+        unsafe fn reused_signal_prop<'a>(self: &'a MyObject) -> &'a i32;
+    }
+    extern "Rust" {
+        #[cxx_name = "setReusedSignalProp"]
+        #[namespace = "cxx_qt::my_object"]
+        fn set_reused_signal_prop(self: Pin<&mut MyObject>, value: i32);
+    }
     extern "Rust" {
         #[cxx_name = "getNamed_prop_2"]
         #[namespace = "cxx_qt::my_object"]
@@ -505,6 +515,25 @@ impl ffi::MyObject {
         self.as_mut().renamed_property_changed();
     }
 }
+impl ffi::MyObject {
+    #[doc = "Getter for the Q_PROPERTY "]
+    #[doc = "reused_signal_prop"]
+    pub fn reused_signal_prop(&self) -> &i32 {
+        &self.reused_signal_prop
+    }
+}
+impl ffi::MyObject {
+    #[doc = "Setter for the Q_PROPERTY "]
+    #[doc = "reused_signal_prop"]
+    pub fn set_reused_signal_prop(mut self: core::pin::Pin<&mut Self>, value: i32) {
+        use cxx_qt::CxxQtType;
+        if self.reused_signal_prop == value {
+            return;
+        }
+        self.as_mut().rust_mut().reused_signal_prop = value;
+        self.as_mut().trivial_changed();
+    }
+}
 impl ffi::MyObject {
     #[doc = "Getter for the Q_PROPERTY "]
     #[doc = "renamed_property_2"]