Add book entry

Author: BenFordTytherington

book/src/bridge/attributes.md

@@ -43,3 +43,8 @@ For [`#[qproperty]`](./extern_rustqt.md#properties), a CXX or Rust name can be p
 The `#[auto_cxx_name]` and `#[auto_rust_name]` attributes can be used to automatically rename cxx and rust names.
 These are placed at a block level on `extern "RustQt"` or `extern "C++Qt"` blocks, and will automatically case convert the items inside, unless they specify either a `rust_name` or `cxx_name`.
 By default `#[auto_cxx_name]` will generate a camelCase conversion for`cxx_name` and `#[auto_rust_name]` will generate a snake_case conversion for `rust_name`.
+
+### Automatic wrapping
+
+A fairly common operation is calling a method on the inner rust type, via the `.rust()` accessor. This can be simplified
+with the `#[auto_wrap]` attribute. This will generate a wrapper for your function which accesses the rust method of that name.

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

@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
 use crate::generator::rust::{get_call_params_tokens, get_params_tokens};
+use crate::naming::TypeNames;
 use crate::{
     generator::{naming::qobject::QObjectNames, rust::fragment::GeneratedRustFragment},
     parser::method::ParsedMethod,
@@ -14,6 +15,7 @@ use syn::{parse_quote_spanned, spanned::Spanned, Result};
 pub fn generate_rust_methods(
     invokables: &[&ParsedMethod],
     qobject_names: &QObjectNames,
+    type_names: &TypeNames,
 ) -> Result<GeneratedRustFragment> {
     let cpp_class_name_rust = &qobject_names.name.rust_unqualified();
 
@@ -56,18 +58,29 @@ pub fn generate_rust_methods(
                 Some(quote! { unsafe })
             };
 
+            let method_safety = if invokable.safe {
+                None
+            } else {
+                Some(quote! { unsafe })
+            };
+
+            let qualified_impl = type_names.rust_qualified(&invokable.qobject_ident)?;
+
             let wrapper_fn = if invokable.wrap {
                 vec![parse_quote_spanned! {
                     invokable.method.span() =>
-                    #unsafe_call fn #invokable_ident_rust(#parameter_signatures) #return_type {
-                        self.rust().#invokable_ident_rust(#call_parameters)
+                    #(#cfgs)*
+                    impl #qualified_impl {
+                        #method_safety fn #invokable_ident_rust(#parameter_signatures) #return_type {
+                            self.rust().#invokable_ident_rust(#call_parameters)
+                        }
                     }
                 }]
             } else {
                 vec![]
             };
 
-            GeneratedRustFragment {
+            Ok(GeneratedRustFragment {
                 cxx_mod_contents: vec![parse_quote_spanned! {
                     invokable.method.span() =>
                     // Note: extern "Rust" block does not need to be unsafe
@@ -87,9 +100,9 @@ pub fn generate_rust_methods(
                     }
                 }],
                 cxx_qt_mod_contents: wrapper_fn,
-            }
+            })
         })
-        .collect::<Vec<_>>();
+        .collect::<Result<Vec<_>>>()?;
 
     Ok(GeneratedRustFragment::flatten(generated))
 }
@@ -130,8 +143,12 @@ mod tests {
         ];
         let qobject_names = create_qobjectname();
 
-        let generated =
-            generate_rust_methods(&invokables.iter().collect::<Vec<_>>(), &qobject_names).unwrap();
+        let generated = generate_rust_methods(
+            &invokables.iter().collect::<Vec<_>>(),
+            &qobject_names,
+            &TypeNames::mock(),
+        )
+        .unwrap();
 
         assert_eq!(generated.cxx_mod_contents.len(), 4);
         assert_eq!(generated.cxx_qt_mod_contents.len(), 2);
@@ -175,8 +192,10 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[0],
             quote! {
-                fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor> {
-                    self.rust().opaque_invokable(param)
+                impl qobject::MyObject {
+                    fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor> {
+                        self.rust().opaque_invokable(param)
+                    }
                 }
             },
         );
@@ -196,8 +215,10 @@ mod tests {
         assert_tokens_eq(
             &generated.cxx_qt_mod_contents[1],
             quote! {
-                unsafe fn unsafe_invokable(self:&MyObject, param: *mut T) -> *mut T {
-                    self.rust().unsafe_invokable(param)
+                impl qobject::MyObject {
+                    unsafe fn unsafe_invokable(self:&MyObject, param: *mut T) -> *mut T {
+                        self.rust().unsafe_invokable(param)
+                    }
                 }
             },
         );

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

@@ -35,7 +35,7 @@ impl GeneratedRustFragment {
                 type_names,
                 structured_qobject,
             )?,
-            generate_rust_methods(&structured_qobject.methods, &qobject_names)?,
+            generate_rust_methods(&structured_qobject.methods, &qobject_names, type_names)?,
             inherit::generate(&qobject_names, &structured_qobject.inherited_methods)?,
             generate_rust_signals(&structured_qobject.signals, &qobject_names, type_names)?,
         ];

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

@@ -780,8 +780,10 @@ cxx_qt::static_assertions::assert_eq_size!(
     cxx_qt::signalhandler::CxxQtSignalHandler<SecondObjectCxxQtSignalClosurepropertyNameChanged>,
     [usize; 2]
 );
-unsafe fn my_function(self: &SecondObject, param: i32) {
-    self.rust().my_function(param)
+impl ffi::SecondObject {
+    fn my_function(self: &SecondObject, param: i32) {
+        self.rust().my_function(param)
+    }
 }
 impl ffi::SecondObject {
     #[doc = "Connect the given function pointer to the signal "]