Automatically generate upcasting implementations

- Any bridges with qobjects that have no custom base class will get an upcasting implemention
- Adds a new include with the necessary template function for calling static_cast

Author: BenFordTytherington

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

@@ -174,6 +174,12 @@ impl GeneratedCppQObject {
             class_initializers.push(initializer);
         }
 
+        // Include casting header
+        let mut result = GeneratedCppQObjectBlocks::default();
+        result.includes.insert("#include <cxx-qt/casting.h>".into());
+
+        generated.blocks.append(&mut result);
+
         generated.blocks.append(&mut constructor::generate(
             &generated,
             &structured_qobject.constructors,

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

@@ -16,7 +16,7 @@ pub mod signals;
 pub mod threading;
 
 use crate::generator::{rust::fragment::GeneratedRustFragment, structuring};
-use crate::parser::{parameter::ParsedFunctionParameter, Parser};
+use crate::parser::{parameter::ParsedFunctionParameter, qobject::ParsedQObject, Parser};
 use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 use syn::{parse_quote, Item, ItemMod, Result};
@@ -60,6 +60,8 @@ impl GeneratedRustBlocks {
         let namespace = parser.cxx_qt_data.namespace.clone().unwrap_or_default();
         let passthrough_mod = &parser.passthrough_module;
 
+        fragments.extend(vec![add_qobject_import(&parser.cxx_qt_data.qobjects)]);
+
         let vis = &passthrough_mod.vis;
         let ident = &passthrough_mod.module_ident;
         let docs = &passthrough_mod.docs;
@@ -95,6 +97,29 @@ impl GeneratedRustBlocks {
     }
 }
 
+fn add_qobject_import(qobjects: &[ParsedQObject]) -> GeneratedRustFragment {
+    let includes = qobjects
+        .iter()
+        .any(|obj| obj.has_qobject_macro && obj.base_class.is_none());
+    if includes {
+        GeneratedRustFragment {
+            cxx_mod_contents: vec![parse_quote! {
+                extern "C++" {
+                    #[doc(hidden)]
+                    #[namespace=""]
+                    type QObject = cxx_qt::qobject::QObject;
+                }
+            }],
+            cxx_qt_mod_contents: vec![],
+        }
+    } else {
+        GeneratedRustFragment {
+            cxx_mod_contents: vec![],
+            cxx_qt_mod_contents: vec![],
+        }
+    }
+}
+
 /// Return the [TokenStream] of the parsed parameters for use in generation
 pub fn get_params_tokens(
     mutable: bool,
@@ -143,7 +168,7 @@ mod tests {
         assert!(rust.cxx_mod.content.is_none());
         assert_eq!(rust.cxx_mod_contents.len(), 0);
         assert_eq!(rust.namespace, "");
-        assert_eq!(rust.fragments.len(), 1);
+        assert_eq!(rust.fragments.len(), 2);
     }
 
     #[test]
@@ -163,7 +188,7 @@ mod tests {
         assert!(rust.cxx_mod.content.is_none());
         assert_eq!(rust.cxx_mod_contents.len(), 0);
         assert_eq!(rust.namespace, "cxx_qt");
-        assert_eq!(rust.fragments.len(), 1);
+        assert_eq!(rust.fragments.len(), 2);
     }
 
     #[test]
@@ -183,6 +208,6 @@ mod tests {
         assert!(rust.cxx_mod.content.is_none());
         assert_eq!(rust.cxx_mod_contents.len(), 0);
         assert_eq!(rust.namespace, "");
-        assert_eq!(rust.fragments.len(), 1);
+        assert_eq!(rust.fragments.len(), 2);
     }
 }

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

@@ -3,6 +3,7 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 use crate::generator::structuring::StructuredQObject;
+use crate::naming::Name;
 use crate::{
     generator::{
         naming::{namespace::NamespaceName, qobject::QObjectNames},
@@ -14,7 +15,7 @@ use crate::{
     },
     naming::TypeNames,
 };
-use quote::quote;
+use quote::{format_ident, quote};
 use syn::{parse_quote, Attribute, Ident, Result};
 
 impl GeneratedRustFragment {
@@ -33,7 +34,6 @@ impl GeneratedRustFragment {
                 &qobject_names,
                 qobject.base_class.clone(),
                 type_names,
-                &qobject.cfgs,
             )?,
             generate_rust_properties(
                 &qobject.properties,
@@ -77,18 +77,60 @@ impl GeneratedRustFragment {
             )?,
             cxxqttype::generate(&qobject_names, type_names, &qobject.cfgs)?,
         ]);
+        // Generate casting impl
+        let mut blocks = GeneratedRustFragment::default();
+        let base = structured_qobject
+            .declaration
+            .base_class
+            .as_ref()
+            .map(|name| type_names.lookup(name))
+            .transpose()?
+            .cloned()
+            .unwrap_or(
+                Name::new(format_ident!("QObject")).with_module(parse_quote! {::cxx_qt::qobject}),
+            ); // TODO! is this default module here causing the issues in the threading examples
+
+        let base_unqualified = base.rust_unqualified();
+        let base_qualified = base.rust_qualified();
+
+        let struct_name = structured_qobject.declaration.name.rust_qualified();
+        let struct_name_unqualified = structured_qobject.declaration.name.rust_unqualified();
+        let (upcast_fn, upcast_fn_attrs, upcast_fn_qualified) = qobject_names
+            .cxx_qt_ffi_method("upcastPtr")
+            .into_cxx_parts();
+        let fragment = GeneratedRustFragment {
+            cxx_mod_contents: vec![parse_quote! {
+                extern "C++" {
+                    #[doc(hidden)]
+                    #(#upcast_fn_attrs)*
+                    unsafe fn #upcast_fn(thiz: *const #struct_name_unqualified) -> *const #base_unqualified;
+                }
+            }],
+            cxx_qt_mod_contents: vec![parse_quote! {
+                impl ::cxx_qt::Upcast<#base_qualified> for #struct_name{
+                    unsafe fn upcast_ptr(this: *const Self) -> *const #base_qualified {
+                        #upcast_fn_qualified(this)
+                    }
+                }
+            }],
+        };
+
+        generated.push(fragment);
+        generated.push(blocks);
+
+        generated.push(constructor::generate(
+            &structured_qobject.constructors,
+            &qobject_names,
+            &namespace_idents,
+            type_names,
+        )?);
 
         Ok(GeneratedRustFragment::flatten(generated))
     }
 }
 
 /// Generate the C++ and Rust CXX definitions for the QObject
-fn generate_qobject_definitions(
-    qobject_idents: &QObjectNames,
-    base: Option<Ident>,
-    type_names: &TypeNames,
-    cfgs: &[Attribute],
-) -> Result<GeneratedRustFragment> {
+fn generate_qobject_definitions(qobject_idents: &QObjectNames) -> Result<GeneratedRustFragment> {
     let cpp_class_name_rust = &qobject_idents.name.rust_unqualified();
     let cpp_class_name_cpp = &qobject_idents.name.cxx_unqualified();
 
@@ -106,29 +148,6 @@ fn generate_qobject_definitions(
         }
     };
 
-    let cpp_struct_qualified = &qobject_idents.name.rust_qualified();
-
-    let base_upcast = if let Some(base) = base {
-        let base_name = type_names.lookup(&base)?.rust_qualified();
-        vec![
-            parse_quote! {
-                #(#cfgs)*
-                impl cxx_qt::Upcast<#base_name> for #cpp_struct_qualified {}
-            },
-            // Until we can actually implement the Upcast trait properly, we just need to silence
-            // the warning that the base class is otherwise unused.
-            // This can be done with an unnamed import and the right attributes
-            parse_quote! {
-                #[allow(unused_imports)]
-                #[allow(dead_code)]
-                #(#cfgs)*
-                use #base_name as _;
-            },
-        ]
-    } else {
-        vec![]
-    };
-
     Ok(GeneratedRustFragment {
         cxx_mod_contents: vec![
             parse_quote! {
@@ -157,7 +176,7 @@ fn generate_qobject_definitions(
                 }
             },
         ],
-        cxx_qt_mod_contents: base_upcast,
+        cxx_qt_mod_contents: vec![],
     })
 }
 
@@ -204,7 +223,7 @@ mod tests {
             &parser.type_names,
         )
         .unwrap();
-        assert_eq!(rust.cxx_mod_contents.len(), 6);
+        assert_eq!(rust.cxx_mod_contents.len(), 7);
         assert_tokens_eq(
             &rust.cxx_mod_contents[0],
             quote! {
@@ -239,6 +258,17 @@ mod tests {
         );
         assert_tokens_eq(
             &rust.cxx_mod_contents[3],
+            quote! {
+                extern "C++" {
+                    #[doc(hidden)]
+                    #[cxx_name = "upcastPtr"]
+                    #[namespace = "rust::cxxqt1"]
+                    unsafe fn cxx_qt_ffi_MyObject_upcastPtr(thiz: *const MyObject) -> *const QObject;
+                }
+            },
+        );
+        assert_tokens_eq(
+            &rust.cxx_mod_contents[4],
             quote! {
                 extern "Rust" {
                     #[cxx_name = "createRs"]
@@ -248,7 +278,7 @@ mod tests {
             },
         );
         assert_tokens_eq(
-            &rust.cxx_mod_contents[4],
+            &rust.cxx_mod_contents[5],
             quote! {
                 unsafe extern "C++" {
                     #[doc(hidden)]
@@ -259,7 +289,7 @@ mod tests {
             },
         );
         assert_tokens_eq(
-            &rust.cxx_mod_contents[5],
+            &rust.cxx_mod_contents[6],
             quote! {
                 unsafe extern "C++" {
                     #[doc(hidden)]

crates/cxx-qt-gen/src/writer/cpp/header.rs

@@ -256,6 +256,7 @@ mod tests {
         let expected = indoc! {r#"
 #pragma once
 
+#include <cxx-qt/casting.h>
 #include <cxx-qt/type.h>
 
 class MyObject;

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cxx-qt/casting.h>
 #include <cxx-qt/type.h>
 
 class MyObject;

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

@@ -61,6 +61,13 @@ mod inheritance {
         #[doc = " Inherited fetchMore from the base class"]
         unsafe fn fetch_more(self: Pin<&mut MyObject>, index: &QModelIndex);
     }
+    extern "C++" {
+        #[doc(hidden)]
+        #[cxx_name = "upcastPtr"]
+        #[namespace = "rust::cxxqt1"]
+        unsafe fn cxx_qt_ffi_MyObject_upcastPtr(thiz: *const MyObject)
+            -> *const QAbstractItemModel;
+    }
     extern "Rust" {
         #[cxx_name = "createRs"]
         #[namespace = "cxx_qt_MyObject"]
@@ -79,10 +86,11 @@ mod inheritance {
         fn cxx_qt_ffi_MyObject_unsafeRustMut(outer: Pin<&mut MyObject>) -> Pin<&mut MyObjectRust>;
     }
 }
-impl cxx_qt::Upcast<inheritance::QAbstractItemModel> for inheritance::MyObject {}
-#[allow(unused_imports)]
-#[allow(dead_code)]
-use inheritance::QAbstractItemModel as _;
+impl ::cxx_qt::Upcast<inheritance::QAbstractItemModel> for inheritance::MyObject {
+    unsafe fn upcast_ptr(this: *const Self) -> *const inheritance::QAbstractItemModel {
+        inheritance::cxx_qt_ffi_MyObject_upcastPtr(this)
+    }
+}
 #[doc(hidden)]
 #[allow(clippy::unnecessary_box_returns)]
 pub fn create_rs_MyObjectRust() -> std::boxed::Box<MyObjectRust> {

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cxx-qt/casting.h>
 #include <cxx-qt/threading.h>
 #include <cxx-qt/type.h>
 

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

@@ -146,6 +146,12 @@ mod ffi {
         #[namespace = "cxx_qt::my_object::cxx_qt_MyObject"]
         type MyObjectCxxQtThreadQueuedFn;
     }
+    extern "C++" {
+        #[doc(hidden)]
+        #[cxx_name = "upcastPtr"]
+        #[namespace = "rust::cxxqt1"]
+        unsafe fn cxx_qt_ffi_MyObject_upcastPtr(thiz: *const MyObject) -> *const QObject;
+    }
     #[namespace = "cxx_qt::my_object::cxx_qt_MyObject"]
     #[cxx_name = "CxxQtConstructorArguments0"]
     #[doc(hidden)]
@@ -247,6 +253,11 @@ mod ffi {
         #[namespace = "rust::cxxqt1"]
         fn cxx_qt_ffi_MyObject_unsafeRustMut(outer: Pin<&mut MyObject>) -> Pin<&mut MyObjectRust>;
     }
+    extern "C++" {
+        #[doc(hidden)]
+        #[namespace = ""]
+        type QObject = cxx_qt::qobject::QObject;
+    }
 }
 impl cxx_qt::Threading for ffi::MyObject {
     type BoxedQueuedFn = MyObjectCxxQtThreadQueuedFn;
@@ -300,6 +311,11 @@ impl cxx_qt::Threading for ffi::MyObject {
 pub struct MyObjectCxxQtThreadQueuedFn {
     inner: std::boxed::Box<dyn FnOnce(core::pin::Pin<&mut ffi::MyObject>) + Send>,
 }
+impl ::cxx_qt::Upcast<::cxx_qt::qobject::QObject> for ffi::MyObject {
+    unsafe fn upcast_ptr(this: *const Self) -> *const ::cxx_qt::qobject::QObject {
+        ffi::cxx_qt_ffi_MyObject_upcastPtr(this)
+    }
+}
 #[doc(hidden)]
 pub fn route_arguments_MyObject_0<'a>(
     arg0: i32,

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

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cxx-qt/casting.h>
 #include <cxx-qt/signalhandler.h>
 #include <cxx-qt/type.h>