Allow immutable signals, and add one to qml_features

Author: BenFordTytherington

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

@@ -51,6 +51,7 @@ fn parameter_types_and_values(
     parameters: &[ParsedFunctionParameter],
     type_names: &TypeNames,
     self_ty: &Name,
+    mutable: bool,
 ) -> Result<Parameters> {
     let mut parameter_named_types_with_self = vec![];
     let mut parameter_types_with_self = vec![];
@@ -66,10 +67,11 @@ fn parameter_types_and_values(
 
     let parameter_named_types = parameter_named_types_with_self.join(", ");
 
+    let is_const = if !mutable { " const" } else { "" };
     // Insert the extra argument into the closure
     let self_ty = self_ty.cxx_qualified();
-    parameter_named_types_with_self.insert(0, format!("{self_ty}& self"));
-    parameter_types_with_self.insert(0, format!("{self_ty}&"));
+    parameter_named_types_with_self.insert(0, format!("{self_ty}{is_const}& self"));
+    parameter_types_with_self.insert(0, format!("{self_ty}{is_const}&"));
     parameter_values_with_self.insert(0, "self".to_owned());
 
     Ok(Parameters {
@@ -109,7 +111,8 @@ pub fn generate_cpp_signal(
     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)?;
+    let parameters =
+        parameter_types_and_values(&signal.parameters, type_names, qobject_name, signal.mutable)?;
     let parameters_named_types = parameters.named_types;
     let parameters_named_types_with_self = parameters.named_types_with_self;
     let parameter_types_with_self = parameters.types_with_self;
@@ -121,6 +124,8 @@ pub fn generate_cpp_signal(
     let signal_handler_call = idents_helper.function_call;
     let signal_handler_drop = idents_helper.function_drop;
     let namespace = idents_helper.namespace;
+    let reference_type = if !signal.mutable { " const &" } else { "&" };
+    let is_const = if !signal.mutable { " const" } else { "" };
 
     let signal_handler_type = format!("SignalHandler<::{namespace}::{param_struct} *>");
 
@@ -135,7 +140,7 @@ pub fn generate_cpp_signal(
     // Generate the Q_SIGNAL if this is not an existing signal
     if !signal.inherit {
         generated.methods.push(CppFragment::Header(format!(
-            "Q_SIGNAL void {signal_ident}({parameters_named_types});"
+            "Q_SIGNAL void {signal_ident}({parameters_named_types}){is_const};"
         )));
     }
 
@@ -144,7 +149,7 @@ pub fn generate_cpp_signal(
         r#"
             namespace {namespace} {{
             ::QMetaObject::Connection
-            {free_connect_ident_cpp}({qobject_ident_namespaced}& self, {signal_handler_alias_namespaced} closure, ::Qt::ConnectionType type);
+            {free_connect_ident_cpp}({qobject_ident_namespaced}{reference_type} self, {signal_handler_alias_namespaced} closure, ::Qt::ConnectionType type);
             }} // namespace {namespace}
             "#
         },
@@ -177,7 +182,7 @@ pub fn generate_cpp_signal(
 
             namespace {namespace} {{
             ::QMetaObject::Connection
-            {free_connect_ident_cpp}({qobject_ident_namespaced}& self, {signal_handler_alias_namespaced} closure, ::Qt::ConnectionType type)
+            {free_connect_ident_cpp}({qobject_ident_namespaced}{reference_type} self, {signal_handler_alias_namespaced} closure, ::Qt::ConnectionType type)
             {{
                 return ::QObject::connect(
                     &self,

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

@@ -85,9 +85,10 @@ pub fn generate_rust_signal(
     let self_type_cxx = if signal.mutable {
         parse_quote_spanned! {span => Pin<&mut #qobject_name_rust> }
     } else {
-        // CODECOV_EXCLUDE_START
-        unreachable!("Signals cannot be immutable right now so this cannot be reached")
-        // CODECOV_EXCLUDE_STOP
+        // // CODECOV_EXCLUDE_START
+        // unreachable!("Signals cannot be immutable right now so this cannot be reached")
+        // // CODECOV_EXCLUDE_STOP
+        parse_quote_spanned! {span => &#qobject_name_rust }
     };
     let self_type_qualified = syn_type_cxx_bridge_to_qualified(&self_type_cxx, type_names)?;
     let qualified_impl = qobject_name.rust_qualified();

crates/cxx-qt-gen/src/parser/signals.rs

@@ -42,12 +42,13 @@ impl ParsedSignal {
         let fields = MethodFields::parse(method, auto_case)?;
         let attrs = require_attributes(&fields.method.attrs, &Self::ALLOWED_ATTRS)?;
 
-        if !fields.mutable {
-            return Err(Error::new(
-                fields.method.span(),
-                "signals must be mutable, use Pin<&mut T> instead of T for the self type",
-            ));
-        }
+        // TODO: add proper checks
+        // if !fields.mutable {
+        //     return Err(Error::new(
+        //         fields.method.span(),
+        //         "signals must be mutable, use Pin<&mut T> instead of T for the self type",
+        //     ));
+        // }
 
         let inherit = attrs.contains_key("inherit");
 
@@ -96,17 +97,13 @@ mod tests {
         assert_parse_errors! {
             |input| ParsedSignal::parse(input, CaseConversion::none()) =>
 
-            // No immutable signals
-            { fn ready(self: &MyObject); }
+            // No namespaces
             {
-                // No namespaces
                 #[namespace = "disallowed_namespace"]
                 fn ready(self: Pin<&mut MyObject>);
             }
             // Missing self
             { fn ready(x: f64); }
-            // Self needs to be receiver like self: &T instead of &self
-            { fn ready(&self); }
         }
     }
 

examples/qml_features/cpp/external_qobject.h

@@ -22,4 +22,5 @@ class ExternalQObject : public QObject
 Q_SIGNALS:
   void triggered();
   void triggeredPrivateSignal(QPrivateSignal);
+  void triggeredConstSignal() const;
 };

examples/qml_features/rust/src/externcxxqt.rs

@@ -22,6 +22,11 @@ pub mod ffi {
         #[qsignal]
         fn triggered(self: Pin<&mut Self>);
 
+        /// const signal that is emitted when trigger is fired
+        #[qsignal]
+        #[rust_name = "triggered_const_signal"]
+        fn triggeredConstSignal(&self);
+
         /// Private signal that is emitted when trigger is fired
         #[qsignal]
         #[rust_name = "triggered_private_signal"]