Add shorthand support for &self and Pin<&mut Self> in RustQt blocks where the type can be inferred

BenFordTytherington · BenFordTytherington · commit e457080e7089 · 2025-04-04T16:51:38.000+01:00
- If exactly one QObject is present in a block with a method, it will infer `Self` to represent that qobject
- Updates one of the examples to test this out
diff --git a/crates/cxx-qt-gen/src/parser/cxxqtdata.rs b/crates/cxx-qt-gen/src/parser/cxxqtdata.rs
@@ -6,6 +6,7 @@
 use super::qnamespace::ParsedQNamespace;
 use super::trait_impl::TraitImpl;
 use crate::naming::cpp::err_unsupported_item;
+use crate::parser::method::MethodFields;
 use crate::parser::CaseConversion;
 use crate::{
     parser::{
@@ -17,6 +18,8 @@ use crate::{
         path::path_compare_str,
     },
 };
+use quote::format_ident;
+use std::ops::DerefMut;
 use syn::{
     spanned::Spanned, Error, ForeignItem, Ident, Item, ItemEnum, ItemForeignMod, ItemImpl,
     ItemMacro, Meta, Result,
@@ -65,6 +68,33 @@ impl ParsedCxxQtData {
         }
     }
 
+    fn try_inline_self_types(
+        inline: bool,
+        type_to_inline: &Option<Ident>,
+        invokables: &mut [impl DerefMut<Target = MethodFields>],
+    ) -> Result<()> {
+        for method in invokables.iter_mut() {
+            if method.self_unresolved {
+                if inline {
+                    if let Some(inline_type) = type_to_inline.clone() {
+                        method.qobject_ident = inline_type;
+                    } else {
+                        return Err(Error::new(
+                            method.method.span(),
+                            "Expected a type to inline, no `qobject` typename was passed!",
+                        ));
+                    }
+                } else {
+                    return Err(Error::new(
+                        method.method.span(),
+                        "`Self` type can only be inferred if the extern block contains only one `qobject`.",
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Determine if the given [syn::Item] is a CXX-Qt related item
     /// If it is then add the [syn::Item] into qobjects BTreeMap
     /// Otherwise return the [syn::Item] to pass through to CXX
@@ -139,6 +169,12 @@ impl ParsedCxxQtData {
 
         let auto_case = CaseConversion::from_attrs(&attrs)?;
 
+        let mut qobjects = vec![];
+
+        let mut methods = vec![];
+        let mut signals = vec![];
+        let mut inherited = vec![];
+
         let namespace = attrs
             .get("namespace")
             .map(|attr| expr_to_string(&attr.meta.require_name_value()?.value))
@@ -159,7 +195,7 @@ impl ParsedCxxQtData {
                             return Err(Error::new(foreign_fn.span(), "block must be declared `unsafe extern \"RustQt\"` if it contains any safe-to-call #[inherit] qsignals"));
                         }
 
-                        self.signals.push(parsed_signal_method);
+                        signals.push(parsed_signal_method);
 
                         // Test if the function is an inheritance method
                         //
@@ -175,15 +211,15 @@ impl ParsedCxxQtData {
                         let parsed_inherited_method =
                             ParsedInheritedMethod::parse(foreign_fn, auto_case)?;
 
-                        self.inherited_methods.push(parsed_inherited_method);
+                        inherited.push(parsed_inherited_method);
                         // Remaining methods are either C++ methods or invokables
                     } else {
                         let parsed_method = ParsedMethod::parse(
                             foreign_fn,
                             auto_case,
                             foreign_mod.unsafety.is_some(),
                         )?;
-                        self.methods.push(parsed_method);
+                        methods.push(parsed_method);
                     }
                 }
                 ForeignItem::Verbatim(tokens) => {
@@ -199,12 +235,28 @@ impl ParsedCxxQtData {
 
                     // Note that we assume a compiler error will occur later
                     // if you had two structs with the same name
-                    self.qobjects.push(qobject);
+                    qobjects.push(qobject);
                 }
-                // Const Macro, Type are unsupported in extern "RustQt" for now
+                // Const, Macro, Type are unsupported in extern "RustQt" for now
                 _ => return Err(err_unsupported_item(&item)),
             }
         }
+
+        // If there is exaclty one qobject in the block, it can be inlined as a self type.
+        let inline_self = qobjects.len() == 1;
+        let inline_ident = qobjects
+            .last()
+            .map(|obj| format_ident!("{}", obj.name.cxx_unqualified()));
+
+        Self::try_inline_self_types(inline_self, &inline_ident, &mut methods)?;
+        Self::try_inline_self_types(inline_self, &inline_ident, &mut signals)?;
+        Self::try_inline_self_types(inline_self, &inline_ident, &mut inherited)?;
+
+        self.qobjects.extend(qobjects);
+        self.methods.extend(methods);
+        self.signals.extend(signals);
+        self.inherited_methods.extend(inherited);
+
         Ok(())
     }
 
@@ -735,4 +787,81 @@ mod tests {
             Some("b")
         );
     }
+
+    #[test]
+    fn test_self_inlining_ref() {
+        let mut parsed_cxxqtdata = ParsedCxxQtData::new(format_ident!("ffi"), None);
+        let extern_rust_qt: Item = parse_quote! {
+            unsafe extern "RustQt" {
+                #[qobject]
+                type MyObject = super::T;
+
+                fn my_method(&self);
+
+                #[inherit]
+                fn my_inherited_method(&self);
+            }
+        };
+
+        parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
+    }
+
+    #[test]
+    fn test_self_inlining_pin() {
+        let mut parsed_cxxqtdata = ParsedCxxQtData::new(format_ident!("ffi"), None);
+        let extern_rust_qt: Item = parse_quote! {
+            unsafe extern "RustQt" {
+                #[qobject]
+                type MyObject = super::T;
+
+                #[qsignal]
+                fn my_signal(self: Pin<&mut Self>);
+            }
+        };
+
+        parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
+    }
+
+    #[test]
+    fn test_self_inlining_methods_invalid() {
+        assert_parse_errors! {
+            |item| ParsedCxxQtData::new(format_ident!("ffi"), None).parse_cxx_qt_item(item) =>
+            // No QObject in block
+            {
+                extern "RustQt" {
+                    fn my_method(&self);
+                }
+            }
+
+            {
+                extern "RustQt" {
+                    fn my_method(self: Pin<&mut Self>);
+                }
+            }
+            // More than 1 QObjects in block
+            {
+                extern "RustQt" {
+                    #[qobject]
+                    type MyObject = super::T;
+
+                    #[qobject]
+                    type MyOtherObject = super::S;
+
+                    fn my_method(&self);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_invalid_inline_call() {
+        let method_sig = parse_quote! {
+            fn test(&self);
+        };
+        let mut methods = vec![ParsedMethod::mock_qinvokable(&method_sig)];
+
+        // If inlining is set to take place, an Ident is required to inline, here it is `None`
+        let data = ParsedCxxQtData::try_inline_self_types(true, &None, &mut methods);
+        assert!(data.is_err());
+    }
 }
diff --git a/crates/cxx-qt-gen/src/parser/inherit.rs b/crates/cxx-qt-gen/src/parser/inherit.rs
@@ -8,6 +8,7 @@ use crate::parser::{
 };
 use core::ops::Deref;
 use quote::format_ident;
+use std::ops::DerefMut;
 use syn::{Attribute, ForeignItemFn, Ident, Result};
 
 /// Describes a method found in an extern "RustQt" with #[inherit]
@@ -56,6 +57,12 @@ impl Deref for ParsedInheritedMethod {
     }
 }
 
+impl DerefMut for ParsedInheritedMethod {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.method_fields
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -68,7 +75,6 @@ mod tests {
             |item| ParsedInheritedMethod::parse(item, CaseConversion::none()) =>
 
             // Missing self type
-            { fn test(&self); }
             { fn test(self: &mut T); }
             // Pointer types
             { fn test(self: *const T); }
@@ -91,6 +97,14 @@ mod tests {
             CaseConversion::none()
         )
         .is_ok());
+        // T by ref is ok in this shorthand (provided the block has one QObject)
+        assert!(ParsedInheritedMethod::parse(
+            parse_quote! {
+                fn test(&self);
+            },
+            CaseConversion::none()
+        )
+        .is_ok());
         // T by Pin
         assert!(ParsedInheritedMethod::parse(
             parse_quote! {
diff --git a/crates/cxx-qt-gen/src/parser/method.rs b/crates/cxx-qt-gen/src/parser/method.rs
@@ -9,7 +9,9 @@ use crate::{
     syntax::{foreignmod, types},
 };
 use core::ops::Deref;
+use quote::format_ident;
 use std::collections::{BTreeMap, HashSet};
+use std::ops::DerefMut;
 use syn::{Attribute, ForeignItemFn, Ident, Result};
 
 /// Describes a C++ specifier for the Q_INVOKABLE
@@ -146,6 +148,12 @@ impl Deref for ParsedMethod {
     }
 }
 
+impl DerefMut for ParsedMethod {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.method_fields
+    }
+}
+
 /// Struct with common fields between Invokable types.
 /// These types are ParsedSignal, ParsedMethod and ParsedInheritedMethod
 #[derive(Clone)]
@@ -156,6 +164,7 @@ pub struct MethodFields {
     pub parameters: Vec<ParsedFunctionParameter>,
     pub safe: bool,
     pub name: Name,
+    pub self_unresolved: bool,
 }
 
 impl MethodFields {
@@ -164,6 +173,8 @@ impl MethodFields {
         let (qobject_ident, mutability) = types::extract_qobject_ident(&self_receiver.ty)?;
         let mutable = mutability.is_some();
 
+        let self_unresolved = qobject_ident == format_ident!("Self");
+
         let parameters = ParsedFunctionParameter::parse_all_ignoring_receiver(&method.sig)?;
         let safe = method.sig.unsafety.is_none();
         let name =
@@ -176,6 +187,7 @@ impl MethodFields {
             parameters,
             safe,
             name,
+            self_unresolved,
         })
     }
 }
diff --git a/crates/cxx-qt-gen/src/parser/signals.rs b/crates/cxx-qt-gen/src/parser/signals.rs
@@ -8,6 +8,7 @@ use crate::{
     syntax::path::path_compare_str,
 };
 use core::ops::Deref;
+use std::ops::DerefMut;
 use syn::{spanned::Spanned, Attribute, Error, ForeignItemFn, Result, Visibility};
 
 #[derive(Clone)]
@@ -74,6 +75,12 @@ impl Deref for ParsedSignal {
     }
 }
 
+impl DerefMut for ParsedSignal {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.method_fields
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use syn::parse_quote;
diff --git a/crates/cxx-qt-gen/src/syntax/foreignmod.rs b/crates/cxx-qt-gen/src/syntax/foreignmod.rs
@@ -174,14 +174,7 @@ pub fn self_type_from_foreign_fn(signature: &Signature) -> Result<Receiver> {
             ));
         }
 
-        if receiver.reference.is_some() {
-            return Err(Error::new(
-                receiver.span(),
-                "Reference on self (i.e. `&self`) are not supported! Use `self: &T` instead",
-            ));
-        }
-
-        if receiver.colon_token.is_none() {
+        if receiver.colon_token.is_none() && receiver.reference.is_none() {
             return Err(Error::new(
                 receiver.span(),
                 "`self` is not supported as receiver! Use `self: T` to indicate a type.",
@@ -254,8 +247,6 @@ mod tests {
             { fn foo(self); }
             // self with mut
             { fn foo(mut self: T); }
-            // self reference
-            { fn foo(&self); }
             // self reference with mut
             { fn foo(&mut self); }
             // attribute on self type
diff --git a/crates/cxx-qt-gen/test_inputs/signals.rs b/crates/cxx-qt-gen/test_inputs/signals.rs
@@ -24,11 +24,11 @@ mod ffi {
         type MyObject = super::MyObjectRust;
 
         #[qsignal]
-        fn ready(self: Pin<&mut MyObject>);
+        fn ready(self: Pin<&mut Self>);
 
         #[qsignal]
         fn data_changed(
-            self: Pin<&mut MyObject>,
+            self: Pin<&mut Self>,
             first: i32,
             second: UniquePtr<Opaque>,
             third: QPoint,
@@ -39,14 +39,14 @@ mod ffi {
         #[inherit]
         #[qsignal]
         fn base_class_new_data(
-            self: Pin<&mut MyObject>,
+            self: Pin<&mut Self>,
             first: i32,
             second: UniquePtr<Opaque>,
             third: QPoint,
             fourth: &'a QPoint,
         );
 
         #[qinvokable]
-        fn invokable(self: Pin<&mut MyObject>);
+        fn invokable(self: Pin<&mut Self>);
     }
 }
diff --git a/examples/qml_minimal/rust/src/cxxqt_object.rs b/examples/qml_minimal/rust/src/cxxqt_object.rs
