Refactor ParsedMethod to use Name

* Remove use of deprecated CombinedIdent and refactor to use Name in its place
CombinedIdent had a rust and cpp field for Idents, which has now been better implemented in Name, so refactor to using that everywhere CombinedIdent was used
* Introduce name field into ParsedMethod
* Replace From with TryFrom for QMethodName and clean up some comments

Author: BenFordTytherington

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

@@ -35,7 +35,7 @@ pub fn generate(
                   return {base_class}::{func_ident}(args...);
               }}"#,
         mutability = if method.mutable { "" } else { " const" },
-        func_ident = method.ident.cpp,
+        func_ident = method.ident.cxx_unqualified(),
         wrapper_ident = method.wrapper_ident(),
         return_type = return_type.unwrap_or_else(|| "void".to_string()),
         base_class = base_class

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

@@ -28,7 +28,7 @@ pub fn generate_cpp_methods(
     let mut generated = GeneratedCppQObjectBlocks::default();
     let qobject_ident = qobject_idents.name.cxx_unqualified();
     for invokable in invokables {
-        let idents = QMethodName::from(invokable);
+        let idents = QMethodName::try_from(invokable)?;
         let return_cxx_ty = syn_type_to_cpp_return_type(&invokable.method.sig.output, type_names)?;
 
         let parameters: Vec<CppNamedType> = invokable
@@ -63,7 +63,7 @@ pub fn generate_cpp_methods(
 
         let body = format!(
             "{ident}({parameter_names})",
-            ident = idents.wrapper.cpp,
+            ident = idents.wrapper.cxx_unqualified(),
             parameter_names = parameters
                 .iter()
                 .map(|parameter| parameter.ident.as_str())
@@ -85,7 +85,7 @@ pub fn generate_cpp_methods(
                 } else {
                     "void"
                 },
-                ident = idents.name.cpp,
+                ident = idents.name.cxx_unqualified(),
                 parameter_types = parameter_types,
                 is_qinvokable = if invokable.is_qinvokable {
                     "Q_INVOKABLE "
@@ -122,7 +122,7 @@ pub fn generate_cpp_methods(
                 } else {
                     "void"
                 },
-                ident = idents.name.cpp,
+                ident = idents.name.cxx_unqualified(),
                 body = if return_cxx_ty.is_some() {
                     format!("return {body}", body = body)
                 } else {
@@ -143,7 +143,7 @@ pub fn generate_cpp_methods(
             } else {
                 "void"
             },
-            ident = idents.wrapper.cpp,
+            ident = idents.wrapper.cxx_unqualified(),
         )));
     }
 
@@ -155,27 +155,42 @@ mod tests {
     use super::*;
 
     use crate::generator::naming::qobject::tests::create_qobjectname;
+    use crate::naming::Name;
     use crate::parser::parameter::ParsedFunctionParameter;
     use indoc::indoc;
     use pretty_assertions::assert_str_eq;
     use quote::format_ident;
     use std::collections::HashSet;
-    use syn::parse_quote;
+    use syn::{parse_quote, ForeignItemFn};
 
     #[test]
     fn test_generate_cpp_invokables() {
+        let method1: ForeignItemFn = parse_quote! { fn void_invokable(self: &MyObject); };
+        let method2: ForeignItemFn =
+            parse_quote! { fn trivial_invokable(self: &MyObject, param: i32) -> i32; };
+        let method3: ForeignItemFn = parse_quote! { fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor>; };
+        let method4: ForeignItemFn =
+            parse_quote! { fn specifiers_invokable(self: &MyObject, param: i32) -> i32; };
+        let method5: ForeignItemFn = parse_quote! { fn cpp_method(self: &MyObject); };
         let invokables = vec![
             ParsedMethod {
-                method: parse_quote! { fn void_invokable(self: &MyObject); },
+                method: method1.clone(),
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
                 parameters: vec![],
                 specifiers: HashSet::new(),
                 is_qinvokable: true,
+                name: Name::from_rust_ident_and_attrs(
+                    &method1.sig.ident,
+                    &method1.attrs,
+                    None,
+                    None,
+                )
+                .unwrap(),
             },
             ParsedMethod {
-                method: parse_quote! { fn trivial_invokable(self: &MyObject, param: i32) -> i32; },
+                method: method2.clone(),
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
@@ -185,9 +200,16 @@ mod tests {
                 }],
                 specifiers: HashSet::new(),
                 is_qinvokable: true,
+                name: Name::from_rust_ident_and_attrs(
+                    &method2.sig.ident,
+                    &method2.attrs,
+                    None,
+                    None,
+                )
+                .unwrap(),
             },
             ParsedMethod {
-                method: parse_quote! { fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor>; },
+                method: method3.clone(),
                 qobject_ident: format_ident!("MyObject"),
                 mutable: true,
                 safe: true,
@@ -197,9 +219,16 @@ mod tests {
                 }],
                 specifiers: HashSet::new(),
                 is_qinvokable: true,
+                name: Name::from_rust_ident_and_attrs(
+                    &method3.sig.ident,
+                    &method3.attrs,
+                    None,
+                    None,
+                )
+                .unwrap(),
             },
             ParsedMethod {
-                method: parse_quote! { fn specifiers_invokable(self: &MyObject, param: i32) -> i32; },
+                method: method4.clone(),
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
@@ -215,15 +244,29 @@ mod tests {
                     specifiers
                 },
                 is_qinvokable: true,
+                name: Name::from_rust_ident_and_attrs(
+                    &method4.sig.ident,
+                    &method4.attrs,
+                    None,
+                    None,
+                )
+                .unwrap(),
             },
             ParsedMethod {
-                method: parse_quote! { fn cpp_method(self: &MyObject); },
+                method: method5.clone(),
                 qobject_ident: format_ident!("MyObject"),
                 mutable: false,
                 safe: true,
                 parameters: vec![],
                 specifiers: HashSet::new(),
                 is_qinvokable: false,
+                name: Name::from_rust_ident_and_attrs(
+                    &method5.sig.ident,
+                    &method5.attrs,
+                    None,
+                    None,
+                )
+                .unwrap(),
             },
         ];
         let qobject_idents = create_qobjectname();
@@ -385,8 +428,10 @@ mod tests {
 
     #[test]
     fn test_generate_cpp_invokables_mapped_cxx_name() {
+        let method: ForeignItemFn =
+            parse_quote! { fn trivial_invokable(self: &MyObject, param: A) -> B; };
         let invokables = vec![ParsedMethod {
-            method: parse_quote! { fn trivial_invokable(self: &MyObject, param: A) -> B; },
+            method: method.clone(),
             qobject_ident: format_ident!("MyObject"),
             mutable: false,
             safe: true,
@@ -396,6 +441,8 @@ mod tests {
             }],
             specifiers: HashSet::new(),
             is_qinvokable: true,
+            name: Name::from_rust_ident_and_attrs(&method.sig.ident, &method.attrs, None, None)
+                .unwrap(),
         }];
         let qobject_idents = create_qobjectname();
 

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

@@ -2,73 +2,81 @@
 // SPDX-FileContributor: Andrew Hayzen <andrew.hayzen@kdab.com>
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
-use crate::{generator::naming::CombinedIdent, parser::method::ParsedMethod};
-use convert_case::{Case, Casing};
-use quote::format_ident;
-use syn::{ForeignItemFn, Ident};
+use crate::naming::Name;
+use crate::parser::method::ParsedMethod;
+use syn::ForeignItemFn;
 
 /// Names for parts of a method (which could be a Q_INVOKABLE)
 pub struct QMethodName {
-    pub name: CombinedIdent,
-    pub wrapper: CombinedIdent,
+    pub name: Name,
+    pub wrapper: Name,
 }
 
-impl From<&ParsedMethod> for QMethodName {
-    fn from(invokable: &ParsedMethod) -> Self {
-        Self::from(&invokable.method)
-    }
-}
+impl TryFrom<&ParsedMethod> for QMethodName {
+    type Error = syn::Error;
 
-impl From<&ForeignItemFn> for QMethodName {
-    fn from(method: &ForeignItemFn) -> Self {
-        let ident = &method.sig.ident;
-        Self {
-            name: CombinedIdent::from_rust_function(ident.clone()),
-            wrapper: CombinedIdent::wrapper_from_invokable(ident),
-        }
+    fn try_from(invokable: &ParsedMethod) -> Result<Self, Self::Error> {
+        Self::try_from(&invokable.method)
     }
 }
 
-impl CombinedIdent {
-    /// For a given ident generate the Rust and C++ wrapper names
-    fn wrapper_from_invokable(ident: &Ident) -> Self {
-        let ident = format_ident!("{ident}_wrapper");
-        Self {
-            cpp: format_ident!("{}", ident.to_string().to_case(Case::Camel)),
-            rust: ident,
-        }
+impl TryFrom<&ForeignItemFn> for QMethodName {
+    type Error = syn::Error;
+
+    fn try_from(method: &ForeignItemFn) -> Result<Self, Self::Error> {
+        let method_name =
+            Name::from_rust_ident_and_attrs(&method.sig.ident, &method.attrs, None, None)?; // Might need to add a way to get the namespace and module in here
+        let wrapper = Name::wrapper_from(&method_name);
+
+        Ok(Self {
+            name: method_name,
+            wrapper,
+        })
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use syn::parse_quote;
+    use syn::{parse_quote, ForeignItemFn};
 
     use super::*;
+    use quote::format_ident;
 
     use std::collections::HashSet;
 
     #[test]
     fn test_from_impl_method() {
+        let method: ForeignItemFn = parse_quote! {
+            fn my_invokable(self: &MyObject);
+        };
         let parsed = ParsedMethod {
-            method: parse_quote! {
-                fn my_invokable(self: &MyObject);
-            },
+            method: method.clone(),
             qobject_ident: format_ident!("MyObject"),
             mutable: false,
             safe: true,
             parameters: vec![],
             specifiers: HashSet::new(),
             is_qinvokable: true,
+            name: Name::from_rust_ident_and_attrs(&method.sig.ident, &method.attrs, None, None)
+                .unwrap(),
         };
 
-        let invokable = QMethodName::from(&parsed);
-        assert_eq!(invokable.name.cpp, format_ident!("myInvokable"));
-        assert_eq!(invokable.name.rust, format_ident!("my_invokable"));
-        assert_eq!(invokable.wrapper.cpp, format_ident!("myInvokableWrapper"));
+        let invokable = QMethodName::try_from(&parsed).unwrap();
+        assert_eq!(
+            invokable.name.cxx_unqualified(),
+            String::from("myInvokable")
+        );
+        assert_eq!(
+            invokable.name.rust_unqualified().to_string(),
+            String::from("my_invokable")
+        );
+        assert_eq!(
+            invokable.wrapper.cxx_unqualified(),
+            String::from("myInvokableWrapper")
+        );
         assert_eq!(
-            invokable.wrapper.rust,
-            format_ident!("my_invokable_wrapper")
+            invokable.wrapper.rust_unqualified().to_string(),
+            String::from("my_invokable_wrapper")
         );
     }
 }

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

@@ -2,20 +2,8 @@
 // SPDX-FileContributor: Andrew Hayzen <andrew.hayzen@kdab.com>
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
-pub mod functions;
 pub mod method;
 pub mod namespace;
 pub mod property;
 pub mod qobject;
 pub mod signals;
-
-use syn::Ident;
-
-/// Describes an ident which potentially has a different name in C++ and Rust
-#[derive(Clone, Debug, PartialEq)]
-pub struct CombinedIdent {
-    /// The ident for C++
-    pub cpp: Ident,
-    /// The ident for rust
-    pub rust: Ident,
-}