Use Name for QSignal parsing & generation

crates/cxx-qt-gen/src/generator/cpp/property/signal.rs

@@ -3,11 +3,10 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use proc_macro2::Span;
-use syn::{ForeignItemFn, Ident};
+use syn::ForeignItemFn;
 
 use crate::{
-    generator::naming::{property::QPropertyNames, qobject::QObjectNames, CombinedIdent},
+    generator::naming::{property::QPropertyNames, qobject::QObjectNames},
     parser::signals::ParsedSignal,
 };
 
@@ -24,10 +23,7 @@ pub fn generate(idents: &QPropertyNames, qobject_idents: &QObjectNames) -> Parse
     };
     ParsedSignal::from_property_method(
         method,
-        CombinedIdent {
-            cpp: Ident::new(&idents.notify.cxx_unqualified(), Span::call_site()),
-            rust: idents.notify.rust_unqualified().clone(),
-        },
+        idents.notify.clone(),
         qobject_idents.name.rust_unqualified().clone(),
     )
 }

crates/cxx-qt-gen/src/generator/cpp/signal.rs

@@ -8,7 +8,7 @@ use crate::{
         cpp::{fragment::CppFragment, qobject::GeneratedCppQObjectBlocks},
         naming::{
             qobject::QObjectNames,
-            signals::{QSignalHelperName, QSignalName},
+            signals::{QSignalHelperNames, QSignalNames},
         },
     },
     naming::{cpp::syn_type_to_cpp_type, Name, TypeNames},
@@ -94,11 +94,11 @@ pub fn generate_cpp_signal(
     let qobject_ident_namespaced = qobject_name.cxx_qualified();
 
     // Prepare the idents
-    let idents = QSignalName::from(signal);
-    let idents_helper = QSignalHelperName::new(&idents, qobject_name)?;
+    let idents = QSignalNames::from(signal);
+    let idents_helper = QSignalHelperNames::new(&idents, qobject_name)?;
 
-    let signal_ident = idents.name.cpp;
-    let free_connect_ident_cpp = idents_helper.connect_name.cpp;
+    let signal_ident = idents.name.cxx_unqualified();
+    let free_connect_ident_cpp = idents_helper.connect_name.cxx_unqualified();
 
     // Retrieve the parameters for the signal
     let parameters = parameter_types_and_values(&signal.parameters, type_names, qobject_name)?;
@@ -213,7 +213,7 @@ pub fn generate_cpp_signals(
 mod tests {
     use super::*;
 
-    use crate::generator::naming::{qobject::tests::create_qobjectname, CombinedIdent};
+    use crate::generator::naming::qobject::tests::create_qobjectname;
     use crate::parser::parameter::ParsedFunctionParameter;
     use indoc::indoc;
     use pretty_assertions::assert_str_eq;
@@ -238,10 +238,7 @@ mod tests {
                     ty: parse_quote! { UniquePtr<QColor> },
                 },
             ],
-            ident: CombinedIdent {
-                cpp: format_ident!("dataChanged"),
-                rust: format_ident!("data_changed"),
-            },
+            name: Name::new(format_ident!("data_changed")).with_cxx_name("dataChanged".to_owned()),
             safe: true,
             inherit: false,
             private: false,
@@ -338,10 +335,7 @@ mod tests {
                 ident: format_ident!("mapped"),
                 ty: parse_quote! { A },
             }],
-            ident: CombinedIdent {
-                cpp: format_ident!("dataChanged"),
-                rust: format_ident!("data_changed"),
-            },
+            name: Name::new(format_ident!("data_changed")).with_cxx_name("dataChanged".to_owned()),
             safe: true,
             inherit: false,
             private: false,
@@ -434,10 +428,7 @@ mod tests {
             qobject_ident: format_ident!("MyObject"),
             mutable: true,
             parameters: vec![],
-            ident: CombinedIdent {
-                cpp: format_ident!("baseName"),
-                rust: format_ident!("existing_signal"),
-            },
+            name: Name::new(format_ident!("existing_signal")).with_cxx_name("baseName".to_owned()),
             safe: true,
             inherit: true,
             private: false,
@@ -520,10 +511,8 @@ mod tests {
             qobject_ident: format_ident!("ObjRust"),
             mutable: true,
             parameters: vec![],
-            ident: CombinedIdent {
-                cpp: format_ident!("signalRustName"),
-                rust: format_ident!("signal_rust_name"),
-            },
+            name: Name::new(format_ident!("signal_rust_name"))
+                .with_cxx_name("signalRustName".to_owned()),
             safe: true,
             inherit: true,
             private: false,
@@ -611,10 +600,8 @@ mod tests {
             qobject_ident: format_ident!("ObjRust"),
             mutable: true,
             parameters: vec![],
-            ident: CombinedIdent {
-                cpp: format_ident!("signalCxxName"),
-                rust: format_ident!("signal_rust_name"),
-            },
+            name: Name::new(format_ident!("signal_rust_name"))
+                .with_cxx_name("signalCxxName".to_owned()),
             safe: true,
             inherit: true,
             private: false,
@@ -641,7 +628,7 @@ mod tests {
             r#"
             namespace mynamespace::rust::cxxqtgen1 {
             ::QMetaObject::Connection
-            ObjRust_signalCxxNameConnect(mynamespace::ObjCpp& self, ::mynamespace::rust::cxxqtgen1::ObjRustCxxQtSignalHandlersignalCxxName closure, ::Qt::ConnectionType type);
+            ObjCpp_signalCxxNameConnect(mynamespace::ObjCpp& self, ::mynamespace::rust::cxxqtgen1::ObjRustCxxQtSignalHandlersignalCxxName closure, ::Qt::ConnectionType type);
             } // namespace mynamespace::rust::cxxqtgen1
             "#}
         );
@@ -675,7 +662,7 @@ mod tests {
 
             namespace mynamespace::rust::cxxqtgen1 {
             ::QMetaObject::Connection
-            ObjRust_signalCxxNameConnect(mynamespace::ObjCpp& self, ::mynamespace::rust::cxxqtgen1::ObjRustCxxQtSignalHandlersignalCxxName closure, ::Qt::ConnectionType type)
+            ObjCpp_signalCxxNameConnect(mynamespace::ObjCpp& self, ::mynamespace::rust::cxxqtgen1::ObjRustCxxQtSignalHandlersignalCxxName closure, ::Qt::ConnectionType type)
             {
                 return ::QObject::connect(
                     &self,

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

@@ -2,46 +2,42 @@
 // SPDX-FileContributor: Andrew Hayzen <andrew.hayzen@kdab.com>
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
-use crate::parser::signals::ParsedSignal;
-use crate::{generator::naming::CombinedIdent, naming::Name};
+use crate::{naming::Name, parser::signals::ParsedSignal};
 use convert_case::{Case, Casing};
 use quote::format_ident;
 use syn::{Ident, Result};
 
 /// Names for parts of a Q_SIGNAL
-pub struct QSignalName {
-    pub name: CombinedIdent,
-    pub connect_name: CombinedIdent,
+pub struct QSignalNames {
+    pub name: Name,
+    pub connect_name: Name,
     pub on_name: Ident,
 }
 
-impl From<&ParsedSignal> for QSignalName {
+impl From<&ParsedSignal> for QSignalNames {
     fn from(signal: &ParsedSignal) -> Self {
         Self {
-            name: signal.ident.clone(),
-            connect_name: CombinedIdent::connect_from_signal(&signal.ident),
-            on_name: on_from_signal(&signal.ident.rust),
+            name: signal.name.clone(),
+            connect_name: connect_name_from_signal(&signal.name),
+            on_name: on_from_signal(signal.name.rust_unqualified()),
         }
     }
 }
 
-fn on_from_signal(ident: &Ident) -> Ident {
-    format_ident!("on_{}", ident.to_string().to_case(Case::Snake))
+fn connect_name_from_signal(name: &Name) -> Name {
+    name.clone()
+        .with_rust_name(format_ident!("connect_{}", name.rust_unqualified()))
+        // Use signalConnect instead of onSignal here so that we don't
+        // create a C++ name that is similar to the QML naming scheme for signals
+        .with_cxx_name(format!("{}Connect", name.cxx_unqualified()))
 }
 
-impl CombinedIdent {
-    fn connect_from_signal(ident: &CombinedIdent) -> Self {
-        Self {
-            // Use signalConnect instead of onSignal here so that we don't
-            // create a C++ name that is similar to the QML naming scheme for signals
-            cpp: format_ident!("{}Connect", ident.cpp.to_string().to_case(Case::Camel)),
-            rust: format_ident!("connect_{}", ident.rust.to_string().to_case(Case::Snake)),
-        }
-    }
+fn on_from_signal(ident: &Ident) -> Ident {
+    format_ident!("on_{}", ident.to_string().to_case(Case::Snake))
 }
 
-pub struct QSignalHelperName {
-    pub connect_name: CombinedIdent,
+pub struct QSignalHelperNames {
+    pub connect_name: Name,
     pub function_call: Ident,
     pub function_drop: Ident,
     pub handler_alias: Ident,
@@ -51,9 +47,9 @@ pub struct QSignalHelperName {
     pub struct_param: Ident,
 }
 
-impl QSignalHelperName {
-    pub fn new(idents: &QSignalName, qobject_name: &Name) -> Result<Self> {
-        let signal_ident = &idents.name.cpp;
+impl QSignalHelperNames {
+    pub fn new(idents: &QSignalNames, qobject_name: &Name) -> Result<Self> {
+        let signal_ident = &idents.name.cxx_unqualified();
         let qobject_ident = qobject_name.rust_unqualified().to_string();
         let handler_alias = format_ident!("{qobject_ident}CxxQtSignalHandler{signal_ident}");
         let namespace = {
@@ -77,13 +73,21 @@ impl QSignalHelperName {
             namespace.join("::")
         };
 
+        let connect_name = Name::new(format_ident!(
+            "{}_{}",
+            qobject_name.rust_unqualified(),
+            idents.connect_name.rust_unqualified()
+        ))
+        .with_cxx_name(format!(
+            "{}_{}",
+            qobject_name.cxx_unqualified(),
+            idents.connect_name.cxx_unqualified()
+        ));
+
         // TODO: in the future we might improve the naming of the methods
         // to avoid collisions (maybe use a separator similar to how CXX uses $?)
         Ok(Self {
-            connect_name: CombinedIdent {
-                cpp: format_ident!("{}_{}", qobject_ident, idents.connect_name.cpp),
-                rust: format_ident!("{}_{}", qobject_ident, idents.connect_name.rust),
-            },
+            connect_name,
             function_drop: format_ident!("drop_{qobject_ident}_signal_handler_{signal_ident}"),
             function_call: format_ident!("call_{qobject_ident}_signal_handler_{signal_ident}"),
             handler_alias_namespaced: format!("::{namespace}::{handler_alias}"),
@@ -110,22 +114,22 @@ mod tests {
             qobject_ident: format_ident!("MyObject"),
             mutable: true,
             parameters: vec![],
-            ident: CombinedIdent {
-                cpp: format_ident!("dataChanged"),
-                rust: format_ident!("data_changed"),
-            },
+            name: Name::new(format_ident!("data_changed")).with_cxx_name("dataChanged".to_owned()),
             safe: true,
             inherit: false,
             private: false,
         };
 
-        let names = QSignalName::from(&qsignal);
-        assert_eq!(names.name.cpp, format_ident!("dataChanged"));
-        assert_eq!(names.name.rust, format_ident!("data_changed"));
-        assert_eq!(names.connect_name.cpp, format_ident!("dataChangedConnect"));
+        let names = QSignalNames::from(&qsignal);
+        assert_eq!(names.name.cxx_unqualified(), "dataChanged");
+        assert_eq!(
+            names.name.rust_unqualified(),
+            &format_ident!("data_changed")
+        );
+        assert_eq!(names.connect_name.cxx_unqualified(), "dataChangedConnect");
         assert_eq!(
-            names.connect_name.rust,
-            format_ident!("connect_data_changed")
+            names.connect_name.rust_unqualified(),
+            &format_ident!("connect_data_changed")
         );
         assert_eq!(names.on_name, format_ident!("on_data_changed"));
     }
@@ -140,22 +144,22 @@ mod tests {
             qobject_ident: format_ident!("MyObject"),
             mutable: true,
             parameters: vec![],
-            ident: CombinedIdent {
-                cpp: format_ident!("baseName"),
-                rust: format_ident!("existing_signal"),
-            },
+            name: Name::new(format_ident!("existing_signal")).with_cxx_name("baseName".to_owned()),
             safe: true,
             inherit: false,
             private: false,
         };
 
-        let names = QSignalName::from(&qsignal);
-        assert_eq!(names.name.cpp, format_ident!("baseName"));
-        assert_eq!(names.name.rust, format_ident!("existing_signal"));
-        assert_eq!(names.connect_name.cpp, format_ident!("baseNameConnect"));
+        let names = QSignalNames::from(&qsignal);
+        assert_eq!(names.name.cxx_unqualified(), "baseName");
+        assert_eq!(
+            names.name.rust_unqualified(),
+            &format_ident!("existing_signal")
+        );
+        assert_eq!(names.connect_name.cxx_unqualified(), "baseNameConnect");
         assert_eq!(
-            names.connect_name.rust,
-            format_ident!("connect_existing_signal")
+            names.connect_name.rust_unqualified(),
+            &format_ident!("connect_existing_signal")
         );
         assert_eq!(names.on_name, format_ident!("on_existing_signal"));
     }

crates/cxx-qt-gen/src/generator/rust/property/mod.rs

@@ -287,8 +287,8 @@ mod tests {
 
                     #[doc(hidden)]
                     #[namespace = "rust::cxxqtgen1"]
-                    #[rust_name = "MyObject_connect_trivial_property_changed"]
-                    fn MyObject_trivialPropertyChangedConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlertrivialPropertyChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection;
+                    #[cxx_name = "MyObject_trivialPropertyChangedConnect"]
+                    fn MyObject_connect_trivial_property_changed(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlertrivialPropertyChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection;
                 }
             },
         );
@@ -412,8 +412,8 @@ mod tests {
 
                     #[doc(hidden)]
                     #[namespace = "rust::cxxqtgen1"]
-                    #[rust_name = "MyObject_connect_opaque_property_changed"]
-                    fn MyObject_opaquePropertyChangedConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandleropaquePropertyChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection;
+                    #[cxx_name = "MyObject_opaquePropertyChangedConnect"]
+                    fn MyObject_connect_opaque_property_changed(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandleropaquePropertyChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection;
                 }
             },
         );
@@ -537,8 +537,8 @@ mod tests {
 
                     #[doc(hidden)]
                     #[namespace = "rust::cxxqtgen1"]
-                    #[rust_name = "MyObject_connect_unsafe_property_changed"]
-                    fn MyObject_unsafePropertyChangedConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerunsafePropertyChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection;
+                    #[cxx_name = "MyObject_unsafePropertyChangedConnect"]
+                    fn MyObject_connect_unsafe_property_changed(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerunsafePropertyChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection;
                 }
             },
         );

crates/cxx-qt-gen/src/generator/rust/property/signal.rs

@@ -3,11 +3,10 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use proc_macro2::Span;
-use syn::{ForeignItemFn, Ident};
+use syn::ForeignItemFn;
 
 use crate::{
-    generator::naming::{property::QPropertyNames, qobject::QObjectNames, CombinedIdent},
+    generator::naming::{property::QPropertyNames, qobject::QObjectNames},
     parser::signals::ParsedSignal,
 };
 
@@ -24,10 +23,7 @@ pub fn generate(idents: &QPropertyNames, qobject_idents: &QObjectNames) -> Parse
     };
     ParsedSignal::from_property_method(
         method,
-        CombinedIdent {
-            cpp: Ident::new(&idents.notify.cxx_unqualified(), Span::call_site()),
-            rust: idents.notify.rust_unqualified().clone(),
-        },
+        idents.notify.clone(),
         qobject_idents.name.rust_unqualified().clone(),
     )
 }