Add support for Self inlining in extern C++Qt blocks

Author: BenFordTytherington

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

@@ -73,7 +73,7 @@ impl ParsedCxxQtData {
     /// If there are unresolved methods in the list, but inline is false, it will error,
     /// as the self inlining is only available if there is exactly one `QObject` in the block,
     /// and this indicates that no inlining can be done, but some `Self` types were present.
-    fn try_inline_self_types(
+    pub fn try_inline_self_types(
         inline: bool,
         type_to_inline: &Option<Ident>,
         invokables: &mut [impl DerefMut<Target = MethodFields>],
@@ -824,7 +824,18 @@ mod tests {
             }
         };
 
+        let extern_cpp_qt: Item = parse_quote! {
+            unsafe extern "C++Qt" {
+                #[qobject]
+                type MyObject;
+
+                #[qsignal]
+                fn my_signal(self: Pin<&mut Self>);
+            }
+        };
+
         parsed_cxxqtdata.parse_cxx_qt_item(extern_rust_qt).unwrap();
+        parsed_cxxqtdata.parse_cxx_qt_item(extern_cpp_qt).unwrap();
     }
 
     #[test]

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

@@ -3,13 +3,15 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use crate::parser::cxxqtdata::ParsedCxxQtData;
 use crate::{
     parser::{
         externqobject::ParsedExternQObject, require_attributes, signals::ParsedSignal,
         CaseConversion,
     },
     syntax::{attribute::attribute_get_path, expr::expr_to_string},
 };
+use quote::format_ident;
 use syn::{spanned::Spanned, Error, ForeignItem, Ident, ItemForeignMod, Result, Token};
 
 /// Representation of an extern "C++Qt" block
@@ -54,6 +56,9 @@ impl ParsedExternCxxQt {
             ..Default::default()
         };
 
+        let mut qobjects = vec![];
+        let mut signals = vec![];
+
         // Parse any signals, other items are passed through
         for item in foreign_mod.items.drain(..) {
             match item {
@@ -74,7 +79,7 @@ impl ParsedExternCxxQt {
                         // extern "C++Qt" signals are always inherit = true
                         // as they always exist on an existing QObject
                         signal.inherit = true;
-                        extern_cxx_block.signals.push(signal);
+                        signals.push(signal);
                     } else {
                         extern_cxx_block
                             .passthrough_items
@@ -89,7 +94,7 @@ impl ParsedExternCxxQt {
                         let extern_ty =
                             ParsedExternQObject::parse(foreign_ty, module_ident, parent_namespace)?;
                         // Pass through types separately for generation
-                        extern_cxx_block.qobjects.push(extern_ty);
+                        qobjects.push(extern_ty);
                     } else {
                         return Err(Error::new(
                             foreign_ty.span(),
@@ -103,6 +108,16 @@ impl ParsedExternCxxQt {
             }
         }
 
+        let inline_self = qobjects.len() == 1;
+        let inline_ident = qobjects
+            .last()
+            .map(|obj| format_ident!("{}", obj.name.cxx_unqualified()));
+
+        ParsedCxxQtData::try_inline_self_types(inline_self, &inline_ident, &mut signals)?;
+
+        extern_cxx_block.qobjects.extend(qobjects);
+        extern_cxx_block.signals.extend(signals);
+
         Ok(extern_cxx_block)
     }
 }

crates/cxx-qt-gen/test_inputs/signals.rs

@@ -16,7 +16,7 @@ mod ffi {
 
         /// When the QTimer timeout occurs
         #[qsignal]
-        pub(self) fn timeout(self: Pin<&mut QTimer>);
+        pub(self) fn timeout(self: Pin<&mut Self>);
     }
 
     unsafe extern "RustQt" {