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 4e49eae25..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,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 }, }, ], - 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, diff --git a/crates/cxx-qt-gen/src/generator/naming/signals.rs b/crates/cxx-qt-gen/src/generator/naming/signals.rs index 521ba294d..4e4cb151f 100644 --- a/crates/cxx-qt-gen/src/generator/naming/signals.rs +++ b/crates/cxx-qt-gen/src/generator/naming/signals.rs @@ -2,46 +2,42 @@ // 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}; /// 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 { - let signal_ident = &idents.name.cpp; +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}"); 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")); } 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/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 564602dfa..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,20 +24,18 @@ 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(); - let signal_name_cpp = idents.name.cpp; - let signal_name_cpp_str = signal_name_cpp.to_string(); - let connect_ident_rust = idents.connect_name.rust; + let signal_name_cpp = idents.name.cxx_unqualified(); + 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 @@ -112,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; } }); @@ -134,7 +132,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 +147,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."] @@ -222,12 +220,12 @@ 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 signal_name_cpp_str = idents.name.cpp.to_string(); + let idents = QSignalNames::from(&signal); + 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 @@ -248,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}; @@ -263,10 +261,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready"), - }, + name: Name::new(format_ident!("ready")), safe: true, inherit: false, private: false, @@ -303,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; } }, ); @@ -426,10 +421,7 @@ mod tests { ty: parse_quote! { UniquePtr }, }, ], - 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, @@ -469,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; } }, ); @@ -587,10 +579,8 @@ mod tests { ident: format_ident!("param"), ty: parse_quote! { *mut T }, }], - ident: 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, @@ -629,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; } }, ); @@ -744,10 +734,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, @@ -785,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; } }, ); @@ -898,10 +885,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready"), - }, + name: Name::new(format_ident!("ready")), safe: true, inherit: false, private: false, @@ -940,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; } }, ); @@ -1053,10 +1037,7 @@ mod tests { qobject_ident: format_ident!("MyObject"), mutable: true, parameters: vec![], - ident: CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready"), - }, + name: Name::new(format_ident!("ready")), safe: true, inherit: false, private: true, @@ -1087,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/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 449eadfa0..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, Name::new(format_ident!("ready"))); assert_eq!( - signals[0].ident, - CombinedIdent { - cpp: format_ident!("ready"), - rust: format_ident!("ready") - } - ); - assert_eq!( - signals[1].ident, - CombinedIdent { - cpp: format_ident!("cppDataChanged"), - rust: format_ident!("data_changed") - } + signals[1].name, + Name::new(format_ident!("data_changed")).with_cxx_name("cppDataChanged".to_owned()) ); assert!(!signals[0].inherit); assert!(signals[1].inherit); @@ -685,11 +676,8 @@ mod tests { assert_eq!(signals[0].parameters.len(), 1); assert_eq!(signals[0].parameters[0].ident, "arg"); assert_eq!( - signals[0].ident, - CombinedIdent { - cpp: format_ident!("unsafeSignal"), - rust: format_ident!("unsafe_signal") - } + signals[0].name, + 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 d031fdb0a..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 ident: 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![], - 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, - 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.ident, - 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); @@ -157,11 +140,8 @@ mod tests { assert!(signal.mutable); assert_eq!(signal.parameters, vec![]); assert_eq!( - signal.ident, - CombinedIdent { - cpp: format_ident!("cppReady"), - rust: format_ident!("ready") - } + signal.name, + 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.ident, - 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.ident, - 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.ident, - 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.ident, - 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); 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,