From 0c1495f6b46204d7e137d9d744db72c8325ca447 Mon Sep 17 00:00:00 2001 From: Leon Matthes Date: Tue, 4 Jun 2024 14:32:14 +0200 Subject: [PATCH 1/4] refactor: Rename ParsedSignal::ident to name --- crates/cxx-qt-gen/src/generator/cpp/signal.rs | 10 +++++----- .../cxx-qt-gen/src/generator/naming/signals.rs | 10 +++++----- .../cxx-qt-gen/src/generator/rust/signals.rs | 12 ++++++------ crates/cxx-qt-gen/src/parser/cxxqtdata.rs | 6 +++--- crates/cxx-qt-gen/src/parser/signals.rs | 18 +++++++++--------- 5 files changed, 28 insertions(+), 28 deletions(-) diff --git a/crates/cxx-qt-gen/src/generator/cpp/signal.rs b/crates/cxx-qt-gen/src/generator/cpp/signal.rs index 4e49eae25..1e2665563 100644 --- a/crates/cxx-qt-gen/src/generator/cpp/signal.rs +++ b/crates/cxx-qt-gen/src/generator/cpp/signal.rs @@ -238,7 +238,7 @@ mod tests { ty: parse_quote! { UniquePtr }, }, ], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("dataChanged"), rust: format_ident!("data_changed"), }, @@ -338,7 +338,7 @@ mod tests { ident: format_ident!("mapped"), ty: parse_quote! { A }, }], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("dataChanged"), rust: format_ident!("data_changed"), }, @@ -434,7 +434,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("baseName"), rust: format_ident!("existing_signal"), }, @@ -520,7 +520,7 @@ mod tests { qobject_ident: format_ident!("ObjRust"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("signalRustName"), rust: format_ident!("signal_rust_name"), }, @@ -611,7 +611,7 @@ mod tests { qobject_ident: format_ident!("ObjRust"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("signalCxxName"), rust: format_ident!("signal_rust_name"), }, diff --git a/crates/cxx-qt-gen/src/generator/naming/signals.rs b/crates/cxx-qt-gen/src/generator/naming/signals.rs index 521ba294d..da9618071 100644 --- a/crates/cxx-qt-gen/src/generator/naming/signals.rs +++ b/crates/cxx-qt-gen/src/generator/naming/signals.rs @@ -18,9 +18,9 @@ pub struct QSignalName { impl From<&ParsedSignal> for QSignalName { 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: CombinedIdent::connect_from_signal(&signal.name), + on_name: on_from_signal(&signal.name.rust), } } } @@ -110,7 +110,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("dataChanged"), rust: format_ident!("data_changed"), }, @@ -140,7 +140,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("baseName"), rust: format_ident!("existing_signal"), }, diff --git a/crates/cxx-qt-gen/src/generator/rust/signals.rs b/crates/cxx-qt-gen/src/generator/rust/signals.rs index 564602dfa..98a737273 100644 --- a/crates/cxx-qt-gen/src/generator/rust/signals.rs +++ b/crates/cxx-qt-gen/src/generator/rust/signals.rs @@ -263,7 +263,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready"), }, @@ -426,7 +426,7 @@ mod tests { ty: parse_quote! { UniquePtr }, }, ], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("dataChanged"), rust: format_ident!("data_changed"), }, @@ -587,7 +587,7 @@ mod tests { ident: format_ident!("param"), ty: parse_quote! { *mut T }, }], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("unsafeSignal"), rust: format_ident!("unsafe_signal"), }, @@ -744,7 +744,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("baseName"), rust: format_ident!("existing_signal"), }, @@ -898,7 +898,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready"), }, @@ -1053,7 +1053,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { + name: CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready"), }, diff --git a/crates/cxx-qt-gen/src/parser/cxxqtdata.rs b/crates/cxx-qt-gen/src/parser/cxxqtdata.rs index 449eadfa0..cc5d4d309 100644 --- a/crates/cxx-qt-gen/src/parser/cxxqtdata.rs +++ b/crates/cxx-qt-gen/src/parser/cxxqtdata.rs @@ -636,14 +636,14 @@ mod tests { assert_eq!(signals[1].parameters.len(), 1); assert_eq!(signals[1].parameters[0].ident, "data"); assert_eq!( - signals[0].ident, + signals[0].name, CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready") } ); assert_eq!( - signals[1].ident, + signals[1].name, CombinedIdent { cpp: format_ident!("cppDataChanged"), rust: format_ident!("data_changed") @@ -685,7 +685,7 @@ mod tests { assert_eq!(signals[0].parameters.len(), 1); assert_eq!(signals[0].parameters[0].ident, "arg"); assert_eq!( - signals[0].ident, + signals[0].name, CombinedIdent { cpp: format_ident!("unsafeSignal"), rust: format_ident!("unsafe_signal") diff --git a/crates/cxx-qt-gen/src/parser/signals.rs b/crates/cxx-qt-gen/src/parser/signals.rs index d031fdb0a..f49cc724a 100644 --- a/crates/cxx-qt-gen/src/parser/signals.rs +++ b/crates/cxx-qt-gen/src/parser/signals.rs @@ -27,7 +27,7 @@ pub struct ParsedSignal { /// The parameters of the signal pub parameters: Vec, /// The name of the signal - pub ident: CombinedIdent, + pub name: CombinedIdent, /// If the signal is defined in the base class pub inherit: bool, /// Whether the signal is private @@ -47,7 +47,7 @@ impl ParsedSignal { mutable: true, safe: true, parameters: vec![], - ident, + name: ident, inherit: false, private: false, } @@ -102,7 +102,7 @@ impl ParsedSignal { qobject_ident, mutable, parameters, - ident, + name: ident, safe, inherit, private, @@ -129,7 +129,7 @@ mod tests { assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); assert_eq!( - signal.ident, + signal.name, CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready") @@ -157,7 +157,7 @@ mod tests { assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); assert_eq!( - signal.ident, + signal.name, CombinedIdent { cpp: format_ident!("cppReady"), rust: format_ident!("ready") @@ -184,7 +184,7 @@ mod tests { assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); assert_eq!( - signal.ident, + signal.name, CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready") @@ -219,7 +219,7 @@ mod tests { assert_eq!(signal.parameters[1].ident, format_ident!("y")); assert_eq!(signal.parameters[1].ty, f64_type()); assert_eq!( - signal.ident, + signal.name, CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready") @@ -241,7 +241,7 @@ mod tests { assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); assert_eq!( - signal.ident, + signal.name, CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready") @@ -281,7 +281,7 @@ mod tests { assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); assert_eq!( - signal.ident, + signal.name, CombinedIdent { cpp: format_ident!("ready"), rust: format_ident!("ready") From 377ac8e2b5427b70bffd10b250752de3c89f3737 Mon Sep 17 00:00:00 2001 From: Leon Matthes Date: Tue, 4 Jun 2024 15:08:22 +0200 Subject: [PATCH 2/4] refactor: Use Name in ParsedSignal --- .../src/generator/cpp/property/signal.rs | 10 +- crates/cxx-qt-gen/src/generator/cpp/signal.rs | 29 ++---- .../src/generator/naming/signals.rs | 39 ++++---- .../src/generator/rust/property/signal.rs | 10 +- .../cxx-qt-gen/src/generator/rust/signals.rs | 42 +++------ crates/cxx-qt-gen/src/naming/name.rs | 33 ++++++- crates/cxx-qt-gen/src/naming/type_names.rs | 2 +- crates/cxx-qt-gen/src/parser/cxxqtdata.rs | 20 +--- crates/cxx-qt-gen/src/parser/qenum.rs | 2 +- crates/cxx-qt-gen/src/parser/qobject.rs | 2 +- crates/cxx-qt-gen/src/parser/signals.rs | 92 +++++-------------- 11 files changed, 109 insertions(+), 172 deletions(-) diff --git a/crates/cxx-qt-gen/src/generator/cpp/property/signal.rs b/crates/cxx-qt-gen/src/generator/cpp/property/signal.rs index 06432df98..2ef864052 100644 --- a/crates/cxx-qt-gen/src/generator/cpp/property/signal.rs +++ b/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(), ) } diff --git a/crates/cxx-qt-gen/src/generator/cpp/signal.rs b/crates/cxx-qt-gen/src/generator/cpp/signal.rs index 1e2665563..3cf8109b4 100644 --- a/crates/cxx-qt-gen/src/generator/cpp/signal.rs +++ b/crates/cxx-qt-gen/src/generator/cpp/signal.rs @@ -97,7 +97,7 @@ pub fn generate_cpp_signal( let idents = QSignalName::from(signal); let idents_helper = QSignalHelperName::new(&idents, qobject_name)?; - let signal_ident = idents.name.cpp; + let signal_ident = idents.name.cxx_unqualified(); let free_connect_ident_cpp = idents_helper.connect_name.cpp; // Retrieve the parameters for the signal @@ -238,10 +238,7 @@ mod tests { ty: parse_quote! { UniquePtr }, }, ], - name: 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 }, }], - name: 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![], - name: 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![], - name: 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![], - name: 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, diff --git a/crates/cxx-qt-gen/src/generator/naming/signals.rs b/crates/cxx-qt-gen/src/generator/naming/signals.rs index da9618071..fb4854083 100644 --- a/crates/cxx-qt-gen/src/generator/naming/signals.rs +++ b/crates/cxx-qt-gen/src/generator/naming/signals.rs @@ -10,7 +10,7 @@ use syn::{Ident, Result}; /// Names for parts of a Q_SIGNAL pub struct QSignalName { - pub name: CombinedIdent, + pub name: Name, pub connect_name: CombinedIdent, pub on_name: Ident, } @@ -20,7 +20,7 @@ impl From<&ParsedSignal> for QSignalName { Self { name: signal.name.clone(), connect_name: CombinedIdent::connect_from_signal(&signal.name), - on_name: on_from_signal(&signal.name.rust), + on_name: on_from_signal(signal.name.rust_unqualified()), } } } @@ -30,12 +30,15 @@ fn on_from_signal(ident: &Ident) -> Ident { } impl CombinedIdent { - fn connect_from_signal(ident: &CombinedIdent) -> Self { + fn connect_from_signal(ident: &Name) -> 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)), + cpp: format_ident!("{}Connect", ident.cxx_unqualified().to_case(Case::Camel)), + rust: format_ident!( + "connect_{}", + ident.rust_unqualified().to_string().to_case(Case::Snake) + ), } } } @@ -53,7 +56,7 @@ pub struct QSignalHelperName { impl QSignalHelperName { pub fn new(idents: &QSignalName, qobject_name: &Name) -> Result { - let signal_ident = &idents.name.cpp; + 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 = { @@ -110,18 +113,18 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - name: 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.name.cxx_unqualified(), "dataChanged"); + assert_eq!( + names.name.rust_unqualified(), + &format_ident!("data_changed") + ); assert_eq!(names.connect_name.cpp, format_ident!("dataChangedConnect")); assert_eq!( names.connect_name.rust, @@ -140,18 +143,18 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - name: 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.name.cxx_unqualified(), "baseName"); + assert_eq!( + names.name.rust_unqualified(), + &format_ident!("existing_signal") + ); assert_eq!(names.connect_name.cpp, format_ident!("baseNameConnect")); assert_eq!( names.connect_name.rust, diff --git a/crates/cxx-qt-gen/src/generator/rust/property/signal.rs b/crates/cxx-qt-gen/src/generator/rust/property/signal.rs index 38223826a..8064036f5 100644 --- a/crates/cxx-qt-gen/src/generator/rust/property/signal.rs +++ b/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(), ) } diff --git a/crates/cxx-qt-gen/src/generator/rust/signals.rs b/crates/cxx-qt-gen/src/generator/rust/signals.rs index 98a737273..b7ef94998 100644 --- a/crates/cxx-qt-gen/src/generator/rust/signals.rs +++ b/crates/cxx-qt-gen/src/generator/rust/signals.rs @@ -29,8 +29,7 @@ pub fn generate_rust_signal( let qobject_name_rust = qobject_name.rust_unqualified(); - let signal_name_cpp = idents.name.cpp; - let signal_name_cpp_str = signal_name_cpp.to_string(); + let signal_name_cpp = idents.name.cxx_unqualified(); let connect_ident_rust = idents.connect_name.rust; let on_ident_rust = idents.on_name; let original_method = &signal.method; @@ -134,7 +133,7 @@ pub fn generate_rust_signal( quote! { impl #qualified_impl { #[doc = "Connect the given function pointer to the signal "] - #[doc = #signal_name_cpp_str] + #[doc = #signal_name_cpp] #[doc = ", so that when the signal is emitted the function pointer is executed."] pub fn #connect_ident_rust(self: #self_type_qualified, mut closure: F, conn_type: cxx_qt::ConnectionType) -> cxx_qt::QMetaObjectConnectionGuard { @@ -149,7 +148,7 @@ pub fn generate_rust_signal( quote! { impl #qualified_impl { #[doc = "Connect the given function pointer to the signal "] - #[doc = #signal_name_cpp_str] + #[doc = #signal_name_cpp] #[doc = ", so that when the signal is emitted the function pointer is executed."] #[doc = "\n"] #[doc = "Note that this method uses a AutoConnection connection type."] @@ -223,11 +222,11 @@ pub fn generate_rust_signals( && attribute_find_path(&signal.method.attrs, &["rust_name"]).is_none() { let idents = QSignalName::from(&signal); - let signal_name_cpp_str = idents.name.cpp.to_string(); + let signal_name_cpp = idents.name.cxx_unqualified(); signal .method .attrs - .push(parse_quote!(#[cxx_name = #signal_name_cpp_str])); + .push(parse_quote!(#[cxx_name = #signal_name_cpp])); signal } else { signal @@ -263,10 +262,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - name: CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready"), - }, + name: Name::new(format_ident!("ready")), safe: true, inherit: false, private: false, @@ -426,10 +422,7 @@ mod tests { ty: parse_quote! { UniquePtr }, }, ], - name: 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, @@ -587,10 +580,8 @@ mod tests { ident: format_ident!("param"), ty: parse_quote! { *mut T }, }], - name: CombinedIdent { - cpp: format_ident!("unsafeSignal"), - rust: format_ident!("unsafe_signal"), - }, + name: Name::new(format_ident!("unsafe_signal")) + .with_cxx_name("unsafeSignal".to_owned()), safe: false, inherit: false, private: false, @@ -744,10 +735,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - name: 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, @@ -898,10 +886,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - name: CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready"), - }, + name: Name::new(format_ident!("ready")), safe: true, inherit: false, private: false, @@ -1053,10 +1038,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - name: CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready"), - }, + name: Name::new(format_ident!("ready")), safe: true, inherit: false, private: true, diff --git a/crates/cxx-qt-gen/src/naming/name.rs b/crates/cxx-qt-gen/src/naming/name.rs index c19978610..cef617a96 100644 --- a/crates/cxx-qt-gen/src/naming/name.rs +++ b/crates/cxx-qt-gen/src/naming/name.rs @@ -3,6 +3,7 @@ // // SPDX-License-Identifier: MIT OR Apache-2.0 +use convert_case::{Case, Casing}; use quote::format_ident; use syn::{spanned::Spanned, Attribute, Ident, Path, Result}; @@ -83,11 +84,39 @@ impl Name { } } + /// Parse a name from an an identifier and a list of attributes. + /// + /// This variant assumes that the name is contained in an `extern "Rust"` block. + /// If no cxx_name is set, it generates a camelCase cxx_name from the rust name. + /// + /// See also: [Self::from_ident_and_attrs] + pub fn from_rust_ident_and_attrs( + ident: &Ident, + attrs: &[Attribute], + parent_namespace: Option<&str>, + module: Option<&Ident>, + ) -> Result { + let name = Self::from_ident_and_attrs(ident, attrs, parent_namespace, module)?; + // No explicit cxx_name set, generate an appropriate camelCase cxx_name + if name.cxx.is_none() { + let rust_string = name.rust.to_string(); + let cxx = rust_string.to_case(Case::Camel); + if cxx != rust_string { + return Ok(name.with_cxx_name(cxx)); + } + } + Ok(name) + } + + /// Parse a name from an identifier and a list of attributes. + /// + /// This deciphers the rust_name, cxx_name and namespace attributes, including + /// inheriting the namespace from the parent. pub fn from_ident_and_attrs( ident: &Ident, attrs: &[Attribute], parent_namespace: Option<&str>, - module: &Ident, + module: Option<&Ident>, ) -> Result { // Find if there is a namespace (for C++ generation) let mut namespace = if let Some(index) = attribute_find_path(attrs, &["namespace"]) { @@ -133,7 +162,7 @@ impl Name { rust: rust_ident, cxx: cxx_name, namespace, - module: Some(module.clone().into()), + module: module.cloned().map(Path::from), }) } diff --git a/crates/cxx-qt-gen/src/naming/type_names.rs b/crates/cxx-qt-gen/src/naming/type_names.rs index deb50fffa..94d6f9a3e 100644 --- a/crates/cxx-qt-gen/src/naming/type_names.rs +++ b/crates/cxx-qt-gen/src/naming/type_names.rs @@ -358,7 +358,7 @@ impl TypeNames { module_ident: &Ident, fallback: impl FnOnce(&mut Self, Name) -> Result<()>, ) -> Result<()> { - let name = Name::from_ident_and_attrs(ident, attrs, parent_namespace, module_ident)?; + let name = Name::from_ident_and_attrs(ident, attrs, parent_namespace, Some(module_ident))?; let entry = self.names.entry(name.rust.clone()); diff --git a/crates/cxx-qt-gen/src/parser/cxxqtdata.rs b/crates/cxx-qt-gen/src/parser/cxxqtdata.rs index cc5d4d309..7dfe8a54c 100644 --- a/crates/cxx-qt-gen/src/parser/cxxqtdata.rs +++ b/crates/cxx-qt-gen/src/parser/cxxqtdata.rs @@ -270,7 +270,7 @@ impl ParsedCxxQtData { mod tests { use super::*; - use crate::{generator::naming::CombinedIdent, parser::qobject::tests::create_parsed_qobject}; + use crate::{naming::Name, parser::qobject::tests::create_parsed_qobject}; use quote::format_ident; use syn::{parse_quote, ItemMod}; @@ -635,19 +635,10 @@ mod tests { assert_eq!(signals[0].parameters.len(), 0); assert_eq!(signals[1].parameters.len(), 1); assert_eq!(signals[1].parameters[0].ident, "data"); - assert_eq!( - signals[0].name, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); + assert_eq!(signals[0].name, Name::new(format_ident!("ready"))); assert_eq!( signals[1].name, - CombinedIdent { - cpp: format_ident!("cppDataChanged"), - rust: format_ident!("data_changed") - } + Name::new(format_ident!("data_changed")).with_cxx_name("cppDataChanged".to_owned()) ); assert!(!signals[0].inherit); assert!(signals[1].inherit); @@ -686,10 +677,7 @@ mod tests { assert_eq!(signals[0].parameters[0].ident, "arg"); assert_eq!( signals[0].name, - CombinedIdent { - cpp: format_ident!("unsafeSignal"), - rust: format_ident!("unsafe_signal") - } + Name::new(format_ident!("unsafe_signal")).with_cxx_name("unsafeSignal".to_owned()) ); assert!(!signals[0].inherit); } diff --git a/crates/cxx-qt-gen/src/parser/qenum.rs b/crates/cxx-qt-gen/src/parser/qenum.rs index 03cae626f..56927c1d9 100644 --- a/crates/cxx-qt-gen/src/parser/qenum.rs +++ b/crates/cxx-qt-gen/src/parser/qenum.rs @@ -62,7 +62,7 @@ impl ParsedQEnum { } let name = - Name::from_ident_and_attrs(&qenum.ident, &qenum.attrs, parent_namespace, module)?; + Name::from_ident_and_attrs(&qenum.ident, &qenum.attrs, parent_namespace, Some(module))?; if name.namespace().is_none() && qobject.is_none() { return Err(syn::Error::new_spanned( diff --git a/crates/cxx-qt-gen/src/parser/qobject.rs b/crates/cxx-qt-gen/src/parser/qobject.rs index 24d372a78..78cbe80ea 100644 --- a/crates/cxx-qt-gen/src/parser/qobject.rs +++ b/crates/cxx-qt-gen/src/parser/qobject.rs @@ -82,7 +82,7 @@ impl ParsedQObject { &declaration.ident_left, &declaration.attrs, namespace, - module, + Some(module), )?; // Parse any properties in the type diff --git a/crates/cxx-qt-gen/src/parser/signals.rs b/crates/cxx-qt-gen/src/parser/signals.rs index f49cc724a..67cb9940b 100644 --- a/crates/cxx-qt-gen/src/parser/signals.rs +++ b/crates/cxx-qt-gen/src/parser/signals.rs @@ -3,14 +3,13 @@ // // SPDX-License-Identifier: MIT OR Apache-2.0 -use crate::parser::parameter::ParsedFunctionParameter; -use crate::syntax::attribute::{attribute_find_path, attribute_take_path}; -use crate::syntax::expr::expr_to_string; -use crate::syntax::foreignmod; -use crate::syntax::path::path_compare_str; -use crate::syntax::safety::Safety; -use crate::{generator::naming::CombinedIdent, syntax::types}; -use quote::format_ident; +use crate::{ + naming::Name, + parser::parameter::ParsedFunctionParameter, + syntax::{ + attribute::attribute_take_path, foreignmod, path::path_compare_str, safety::Safety, types, + }, +}; use syn::{spanned::Spanned, Error, ForeignItemFn, Ident, Result, Visibility}; #[derive(Clone)] @@ -27,7 +26,7 @@ pub struct ParsedSignal { /// The parameters of the signal pub parameters: Vec, /// The name of the signal - pub name: CombinedIdent, + pub name: Name, /// If the signal is defined in the base class pub inherit: bool, /// Whether the signal is private @@ -36,18 +35,14 @@ pub struct ParsedSignal { impl ParsedSignal { /// Builds a signal from a given property method - pub fn from_property_method( - method: ForeignItemFn, - ident: CombinedIdent, - qobject_ident: Ident, - ) -> Self { + pub fn from_property_method(method: ForeignItemFn, name: Name, qobject_ident: Ident) -> Self { Self { method, qobject_ident, mutable: true, safe: true, parameters: vec![], - name: ident, + name, inherit: false, private: false, } @@ -73,20 +68,13 @@ impl ParsedSignal { let parameters = ParsedFunctionParameter::parse_all_ignoring_receiver(&method.sig)?; - let mut ident = CombinedIdent::from_rust_function(method.sig.ident.clone()); + let name = Name::from_rust_ident_and_attrs(&method.sig.ident, &method.attrs, None, None)?; - if let Some(index) = attribute_find_path(&method.attrs, &["cxx_name"]) { - ident.cpp = format_ident!( - "{}", - expr_to_string(&method.attrs[index].meta.require_name_value()?.value)? - ); - } - - if let Some(index) = attribute_find_path(&method.attrs, &["rust_name"]) { - ident.rust = format_ident!( - "{}", - expr_to_string(&method.attrs[index].meta.require_name_value()?.value)? - ); + if name.namespace().is_some() { + return Err(Error::new_spanned( + method.sig.ident, + "Signals cannot have a namespace attribute", + )); } let inherit = attribute_take_path(&mut method.attrs, &["inherit"]).is_some(); @@ -102,7 +90,7 @@ impl ParsedSignal { qobject_ident, mutable, parameters, - name: ident, + name, safe, inherit, private, @@ -117,6 +105,7 @@ mod tests { use super::*; use crate::parser::tests::f64_type; + use quote::format_ident; #[test] fn test_parse_signal() { @@ -128,13 +117,7 @@ mod tests { assert_eq!(signal.qobject_ident, format_ident!("MyObject")); assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); - assert_eq!( - signal.name, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); + assert_eq!(signal.name, Name::new(format_ident!("ready"))); assert!(signal.safe); assert!(!signal.inherit); assert!(!signal.private); @@ -158,10 +141,7 @@ mod tests { assert_eq!(signal.parameters, vec![]); assert_eq!( signal.name, - CombinedIdent { - cpp: format_ident!("cppReady"), - rust: format_ident!("ready") - } + Name::new(format_ident!("ready")).with_cxx_name("cppReady".to_owned()) ); assert!(signal.safe); assert!(!signal.inherit); @@ -183,13 +163,7 @@ mod tests { assert_eq!(signal.qobject_ident, format_ident!("MyObject")); assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); - assert_eq!( - signal.name, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); + assert_eq!(signal.name, Name::new(format_ident!("ready"))); assert!(signal.safe); assert!(signal.inherit); assert!(!signal.private); @@ -218,13 +192,7 @@ mod tests { assert_eq!(signal.parameters[0].ty, f64_type()); assert_eq!(signal.parameters[1].ident, format_ident!("y")); assert_eq!(signal.parameters[1].ty, f64_type()); - assert_eq!( - signal.name, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); + assert_eq!(signal.name, Name::new(format_ident!("ready"))); assert!(signal.safe); assert!(!signal.inherit); assert!(!signal.private); @@ -240,13 +208,7 @@ mod tests { assert_eq!(signal.qobject_ident, format_ident!("MyObject")); assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); - assert_eq!( - signal.name, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); + assert_eq!(signal.name, Name::new(format_ident!("ready"))); assert!(signal.safe); assert!(!signal.inherit); assert!(signal.private); @@ -280,13 +242,7 @@ mod tests { assert_eq!(signal.qobject_ident, format_ident!("MyObject")); assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); - assert_eq!( - signal.name, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); + assert_eq!(signal.name, Name::new(format_ident!("ready"))); assert!(!signal.safe); assert!(!signal.inherit); assert!(!signal.private); From 87d11c6bfe21d21dd5d31ffd2358cad1cdfa6659 Mon Sep 17 00:00:00 2001 From: Leon Matthes Date: Tue, 4 Jun 2024 16:45:08 +0200 Subject: [PATCH 3/4] refactor: Use Name in SignalName&SignalHelperName --- crates/cxx-qt-gen/src/generator/cpp/signal.rs | 8 +-- .../src/generator/naming/signals.rs | 59 ++++++++++--------- .../src/generator/rust/property/mod.rs | 12 ++-- .../cxx-qt-gen/src/generator/rust/signals.rs | 37 ++++++------ .../test_outputs/passthrough_and_naming.cpp | 4 +- .../test_outputs/passthrough_and_naming.h | 4 +- .../test_outputs/passthrough_and_naming.rs | 28 ++++----- crates/cxx-qt-gen/test_outputs/properties.rs | 8 +-- crates/cxx-qt-gen/test_outputs/signals.rs | 16 ++--- 9 files changed, 88 insertions(+), 88 deletions(-) diff --git a/crates/cxx-qt-gen/src/generator/cpp/signal.rs b/crates/cxx-qt-gen/src/generator/cpp/signal.rs index 3cf8109b4..22bedc907 100644 --- a/crates/cxx-qt-gen/src/generator/cpp/signal.rs +++ b/crates/cxx-qt-gen/src/generator/cpp/signal.rs @@ -98,7 +98,7 @@ pub fn generate_cpp_signal( let idents_helper = QSignalHelperName::new(&idents, qobject_name)?; let signal_ident = idents.name.cxx_unqualified(); - let free_connect_ident_cpp = idents_helper.connect_name.cpp; + 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; @@ -628,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 "#} ); @@ -662,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, diff --git a/crates/cxx-qt-gen/src/generator/naming/signals.rs b/crates/cxx-qt-gen/src/generator/naming/signals.rs index fb4854083..675ce6ad6 100644 --- a/crates/cxx-qt-gen/src/generator/naming/signals.rs +++ b/crates/cxx-qt-gen/src/generator/naming/signals.rs @@ -2,8 +2,7 @@ // SPDX-FileContributor: Andrew Hayzen // // 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}; @@ -11,7 +10,7 @@ use syn::{Ident, Result}; /// Names for parts of a Q_SIGNAL pub struct QSignalName { pub name: Name, - pub connect_name: CombinedIdent, + pub connect_name: Name, pub on_name: Ident, } @@ -19,32 +18,26 @@ impl From<&ParsedSignal> for QSignalName { fn from(signal: &ParsedSignal) -> Self { Self { name: signal.name.clone(), - connect_name: CombinedIdent::connect_from_signal(&signal.name), + 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: &Name) -> 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.cxx_unqualified().to_case(Case::Camel)), - rust: format_ident!( - "connect_{}", - ident.rust_unqualified().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 connect_name: Name, pub function_call: Ident, pub function_drop: Ident, pub handler_alias: Ident, @@ -80,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}"), @@ -125,10 +126,10 @@ mod tests { names.name.rust_unqualified(), &format_ident!("data_changed") ); - assert_eq!(names.connect_name.cpp, format_ident!("dataChangedConnect")); + 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")); } @@ -155,10 +156,10 @@ mod tests { names.name.rust_unqualified(), &format_ident!("existing_signal") ); - assert_eq!(names.connect_name.cpp, format_ident!("baseNameConnect")); + 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")); } diff --git a/crates/cxx-qt-gen/src/generator/rust/property/mod.rs b/crates/cxx-qt-gen/src/generator/rust/property/mod.rs index d2c62775e..ac676a7b0 100644 --- a/crates/cxx-qt-gen/src/generator/rust/property/mod.rs +++ b/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; } }, ); diff --git a/crates/cxx-qt-gen/src/generator/rust/signals.rs b/crates/cxx-qt-gen/src/generator/rust/signals.rs index b7ef94998..8ca1d466f 100644 --- a/crates/cxx-qt-gen/src/generator/rust/signals.rs +++ b/crates/cxx-qt-gen/src/generator/rust/signals.rs @@ -30,13 +30,12 @@ pub fn generate_rust_signal( let qobject_name_rust = qobject_name.rust_unqualified(); let signal_name_cpp = idents.name.cxx_unqualified(); - let connect_ident_rust = idents.connect_name.rust; + let connect_ident_rust = idents.connect_name.rust_unqualified(); let on_ident_rust = idents.on_name; let original_method = &signal.method; - let free_connect_ident_cpp = idents_helper.connect_name.cpp; - let free_connect_ident_rust = idents_helper.connect_name.rust; - let free_connect_ident_rust_str = free_connect_ident_rust.to_string(); + let free_connect_ident_cpp = idents_helper.connect_name.cxx_unqualified(); + let free_connect_ident_rust = idents_helper.connect_name.rust_unqualified(); let parameters_cxx: Vec = signal .parameters @@ -111,8 +110,8 @@ pub fn generate_rust_signal( #[doc(hidden)] #[namespace = #namespace_str] - #[rust_name = #free_connect_ident_rust_str] - fn #free_connect_ident_cpp(self_value: #self_type_cxx, signal_handler: #signal_handler_alias, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = #free_connect_ident_cpp] + fn #free_connect_ident_rust(self_value: #self_type_cxx, signal_handler: #signal_handler_alias, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }); @@ -247,7 +246,7 @@ pub fn generate_rust_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 crate::tests::assert_tokens_eq; use quote::{format_ident, quote}; @@ -299,8 +298,8 @@ mod tests { #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_ready"] - fn MyObject_readyConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = "MyObject_readyConnect"] + fn MyObject_connect_ready(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }, ); @@ -462,8 +461,8 @@ mod tests { #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_data_changed"] - fn MyObject_dataChangedConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerdataChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = "MyObject_dataChangedConnect"] + fn MyObject_connect_data_changed(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerdataChanged, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }, ); @@ -620,8 +619,8 @@ mod tests { #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_unsafe_signal"] - fn MyObject_unsafeSignalConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerunsafeSignal, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = "MyObject_unsafeSignalConnect"] + fn MyObject_connect_unsafe_signal(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerunsafeSignal, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }, ); @@ -773,8 +772,8 @@ mod tests { #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_existing_signal"] - fn MyObject_baseNameConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerbaseName, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = "MyObject_baseNameConnect"] + fn MyObject_connect_existing_signal(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerbaseName, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }, ); @@ -925,8 +924,8 @@ mod tests { #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_ready"] - fn MyObject_readyConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = "MyObject_readyConnect"] + fn MyObject_connect_ready(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }, ); @@ -1069,8 +1068,8 @@ mod tests { #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_ready"] - fn MyObject_readyConnect(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; + #[cxx_name = "MyObject_readyConnect"] + fn MyObject_connect_ready(self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType) -> CxxQtQMetaObjectConnection; } }, ); diff --git a/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.cpp b/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.cpp index 5cd9c932b..6dff54d5e 100644 --- a/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.cpp +++ b/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.cpp @@ -94,7 +94,7 @@ static_assert( namespace mynamespace::rust::cxxqtgen1 { ::QMetaObject::Connection -ExternObject_dataReadyConnect( +ExternObjectCpp_dataReadyConnect( mynamespace::ExternObjectCpp& self, ::mynamespace::rust::cxxqtgen1::ExternObjectCxxQtSignalHandlerdataReady closure, @@ -152,7 +152,7 @@ static_assert( namespace mynamespace::rust::cxxqtgen1 { ::QMetaObject::Connection -ExternObject_errorOccurredConnect( +ExternObjectCpp_errorOccurredConnect( mynamespace::ExternObjectCpp& self, ::mynamespace::rust::cxxqtgen1::ExternObjectCxxQtSignalHandlererrorOccurred closure, diff --git a/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.h b/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.h index 0831dd633..6d63ece3c 100644 --- a/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.h +++ b/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.h @@ -70,7 +70,7 @@ QPushButton_clickedConnect( namespace mynamespace::rust::cxxqtgen1 { ::QMetaObject::Connection -ExternObject_dataReadyConnect( +ExternObjectCpp_dataReadyConnect( mynamespace::ExternObjectCpp& self, ::mynamespace::rust::cxxqtgen1::ExternObjectCxxQtSignalHandlerdataReady closure, @@ -79,7 +79,7 @@ ExternObject_dataReadyConnect( namespace mynamespace::rust::cxxqtgen1 { ::QMetaObject::Connection -ExternObject_errorOccurredConnect( +ExternObjectCpp_errorOccurredConnect( mynamespace::ExternObjectCpp& self, ::mynamespace::rust::cxxqtgen1::ExternObjectCxxQtSignalHandlererrorOccurred closure, diff --git a/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.rs b/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.rs index 8628875aa..189837444 100644 --- a/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.rs +++ b/crates/cxx-qt-gen/test_outputs/passthrough_and_naming.rs @@ -104,8 +104,8 @@ pub mod ffi { >; #[doc(hidden)] #[namespace = "cxx_qt::multi_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_property_name_changed"] - fn MyObject_propertyNameChangedConnect( + #[cxx_name = "MyObject_propertyNameChangedConnect"] + fn MyObject_connect_property_name_changed( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerpropertyNameChanged, conn_type: CxxQtConnectionType, @@ -139,8 +139,8 @@ pub mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "cxx_qt::multi_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_ready"] - fn MyObject_readyConnect( + #[cxx_name = "MyObject_readyConnect"] + fn MyObject_connect_ready( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType, @@ -237,8 +237,8 @@ pub mod ffi { >; #[doc(hidden)] #[namespace = "second_object::rust::cxxqtgen1"] - #[rust_name = "SecondObject_connect_property_name_changed"] - fn SecondObject_propertyNameChangedConnect( + #[cxx_name = "SecondObject_propertyNameChangedConnect"] + fn SecondObject_connect_property_name_changed( self_value: Pin<&mut SecondObject>, signal_handler: SecondObjectCxxQtSignalHandlerpropertyNameChanged, conn_type: CxxQtConnectionType, @@ -273,8 +273,8 @@ pub mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "second_object::rust::cxxqtgen1"] - #[rust_name = "SecondObject_connect_ready"] - fn SecondObject_readyConnect( + #[cxx_name = "SecondObject_readyConnect"] + fn SecondObject_connect_ready( self_value: Pin<&mut SecondObject>, signal_handler: SecondObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType, @@ -322,8 +322,8 @@ pub mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "rust::cxxqtgen1"] - #[rust_name = "QPushButton_connect_clicked"] - fn QPushButton_clickedConnect( + #[cxx_name = "QPushButton_clickedConnect"] + fn QPushButton_connect_clicked( self_value: Pin<&mut QPushButton>, signal_handler: QPushButtonCxxQtSignalHandlerclicked, conn_type: CxxQtConnectionType, @@ -352,8 +352,8 @@ pub mod ffi { >; #[doc(hidden)] #[namespace = "mynamespace::rust::cxxqtgen1"] - #[rust_name = "ExternObject_connect_data_ready"] - fn ExternObject_dataReadyConnect( + #[cxx_name = "ExternObjectCpp_dataReadyConnect"] + fn ExternObject_connect_data_ready( self_value: Pin<&mut ExternObject>, signal_handler: ExternObjectCxxQtSignalHandlerdataReady, conn_type: CxxQtConnectionType, @@ -384,8 +384,8 @@ pub mod ffi { >; #[doc(hidden)] #[namespace = "mynamespace::rust::cxxqtgen1"] - #[rust_name = "ExternObject_connect_error_occurred"] - fn ExternObject_errorOccurredConnect( + #[cxx_name = "ExternObjectCpp_errorOccurredConnect"] + fn ExternObject_connect_error_occurred( self_value: Pin<&mut ExternObject>, signal_handler: ExternObjectCxxQtSignalHandlererrorOccurred, conn_type: CxxQtConnectionType, diff --git a/crates/cxx-qt-gen/test_outputs/properties.rs b/crates/cxx-qt-gen/test_outputs/properties.rs index 618b5d548..68c14a2f6 100644 --- a/crates/cxx-qt-gen/test_outputs/properties.rs +++ b/crates/cxx-qt-gen/test_outputs/properties.rs @@ -62,8 +62,8 @@ mod ffi { >; #[doc(hidden)] #[namespace = "cxx_qt::my_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_primitive_changed"] - fn MyObject_primitiveChangedConnect( + #[cxx_name = "MyObject_primitiveChangedConnect"] + fn MyObject_connect_primitive_changed( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerprimitiveChanged, conn_type: CxxQtConnectionType, @@ -94,8 +94,8 @@ mod ffi { >; #[doc(hidden)] #[namespace = "cxx_qt::my_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_trivial_changed"] - fn MyObject_trivialChangedConnect( + #[cxx_name = "MyObject_trivialChangedConnect"] + fn MyObject_connect_trivial_changed( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlertrivialChanged, conn_type: CxxQtConnectionType, diff --git a/crates/cxx-qt-gen/test_outputs/signals.rs b/crates/cxx-qt-gen/test_outputs/signals.rs index 3479a5648..263d973b1 100644 --- a/crates/cxx-qt-gen/test_outputs/signals.rs +++ b/crates/cxx-qt-gen/test_outputs/signals.rs @@ -50,8 +50,8 @@ mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "cxx_qt::my_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_ready"] - fn MyObject_readyConnect( + #[cxx_name = "MyObject_readyConnect"] + fn MyObject_connect_ready( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerready, conn_type: CxxQtConnectionType, @@ -84,8 +84,8 @@ mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "cxx_qt::my_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_data_changed"] - fn MyObject_dataChangedConnect( + #[cxx_name = "MyObject_dataChangedConnect"] + fn MyObject_connect_data_changed( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlerdataChanged, conn_type: CxxQtConnectionType, @@ -122,8 +122,8 @@ mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "cxx_qt::my_object::rust::cxxqtgen1"] - #[rust_name = "MyObject_connect_base_class_new_data"] - fn MyObject_newDataConnect( + #[cxx_name = "MyObject_newDataConnect"] + fn MyObject_connect_base_class_new_data( self_value: Pin<&mut MyObject>, signal_handler: MyObjectCxxQtSignalHandlernewData, conn_type: CxxQtConnectionType, @@ -170,8 +170,8 @@ mod ffi { cxx_qt::signalhandler::CxxQtSignalHandler; #[doc(hidden)] #[namespace = "cxx_qt::my_object::rust::cxxqtgen1"] - #[rust_name = "QTimer_connect_timeout"] - fn QTimer_timeoutConnect( + #[cxx_name = "QTimer_timeoutConnect"] + fn QTimer_connect_timeout( self_value: Pin<&mut QTimer>, signal_handler: QTimerCxxQtSignalHandlertimeout, conn_type: CxxQtConnectionType, From 1a73a203c7962186c9c6d64cf2ed396fabc458e8 Mon Sep 17 00:00:00 2001 From: Leon Matthes Date: Tue, 4 Jun 2024 16:46:19 +0200 Subject: [PATCH 4/4] refactor: Pluralize SignalNames&SignalHelperNames --- crates/cxx-qt-gen/src/generator/cpp/signal.rs | 6 +++--- crates/cxx-qt-gen/src/generator/naming/signals.rs | 14 +++++++------- crates/cxx-qt-gen/src/generator/rust/signals.rs | 8 ++++---- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/crates/cxx-qt-gen/src/generator/cpp/signal.rs b/crates/cxx-qt-gen/src/generator/cpp/signal.rs index 22bedc907..61045d920 100644 --- a/crates/cxx-qt-gen/src/generator/cpp/signal.rs +++ b/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,8 +94,8 @@ 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.cxx_unqualified(); let free_connect_ident_cpp = idents_helper.connect_name.cxx_unqualified(); diff --git a/crates/cxx-qt-gen/src/generator/naming/signals.rs b/crates/cxx-qt-gen/src/generator/naming/signals.rs index 675ce6ad6..4e4cb151f 100644 --- a/crates/cxx-qt-gen/src/generator/naming/signals.rs +++ b/crates/cxx-qt-gen/src/generator/naming/signals.rs @@ -8,13 +8,13 @@ use quote::format_ident; use syn::{Ident, Result}; /// Names for parts of a Q_SIGNAL -pub struct QSignalName { +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.name.clone(), @@ -36,7 +36,7 @@ fn on_from_signal(ident: &Ident) -> Ident { format_ident!("on_{}", ident.to_string().to_case(Case::Snake)) } -pub struct QSignalHelperName { +pub struct QSignalHelperNames { pub connect_name: Name, pub function_call: Ident, pub function_drop: Ident, @@ -47,8 +47,8 @@ pub struct QSignalHelperName { pub struct_param: Ident, } -impl QSignalHelperName { - pub fn new(idents: &QSignalName, qobject_name: &Name) -> Result { +impl QSignalHelperNames { + pub fn new(idents: &QSignalNames, qobject_name: &Name) -> Result { 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}"); @@ -120,7 +120,7 @@ mod tests { private: false, }; - let names = QSignalName::from(&qsignal); + let names = QSignalNames::from(&qsignal); assert_eq!(names.name.cxx_unqualified(), "dataChanged"); assert_eq!( names.name.rust_unqualified(), @@ -150,7 +150,7 @@ mod tests { private: false, }; - let names = QSignalName::from(&qsignal); + let names = QSignalNames::from(&qsignal); assert_eq!(names.name.cxx_unqualified(), "baseName"); assert_eq!( names.name.rust_unqualified(), diff --git a/crates/cxx-qt-gen/src/generator/rust/signals.rs b/crates/cxx-qt-gen/src/generator/rust/signals.rs index 8ca1d466f..3eb428d01 100644 --- a/crates/cxx-qt-gen/src/generator/rust/signals.rs +++ b/crates/cxx-qt-gen/src/generator/rust/signals.rs @@ -7,7 +7,7 @@ use crate::{ generator::{ naming::{ qobject::QObjectNames, - signals::{QSignalHelperName, QSignalName}, + signals::{QSignalHelperNames, QSignalNames}, }, rust::fragment::{GeneratedRustFragment, RustFragmentPair}, }, @@ -24,8 +24,8 @@ pub fn generate_rust_signal( type_names: &TypeNames, module_ident: &Ident, ) -> Result { - 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 qobject_name_rust = qobject_name.rust_unqualified(); @@ -220,7 +220,7 @@ pub fn generate_rust_signals( if attribute_find_path(&signal.method.attrs, &["cxx_name"]).is_none() && attribute_find_path(&signal.method.attrs, &["rust_name"]).is_none() { - let idents = QSignalName::from(&signal); + let idents = QSignalNames::from(&signal); let signal_name_cpp = idents.name.cxx_unqualified(); signal .method