PropertNames: Use Name instead of CombinedIdent

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

@@ -3,14 +3,14 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::generator::{cpp::fragment::CppFragment, naming::property::QPropertyName};
+use crate::generator::{cpp::fragment::CppFragment, naming::property::QPropertyNames};
 use indoc::formatdoc;
 
-pub fn generate(idents: &QPropertyName, qobject_ident: &str, return_cxx_ty: &str) -> CppFragment {
+pub fn generate(idents: &QPropertyNames, qobject_ident: &str, return_cxx_ty: &str) -> CppFragment {
     CppFragment::Pair {
         header: format!(
             "{return_cxx_ty} const& {ident_getter}() const;",
-            ident_getter = idents.getter.cpp
+            ident_getter = idents.getter.cxx_unqualified()
         ),
         source: formatdoc!(
             r#"
@@ -21,15 +21,15 @@ pub fn generate(idents: &QPropertyName, qobject_ident: &str, return_cxx_ty: &str
                 return {ident_getter_wrapper}();
             }}
             "#,
-            ident_getter = idents.getter.cpp.to_string(),
-            ident_getter_wrapper = idents.getter_wrapper.cpp.to_string(),
+            ident_getter = idents.getter.cxx_unqualified(),
+            ident_getter_wrapper = idents.getter_wrapper.cxx_unqualified(),
         ),
     }
 }
 
-pub fn generate_wrapper(idents: &QPropertyName, cxx_ty: &str) -> CppFragment {
+pub fn generate_wrapper(idents: &QPropertyNames, cxx_ty: &str) -> CppFragment {
     CppFragment::Header(format!(
         "{cxx_ty} const& {ident_getter_wrapper}() const noexcept;",
-        ident_getter_wrapper = idents.getter_wrapper.cpp
+        ident_getter_wrapper = idents.getter_wrapper.cxx_unqualified()
     ))
 }

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

@@ -3,16 +3,16 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::generator::naming::property::QPropertyName;
+use crate::generator::naming::property::QPropertyNames;
 
 /// Generate the metaobject line for a given property
-pub fn generate(idents: &QPropertyName, cxx_ty: &str) -> String {
+pub fn generate(idents: &QPropertyNames, cxx_ty: &str) -> String {
     format!(
         "Q_PROPERTY({ty} {ident} READ {ident_getter} WRITE {ident_setter} NOTIFY {ident_notify})",
         ty = cxx_ty,
-        ident = idents.name.cpp,
-        ident_getter = idents.getter.cpp,
-        ident_setter = idents.setter.cpp,
-        ident_notify = idents.notify.cpp,
+        ident = idents.name.cxx_unqualified(),
+        ident_getter = idents.getter.cxx_unqualified(),
+        ident_setter = idents.setter.cxx_unqualified(),
+        ident_notify = idents.notify.cxx_unqualified()
     )
 }

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

@@ -5,7 +5,7 @@
 
 use crate::generator::{
     cpp::{qobject::GeneratedCppQObjectBlocks, signal::generate_cpp_signals},
-    naming::{property::QPropertyName, qobject::QObjectNames},
+    naming::{property::QPropertyNames, qobject::QObjectNames},
 };
 use crate::{
     naming::cpp::syn_type_to_cpp_type, naming::TypeNames, parser::property::ParsedQProperty,
@@ -28,7 +28,7 @@ pub fn generate_cpp_properties(
 
     for property in properties {
         // Cache the idents as they are used in multiple places
-        let idents = QPropertyName::from(property);
+        let idents = QPropertyNames::from(property);
         let cxx_ty = syn_type_to_cpp_type(&property.ty, type_names)?;
 
         generated.metaobjects.push(meta::generate(&idents, &cxx_ty));

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

@@ -3,14 +3,14 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use crate::generator::{cpp::fragment::CppFragment, naming::property::QPropertyName};
+use crate::generator::{cpp::fragment::CppFragment, naming::property::QPropertyNames};
 use indoc::formatdoc;
 
-pub fn generate(idents: &QPropertyName, qobject_ident: &str, cxx_ty: &str) -> CppFragment {
+pub fn generate(idents: &QPropertyNames, qobject_ident: &str, cxx_ty: &str) -> CppFragment {
     CppFragment::Pair {
         header: format!(
             "Q_SLOT void {ident_setter}({cxx_ty} const& value);",
-            ident_setter = idents.setter.cpp,
+            ident_setter = idents.setter.cxx_unqualified(),
         ),
         source: formatdoc! {
             r#"
@@ -21,17 +21,17 @@ pub fn generate(idents: &QPropertyName, qobject_ident: &str, cxx_ty: &str) -> Cp
                 {ident_setter_wrapper}(value);
             }}
             "#,
-            ident_setter = idents.setter.cpp,
-            ident_setter_wrapper = idents.setter_wrapper.cpp.to_string(),
+            ident_setter = idents.setter.cxx_unqualified(),
+            ident_setter_wrapper = idents.setter_wrapper.cxx_unqualified(),
         },
     }
 }
 
-pub fn generate_wrapper(idents: &QPropertyName, cxx_ty: &str) -> CppFragment {
+pub fn generate_wrapper(idents: &QPropertyNames, cxx_ty: &str) -> CppFragment {
     CppFragment::Header(format!(
         // Note that we pass T not const T& to Rust so that it is by-value
         // https://github.com/KDAB/cxx-qt/issues/463
         "void {ident_setter_wrapper}({cxx_ty} value) noexcept;",
-        ident_setter_wrapper = idents.setter_wrapper.cpp
+        ident_setter_wrapper = idents.setter_wrapper.cxx_unqualified()
     ))
 }

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

@@ -3,27 +3,31 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
-use syn::ForeignItemFn;
+use proc_macro2::Span;
+use syn::{ForeignItemFn, Ident};
 
 use crate::{
-    generator::naming::{property::QPropertyName, qobject::QObjectNames},
+    generator::naming::{property::QPropertyNames, qobject::QObjectNames, CombinedIdent},
     parser::signals::ParsedSignal,
 };
 
-pub fn generate(idents: &QPropertyName, qobject_idents: &QObjectNames) -> ParsedSignal {
+pub fn generate(idents: &QPropertyNames, qobject_idents: &QObjectNames) -> ParsedSignal {
     // We build our signal in the generation phase as we need to use the naming
     // structs to build the signal name
     let cpp_class_rust = &qobject_idents.name.rust_unqualified();
-    let notify_cpp = &idents.notify.cpp;
-    let notify_rust_str = idents.notify.rust.to_string();
+    let notify_cpp = &idents.notify.cxx_unqualified();
+    let notify_rust = idents.notify.rust_unqualified();
     let method: ForeignItemFn = syn::parse_quote! {
         #[doc = "Notify for the Q_PROPERTY"]
-        #[rust_name = #notify_rust_str]
-        fn #notify_cpp(self: Pin<&mut #cpp_class_rust>);
+        #[cxx_name = #notify_cpp]
+        fn #notify_rust(self: Pin<&mut #cpp_class_rust>);
     };
     ParsedSignal::from_property_method(
         method,
-        idents.notify.clone(),
+        CombinedIdent {
+            cpp: Ident::new(&idents.notify.cxx_unqualified(), Span::call_site()),
+            rust: idents.notify.rust_unqualified().clone(),
+        },
         qobject_idents.name.rust_unqualified().clone(),
     )
 }

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

@@ -2,85 +2,74 @@
 // SPDX-FileContributor: Andrew Hayzen <andrew.hayzen@kdab.com>
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
-use crate::generator::naming::CombinedIdent;
-use crate::parser::property::ParsedQProperty;
+use crate::{naming::Name, parser::property::ParsedQProperty};
 use convert_case::{Case, Casing};
 use quote::format_ident;
 use syn::Ident;
 
 /// Names for parts of a Q_PROPERTY
-pub struct QPropertyName {
-    pub name: CombinedIdent,
-    pub getter: CombinedIdent,
-    pub getter_wrapper: CombinedIdent,
-    pub setter: CombinedIdent,
-    pub setter_wrapper: CombinedIdent,
-    pub notify: CombinedIdent,
+pub struct QPropertyNames {
+    pub name: Name,
+    pub getter: Name,
+    pub getter_wrapper: Name,
+    pub setter: Name,
+    pub setter_wrapper: Name,
+    pub notify: Name,
 }
 
-impl From<&Ident> for QPropertyName {
-    fn from(ident: &Ident) -> Self {
-        let getter = CombinedIdent::getter_from_property(ident.clone());
-        let setter = CombinedIdent::setter_from_property(ident);
+impl From<&ParsedQProperty> for QPropertyNames {
+    fn from(property: &ParsedQProperty) -> Self {
+        let property_name = property_name_from_rust_name(property.ident.clone());
+        let getter = getter_name_from_property(&property_name);
+        let setter = setter_name_from_property(&property_name);
         Self {
-            name: CombinedIdent::from_property(ident.clone()),
-            getter_wrapper: CombinedIdent::wrapper_from_combined_property(&getter),
+            getter_wrapper: wrapper_name_from_function_name(&getter),
             getter,
-            setter_wrapper: CombinedIdent::wrapper_from_combined_property(&setter),
+            setter_wrapper: wrapper_name_from_function_name(&setter),
             setter,
-            notify: CombinedIdent::notify_from_property(ident),
+            notify: notify_name_from_property(&property_name),
+            name: property_name,
         }
     }
 }
 
-impl From<&ParsedQProperty> for QPropertyName {
-    fn from(property: &ParsedQProperty) -> Self {
-        Self::from(&property.ident)
-    }
+fn property_name_from_rust_name(ident: Ident) -> Name {
+    // TODO: ParsedQProperty should probably take care of this already and allow the user to set
+    // their own name for C++ if they want to.
+    let cxx_name = ident.to_string().to_case(Case::Camel);
+    Name::new(ident).with_cxx_name(cxx_name)
 }
 
-impl CombinedIdent {
-    /// For a given ident generate the Rust and C++ getter names
-    fn getter_from_property(ident: Ident) -> Self {
-        Self {
-            cpp: format_ident!("get{}", ident.to_string().to_case(Case::Pascal)),
-            rust: ident,
-        }
-    }
-
-    /// For a given ident generate the Rust and C++ names
-    fn from_property(ident: Ident) -> Self {
-        Self {
-            cpp: format_ident!("{}", ident.to_string().to_case(Case::Camel)),
-            rust: ident,
-        }
-    }
+/// For a given property name generate the getter name
+fn getter_name_from_property(name: &Name) -> Name {
+    name.clone().with_cxx_name(format!(
+        "get{}",
+        name.cxx_unqualified().to_case(Case::Pascal)
+    ))
+}
 
-    /// For a given ident generate the Rust and C++ notify names
-    fn notify_from_property(ident: &Ident) -> Self {
-        let ident = format_ident!("{ident}_changed");
-        Self {
-            cpp: format_ident!("{}", ident.to_string().to_case(Case::Camel)),
-            rust: ident,
-        }
-    }
+/// For a given property name generate the setter name
+fn setter_name_from_property(name: &Name) -> Name {
+    name.clone()
+        .with_rust_name(format_ident!("set_{}", name.rust_unqualified()))
+        .with_cxx_name(format!(
+            "set{}",
+            name.cxx_unqualified().to_case(Case::Pascal)
+        ))
+}
 
-    /// For a given ident generate the Rust and C++ setter names
-    fn setter_from_property(ident: &Ident) -> Self {
-        let ident = format_ident!("set_{ident}");
-        Self {
-            cpp: format_ident!("{}", ident.to_string().to_case(Case::Camel)),
-            rust: ident,
-        }
-    }
+/// For a given function name generate the Rust and C++ wrapper names
+fn wrapper_name_from_function_name(name: &Name) -> Name {
+    name.clone()
+        .with_rust_name(format_ident!("{}_wrapper", name.rust_unqualified().clone()))
+        .with_cxx_name(format!("{}Wrapper", name.cxx_unqualified()))
+}
 
-    /// For a given ident generate the Rust and C++ wrapper names
-    fn wrapper_from_combined_property(ident: &CombinedIdent) -> Self {
-        Self {
-            cpp: format_ident!("{}Wrapper", ident.cpp),
-            rust: format_ident!("{}_wrapper", ident.rust),
-        }
-    }
+/// For a given property name generate the notify signal name
+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)]
@@ -89,25 +78,34 @@ pub mod tests {
 
     use super::*;
 
-    pub fn create_i32_qpropertyname() -> QPropertyName {
+    pub fn create_i32_qpropertyname() -> QPropertyNames {
         let ty: syn::Type = parse_quote! { i32 };
         let property = ParsedQProperty {
             ident: format_ident!("my_property"),
             ty,
         };
-        QPropertyName::from(&property)
+        QPropertyNames::from(&property)
     }
 
     #[test]
     fn test_parsed_property() {
         let names = create_i32_qpropertyname();
-        assert_eq!(names.name.cpp, format_ident!("myProperty"));
-        assert_eq!(names.name.rust, format_ident!("my_property"));
-        assert_eq!(names.getter.cpp, format_ident!("getMyProperty"));
-        assert_eq!(names.getter.rust, format_ident!("my_property"));
-        assert_eq!(names.setter.cpp, format_ident!("setMyProperty"));
-        assert_eq!(names.setter.rust, format_ident!("set_my_property"));
-        assert_eq!(names.notify.cpp, format_ident!("myPropertyChanged"));
-        assert_eq!(names.notify.rust, format_ident!("my_property_changed"));
+        assert_eq!(names.name.cxx_unqualified(), "myProperty");
+        assert_eq!(names.name.rust_unqualified(), &format_ident!("my_property"));
+        assert_eq!(names.getter.cxx_unqualified(), "getMyProperty");
+        assert_eq!(
+            names.getter.rust_unqualified(),
+            &format_ident!("my_property")
+        );
+        assert_eq!(names.setter.cxx_unqualified(), "setMyProperty");
+        assert_eq!(
+            names.setter.rust_unqualified(),
+            &format_ident!("set_my_property")
+        );
+        assert_eq!(names.notify.cxx_unqualified(), "myPropertyChanged");
+        assert_eq!(
+            names.notify.rust_unqualified(),
+            &format_ident!("my_property_changed")
+        );
     }
 }

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

@@ -5,7 +5,7 @@
 
 use crate::{
     generator::{
-        naming::{property::QPropertyName, qobject::QObjectNames},
+        naming::{property::QPropertyNames, qobject::QObjectNames},
         rust::fragment::RustFragmentPair,
     },
     naming::rust::syn_type_cxx_bridge_to_qualified,
@@ -15,15 +15,15 @@ use quote::quote;
 use syn::{Result, Type};
 
 pub fn generate(
-    idents: &QPropertyName,
+    idents: &QPropertyNames,
     qobject_idents: &QObjectNames,
     cxx_ty: &Type,
     type_names: &TypeNames,
 ) -> Result<RustFragmentPair> {
     let cpp_class_name_rust = &qobject_idents.name.rust_unqualified();
-    let getter_wrapper_cpp = idents.getter_wrapper.cpp.to_string();
-    let getter_rust = &idents.getter.rust;
-    let ident = &idents.name.rust;
+    let getter_wrapper_cpp = idents.getter_wrapper.cxx_unqualified();
+    let getter_rust = idents.getter.rust_unqualified();
+    let ident = idents.name.rust_unqualified();
     let ident_str = ident.to_string();
     let qualified_ty = syn_type_cxx_bridge_to_qualified(cxx_ty, type_names)?;
     let qualified_impl = type_names.rust_qualified(cpp_class_name_rust)?;

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

@@ -9,7 +9,7 @@ pub mod signal;
 
 use crate::{
     generator::{
-        naming::{property::QPropertyName, qobject::QObjectNames},
+        naming::{property::QPropertyNames, qobject::QObjectNames},
         rust::fragment::GeneratedRustFragment,
     },
     naming::TypeNames,
@@ -29,7 +29,7 @@ pub fn generate_rust_properties(
     let mut signals = vec![];
 
     for property in properties {
-        let idents = QPropertyName::from(property);
+        let idents = QPropertyNames::from(property);
 
         // Getters
         let getter = getter::generate(&idents, qobject_idents, &property.ty, type_names)?;