cxx-qt-gen: remove generation of wrapper for emitting signals

This is now unused as the type conversion has been removed.

Related to KDAB#289

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

@@ -42,7 +42,6 @@ pub fn generate_cpp_signals(
 
         // Prepare the idents
         let idents = QSignalName::from(signal);
-        let emit_ident = idents.emit_name.cpp.to_string();
         let signal_ident = idents.name.cpp.to_string();
         let connect_ident = idents.connect_name.cpp.to_string();
 
@@ -55,29 +54,6 @@ pub fn generate_cpp_signals(
             )));
         }
 
-        // Generate the emitters
-        generated.methods.push(CppFragment::Pair {
-            header: format!(
-                "void {ident}({parameters});",
-                ident = emit_ident,
-                parameters = parameter_types_cpp.join(", "),
-            ),
-            source: formatdoc! {
-                r#"
-                void
-                {qobject_ident}::{emit_ident}({parameters})
-                {{
-                    Q_EMIT {ident}({parameter_values});
-                }}
-                "#,
-                ident = signal_ident,
-                parameters = parameter_types_cpp.join(", "),
-                parameter_values = parameter_values_emitter.join(", "),
-                emit_ident = emit_ident,
-                qobject_ident = qobject_ident,
-            },
-        });
-
         // Generate connection
         let mut parameter_types_rust = parameter_types_cpp.clone();
         let mut parameter_values_connection = parameter_values_emitter.clone();
@@ -147,7 +123,7 @@ mod tests {
         let generated =
             generate_cpp_signals(&signals, &qobject_idents, &ParsedCxxMappings::default()).unwrap();
 
-        assert_eq!(generated.methods.len(), 3);
+        assert_eq!(generated.methods.len(), 2);
         let header = if let CppFragment::Header(header) = &generated.methods[0] {
             header
         } else {
@@ -163,26 +139,6 @@ mod tests {
         } else {
             panic!("Expected Pair")
         };
-        assert_str_eq!(
-            header,
-            "void emitDataChanged(::std::int32_t trivial, ::std::unique_ptr<QColor> opaque);"
-        );
-        assert_str_eq!(
-            source,
-            indoc! {r#"
-            void
-            MyObject::emitDataChanged(::std::int32_t trivial, ::std::unique_ptr<QColor> opaque)
-            {
-                Q_EMIT dataChanged(::std::move(trivial), ::std::move(opaque));
-            }
-            "#}
-        );
-
-        let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[2] {
-            (header, source)
-        } else {
-            panic!("Expected Pair")
-        };
         assert_str_eq!(
             header,
             "::QMetaObject::Connection dataChangedConnect(::rust::Fn<void(MyObject&, ::std::int32_t trivial, ::std::unique_ptr<QColor> opaque)> func, ::Qt::ConnectionType type);"
@@ -225,7 +181,7 @@ mod tests {
 
         let generated = generate_cpp_signals(&signals, &qobject_idents, &cxx_mappings).unwrap();
 
-        assert_eq!(generated.methods.len(), 3);
+        assert_eq!(generated.methods.len(), 2);
         let header = if let CppFragment::Header(header) = &generated.methods[0] {
             header
         } else {
@@ -238,23 +194,6 @@ mod tests {
         } else {
             panic!("Expected Pair")
         };
-        assert_str_eq!(header, "void emitDataChanged(A1 mapped);");
-        assert_str_eq!(
-            source,
-            indoc! {r#"
-            void
-            MyObject::emitDataChanged(A1 mapped)
-            {
-                Q_EMIT dataChanged(::std::move(mapped));
-            }
-            "#}
-        );
-
-        let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[2] {
-            (header, source)
-        } else {
-            panic!("Expected Pair")
-        };
         assert_str_eq!(
             header,
             "::QMetaObject::Connection dataChangedConnect(::rust::Fn<void(MyObject&, A1 mapped)> func, ::Qt::ConnectionType type);"
@@ -290,25 +229,9 @@ mod tests {
         let generated =
             generate_cpp_signals(&signals, &qobject_idents, &ParsedCxxMappings::default()).unwrap();
 
-        assert_eq!(generated.methods.len(), 2);
-        let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[0] {
-            (header, source)
-        } else {
-            panic!("Expected Pair")
-        };
-        assert_str_eq!(header, "void emitBaseName();");
-        assert_str_eq!(
-            source,
-            indoc! {r#"
-            void
-            MyObject::emitBaseName()
-            {
-                Q_EMIT baseName();
-            }
-            "#}
-        );
+        assert_eq!(generated.methods.len(), 1);
 
-        let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[1] {
+        let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[0] {
             (header, source)
         } else {
             panic!("Expected Pair")

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

@@ -12,7 +12,6 @@ use syn::Ident;
 pub struct QSignalName {
     pub enum_name: Ident,
     pub name: CombinedIdent,
-    pub emit_name: CombinedIdent,
     pub connect_name: CombinedIdent,
     pub on_name: Ident,
 }
@@ -29,7 +28,6 @@ impl From<&ParsedSignal> for QSignalName {
         Self {
             enum_name: signal.ident.clone(),
             name: CombinedIdent::from_signal(&signal.ident, &cxx_ident),
-            emit_name: CombinedIdent::emit_from_signal(&signal.ident, &cxx_ident),
             connect_name: CombinedIdent::connect_from_signal(&signal.ident, &cxx_ident),
             on_name: on_from_signal(&signal.ident),
         }
@@ -50,14 +48,6 @@ impl CombinedIdent {
         }
     }
 
-    /// For a given signal ident generate the Rust and C++ emit name
-    fn emit_from_signal(ident: &Ident, cxx_ident: &Ident) -> Self {
-        Self {
-            cpp: format_ident!("emit{}", cxx_ident.to_string().to_case(Case::Pascal)),
-            rust: format_ident!("emit_{}", ident.to_string().to_case(Case::Snake)),
-        }
-    }
-
     fn connect_from_signal(ident: &Ident, cxx_ident: &Ident) -> Self {
         Self {
             // Use signalConnect instead of onSignal here so that we don't
@@ -85,8 +75,6 @@ mod tests {
         assert_eq!(names.enum_name, format_ident!("DataChanged"));
         assert_eq!(names.name.cpp, format_ident!("dataChanged"));
         assert_eq!(names.name.rust, format_ident!("data_changed"));
-        assert_eq!(names.emit_name.cpp, format_ident!("emitDataChanged"));
-        assert_eq!(names.emit_name.rust, format_ident!("emit_data_changed"));
         assert_eq!(names.connect_name.cpp, format_ident!("dataChangedConnect"));
         assert_eq!(
             names.connect_name.rust,
@@ -108,8 +96,6 @@ mod tests {
         assert_eq!(names.enum_name, format_ident!("ExistingSignal"));
         assert_eq!(names.name.cpp, format_ident!("baseName"));
         assert_eq!(names.name.rust, format_ident!("existing_signal"));
-        assert_eq!(names.emit_name.cpp, format_ident!("emitBaseName"));
-        assert_eq!(names.emit_name.rust, format_ident!("emit_existing_signal"));
         assert_eq!(names.connect_name.cpp, format_ident!("baseNameConnect"));
         assert_eq!(
             names.connect_name.rust,

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

@@ -36,9 +36,9 @@ pub fn generate_rust_signals(
         let idents = QSignalName::from(signal);
         let signal_ident_rust = idents.enum_name;
         let signal_ident_cpp_str = idents.name.cpp.to_string();
-        let emit_ident_cpp = &idents.emit_name.cpp;
-        let emit_ident_rust = &idents.emit_name.rust;
-        let emit_ident_rust_str = idents.emit_name.rust.to_string();
+        let signal_name_rust = idents.name.rust;
+        let signal_name_rust_str = signal_name_rust.to_string();
+        let signal_name_cpp = idents.name.cpp;
         let connect_ident_cpp = idents.connect_name.cpp;
         let connect_ident_rust = idents.connect_name.rust;
         let connect_ident_rust_str = connect_ident_rust.to_string();
@@ -94,8 +94,8 @@ pub fn generate_rust_signals(
                 quote! {
                     unsafe extern "C++" {
                         #[doc(hidden)]
-                        #[rust_name = #emit_ident_rust_str]
-                        #has_unsafe fn #emit_ident_cpp(#parameter_signatures);
+                        #[rust_name = #signal_name_rust_str]
+                        #has_unsafe fn #signal_name_cpp(#parameter_signatures);
                     }
                 },
                 quote! {
@@ -127,7 +127,7 @@ pub fn generate_rust_signals(
             }],
         };
         signal_matches.push(quote! {
-            #signal_enum_ident::#signal_ident_rust { #(#parameter_names),* } => #has_unsafe { self.#emit_ident_rust(#(#parameter_names),*) }
+            #signal_enum_ident::#signal_ident_rust { #(#parameter_names),* } => #has_unsafe { self.#signal_name_rust(#(#parameter_names),*) }
         });
 
         generated
@@ -201,8 +201,8 @@ mod tests {
             quote! {
                 unsafe extern "C++" {
                     #[doc(hidden)]
-                    #[rust_name = "emit_ready"]
-                    fn emitReady(self: Pin<&mut MyObjectQt>);
+                    #[rust_name = "ready"]
+                    fn ready(self: Pin<&mut MyObjectQt>);
                 }
             },
         );
@@ -226,8 +226,8 @@ mod tests {
             quote! {
                 unsafe extern "C++" {
                     #[doc(hidden)]
-                    #[rust_name = "emit_data_changed"]
-                    fn emitDataChanged(self: Pin<&mut MyObjectQt>, trivial: i32, opaque: UniquePtr<QColor>);
+                    #[rust_name = "data_changed"]
+                    fn dataChanged(self: Pin<&mut MyObjectQt>, trivial: i32, opaque: UniquePtr<QColor>);
                 }
             },
         );
@@ -251,8 +251,8 @@ mod tests {
             quote! {
                 unsafe extern "C++" {
                     #[doc(hidden)]
-                    #[rust_name = "emit_unsafe_signal"]
-                    unsafe fn emitUnsafeSignal(self: Pin<&mut MyObjectQt>, param: *mut T);
+                    #[rust_name = "unsafe_signal"]
+                    unsafe fn unsafeSignal(self: Pin<&mut MyObjectQt>, param: *mut T);
                 }
             },
         );
@@ -276,8 +276,8 @@ mod tests {
             quote! {
                 unsafe extern "C++" {
                     #[doc(hidden)]
-                    #[rust_name = "emit_existing_signal"]
-                    fn emitBaseName(self: Pin<&mut MyObjectQt>);
+                    #[rust_name = "existing_signal"]
+                    fn baseName(self: Pin<&mut MyObjectQt>);
                 }
             },
         );
@@ -390,10 +390,10 @@ mod tests {
                     #[doc = "MyObject"]
                     pub fn emit(self: Pin<&mut Self>, signal: MySignals) {
                         match signal {
-                            MySignals::Ready {} => { self.emit_ready() },
-                            MySignals::DataChanged { trivial, opaque } => { self.emit_data_changed(trivial, opaque) },
-                            MySignals::UnsafeSignal { param } => unsafe { self.emit_unsafe_signal(param) },
-                            MySignals::ExistingSignal {} => { self.emit_existing_signal() }
+                            MySignals::Ready {} => { self.ready() },
+                            MySignals::DataChanged { trivial, opaque } => { self.data_changed(trivial, opaque) },
+                            MySignals::UnsafeSignal { param } => unsafe { self.unsafe_signal(param) },
+                            MySignals::ExistingSignal {} => { self.existing_signal() }
                         }
                     }
                 }

crates/cxx-qt-gen/test_outputs/passthrough_and_naming.cpp

@@ -58,12 +58,6 @@ MyObject::invokableName()
   m_rustObj->invokableNameWrapper(*this);
 }
 
-void
-MyObject::emitReady()
-{
-  Q_EMIT ready();
-}
-
 ::QMetaObject::Connection
 MyObject::readyConnect(::rust::Fn<void(MyObject&)> func,
                        ::Qt::ConnectionType type)
@@ -147,12 +141,6 @@ SecondObject::invokableName()
   m_rustObj->invokableNameWrapper(*this);
 }
 
-void
-SecondObject::emitReady()
-{
-  Q_EMIT ready();
-}
-
 ::QMetaObject::Connection
 SecondObject::readyConnect(::rust::Fn<void(SecondObject&)> func,
                            ::Qt::ConnectionType type)

crates/cxx-qt-gen/test_outputs/passthrough_and_naming.h

@@ -40,7 +40,6 @@ class MyObject : public QStringListModel
   Q_SIGNAL void propertyNameChanged();
   Q_INVOKABLE void invokableName();
   Q_SIGNAL void ready();
-  void emitReady();
   ::QMetaObject::Connection readyConnect(::rust::Fn<void(MyObject&)> func,
                                          ::Qt::ConnectionType type);
 
@@ -82,7 +81,6 @@ class SecondObject : public QObject
   Q_SIGNAL void propertyNameChanged();
   Q_INVOKABLE void invokableName();
   Q_SIGNAL void ready();
-  void emitReady();
   ::QMetaObject::Connection readyConnect(::rust::Fn<void(SecondObject&)> func,
                                          ::Qt::ConnectionType type);
 

crates/cxx-qt-gen/test_outputs/passthrough_and_naming.rs

@@ -99,8 +99,8 @@ pub mod ffi {
     }
     unsafe extern "C++" {
         #[doc(hidden)]
-        #[rust_name = "emit_ready"]
-        fn emitReady(self: Pin<&mut MyObjectQt>);
+        #[rust_name = "ready"]
+        fn ready(self: Pin<&mut MyObjectQt>);
     }
     unsafe extern "C++" {
         #[doc = "Connect the given function pointer to the signal "]
@@ -197,8 +197,8 @@ pub mod ffi {
     }
     unsafe extern "C++" {
         #[doc(hidden)]
-        #[rust_name = "emit_ready"]
-        fn emitReady(self: Pin<&mut SecondObjectQt>);
+        #[rust_name = "ready"]
+        fn ready(self: Pin<&mut SecondObjectQt>);
     }
     unsafe extern "C++" {
         #[doc = "Connect the given function pointer to the signal "]
@@ -375,7 +375,7 @@ mod cxx_qt_ffi {
         #[doc = "MyObject"]
         pub fn emit(self: Pin<&mut Self>, signal: MySignals) {
             match signal {
-                MySignals::Ready {} => self.emit_ready(),
+                MySignals::Ready {} => self.ready(),
             }
         }
     }
@@ -497,7 +497,7 @@ mod cxx_qt_ffi {
         #[doc = "SecondObject"]
         pub fn emit(self: Pin<&mut Self>, signal: SecondSignals) {
             match signal {
-                SecondSignals::Ready {} => self.emit_ready(),
+                SecondSignals::Ready {} => self.ready(),
             }
         }
     }