cxx-qt-gen: support base class for the qobject macro

Author: ahayzen-kdab

book/src/qobject/macro.md

@@ -31,4 +31,8 @@ Then when registering the type you use the type with your namespace as usual.
 {{#include ../../../examples/qml_with_threaded_logic/src/lib.rs:book_namespace_register}}
 ```
 
-Note: this might change in the future to allow for defining the base class or options when exporting to QML and could become namespaced to `#[cxx_qt::qobject(base = "QAbstractListModel")]` ( [https://github.com/KDAB/cxx-qt/issues/22](https://github.com/KDAB/cxx-qt/issues/22) ).
+You can also specify the base class by using `#[cxx_qt::qobject(base = "QStringListModel")]`. Note that you need to use CXX to include the header that the base class is declared in.
+
+```rust,ignore,noplayground
+{{#include ../../../examples/qml_features/src/custom_base.rs:book_macro_code}}
+```

cxx-qt-gen/src/extract.rs

@@ -191,6 +191,8 @@ pub struct QObject {
     pub(crate) original_passthrough_decls: Vec<Item>,
     /// The Rust impl that has optionally been provided to handle updates
     pub(crate) handle_updates_impl: Option<ItemImpl>,
+    /// The base class of the QObject
+    pub(crate) base_class: Option<String>,
 }
 
 /// Describe the error type from extract_qt_type and extract_type_ident
@@ -744,6 +746,7 @@ pub fn extract_qobject(module: &ItemMod) -> Result<QObject, TokenStream> {
         original_rust_struct,
         original_passthrough_decls,
         handle_updates_impl,
+        base_class: qobject.base_class,
     })
 }
 

cxx-qt-gen/src/gen_cpp.rs

@@ -856,6 +856,10 @@ pub fn generate_qobject_cpp(obj: &QObject) -> Result<CppObject, TokenStream> {
         rust_ident: rust_struct_ident,
         namespace: obj.namespace.clone(),
         namespace_internals: namespace_internals.join("::"),
+        base_class: obj
+            .base_class
+            .clone()
+            .unwrap_or_else(|| "QObject".to_owned()),
         metaobjects,
         methods,
         slots,

cxx-qt-gen/src/gen_rs.rs

@@ -369,13 +369,6 @@ pub fn generate_qobject_cxx(obj: &QObject) -> Result<ItemMod, TokenStream> {
     // Retrieve the passthrough items to CXX
     let cxx_items = &obj.cxx_items;
 
-    // For now we always include QObject, but when a base class can be specified this will
-    // become None and require the include to be in the extern "C++" block
-    //
-    // Note that quote formats this with spaces but it is valid syntax for CXX
-    // https://github.com/dtolnay/cxx/blob/1862c5dad56c3da71420c5dca6e80ab788bb193d/syntax/parse.rs#L1101
-    let qt_include = quote! { <QtCore/QObject> };
-
     // Add an include for the UpdateRequester if it is used
     let update_requester_include = if obj.handle_updates_impl.is_some() {
         quote! { include!("cxx-qt-lib/include/update_requester.h"); }
@@ -392,7 +385,6 @@ pub fn generate_qobject_cxx(obj: &QObject) -> Result<ItemMod, TokenStream> {
             unsafe extern "C++" {
                 include!(#import_path);
                 #update_requester_include
-                include!(#qt_include);
 
                 #[cxx_name = #class_name_str]
                 type #rust_class_name_cpp;

cxx-qt-gen/src/generator/cpp/mod.rs

@@ -19,6 +19,8 @@ pub struct GeneratedCppBlocks {
     pub namespace: String,
     /// Ident of the namespace for CXX-Qt internals of the QObject
     pub namespace_internals: String,
+    /// Base class of the QObject
+    pub base_class: String,
     /// List of Qt Meta Object items (eg Q_PROPERTY)
     pub metaobjects: Vec<String>,
     /// List of public methods for the QObject

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

@@ -5,12 +5,13 @@
 
 use crate::parser::{qobject::ParsedQObject, signals::ParsedSignalsEnum};
 use crate::syntax::{
-    attribute::{attribute_find_path, attribute_tokens_to_ident},
+    attribute::{attribute_find_path, attribute_tokens_to_ident, attribute_tokens_to_map},
     path::{path_angled_args_to_type_path, path_compare_str, path_to_single_ident},
 };
 use std::collections::HashMap;
 use syn::{
-    spanned::Spanned, Error, Ident, Item, ItemEnum, ItemImpl, ItemStruct, Result, Type, TypePath,
+    spanned::Spanned, Error, Ident, Item, ItemEnum, ItemImpl, ItemStruct, LitStr, Result, Type,
+    TypePath,
 };
 
 #[derive(Default)]
@@ -145,25 +146,31 @@ impl ParsedCxxQtData {
 
     /// Parse a [syn::ItemStruct] into the qobjects if it's a CXX-Qt struct
     /// otherwise return as a [syn::Item] to pass through.
-    fn parse_struct(&mut self, s: ItemStruct) -> Result<Option<Item>> {
+    fn parse_struct(&mut self, item_struct: ItemStruct) -> Result<Option<Item>> {
         // If the attribute is #[cxx_qt::qobject] then this the struct defining a qobject
-        if let Some(index) = attribute_find_path(&s.attrs, &["cxx_qt", "qobject"]) {
-            // Remove the macro from the struct
-            //
-            // TODO: we need to read the base class from the macro
-            let mut s = s.clone();
-            s.attrs.remove(index);
-
-            if let Some(qobject) = self.qobjects.get_mut(&s.ident) {
+        if let Some(index) = attribute_find_path(&item_struct.attrs, &["cxx_qt", "qobject"]) {
+            if let Some(qobject) = self.qobjects.get_mut(&item_struct.ident) {
+                // Find if there is any base class
+                if let Some(base) =
+                    attribute_tokens_to_map::<Ident, LitStr>(&item_struct.attrs[index])?
+                        .get(&quote::format_ident!("base"))
+                {
+                    qobject.base_class = Some(base.value());
+                }
+
+                // Remove the macro from the struct
+                let mut item_struct = item_struct.clone();
+                item_struct.attrs.remove(index);
+
                 // Parse any properties in the struct
                 // and remove the #[qproperty] attribute
-                qobject.parse_struct_fields(&mut s.fields)?;
+                qobject.parse_struct_fields(&mut item_struct.fields)?;
 
-                qobject.qobject_struct = Some(s);
+                qobject.qobject_struct = Some(item_struct);
                 return Ok(None);
             } else {
                 return Err(Error::new(
-                    s.span(),
+                    item_struct.span(),
                     "cxx_qt::qobject struct was not found by find_qobject_keys",
                 ));
             }
@@ -172,15 +179,15 @@ impl ParsedCxxQtData {
         // TODO: for now we assume that Data is related to the only struct in the qobjects
         //
         // Once Data and "RustObj" have been merged this can be removed
-        match s.ident.to_string().as_str() {
+        match item_struct.ident.to_string().as_str() {
             "Data" if !self.qobjects.is_empty() => {
                 let qobject_ident = self.qobjects.keys().next().unwrap().clone();
                 self.qobjects
                     .entry(qobject_ident)
-                    .and_modify(|qobject| qobject.data_struct = Some(s.clone()));
+                    .and_modify(|qobject| qobject.data_struct = Some(item_struct.clone()));
                 Ok(None)
             }
-            _others => Ok(Some(Item::Struct(s))),
+            _others => Ok(Some(Item::Struct(item_struct))),
         }
     }
 }
@@ -324,6 +331,25 @@ mod tests {
         assert!(cxx_qt_data.qobjects[&qobject_ident()].data_struct.is_some());
     }
 
+    #[test]
+    fn test_find_and_merge_cxx_qt_item_struct_valid_base_class() {
+        let mut cxx_qt_data = create_parsed_cxx_qt_data();
+
+        let item: Item = tokens_to_syn(quote! {
+            #[cxx_qt::qobject(base = "QStringListModel")]
+            struct MyObject;
+        });
+        let result = cxx_qt_data.parse_cxx_qt_item(item).unwrap();
+        assert!(result.is_none());
+        assert_eq!(
+            cxx_qt_data.qobjects[&qobject_ident()]
+                .base_class
+                .as_ref()
+                .unwrap(),
+            "QStringListModel"
+        );
+    }
+
     #[test]
     fn test_find_and_merge_cxx_qt_item_struct_valid_rustobj() {
         let mut cxx_qt_data = create_parsed_cxx_qt_data();
@@ -337,6 +363,7 @@ mod tests {
         assert!(cxx_qt_data.qobjects[&qobject_ident()]
             .qobject_struct
             .is_some());
+        assert!(cxx_qt_data.qobjects[&qobject_ident()].base_class.is_none());
     }
 
     #[test]

cxx-qt-gen/src/parser/qobject.rs

@@ -15,6 +15,8 @@ use syn::{
 /// then mutate these [syn::Item]'s for generation purposes.
 #[derive(Default)]
 pub struct ParsedQObject {
+    /// The base class of the struct
+    pub base_class: Option<String>,
     /// Data struct that currently stores the properties for the QObject
     ///
     /// In the future this will be removed

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

@@ -49,7 +49,7 @@ pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
 
         {namespace_start}
 
-        class {ident} : public QObject
+        class {ident} : public {base_class}
         {{
           Q_OBJECT
           {metaobjects}
@@ -71,6 +71,8 @@ pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
           {members}
         }};
 
+        static_assert(std::is_base_of<QObject, {ident}>::value, "{ident} must inherit from QObject");
+
         {namespace_end}
 
         namespace {namespace_internals} {{
@@ -94,6 +96,7 @@ pub fn write_cpp_header(generated: &GeneratedCppBlocks) -> String {
     },
     namespace_internals = generated.namespace_internals,
     rust_ident = generated.rust_ident,
+    base_class = generated.base_class,
     metaobjects = generated.metaobjects.join("\n  "),
     methods = create_block("public", &generated.methods.iter().map(pair_as_header).collect::<Vec<&str>>()),
     slots = create_block("public Q_SLOTS", &generated.slots.iter().map(pair_as_header).collect::<Vec<&str>>()),

cxx-qt-gen/src/writer/cpp/mod.rs

@@ -37,6 +37,7 @@ mod tests {
             rust_ident: "MyObjectRust".to_owned(),
             namespace: "cxx_qt::my_object".to_owned(),
             namespace_internals: "cxx_qt::my_object::cxx_qt_my_object".to_owned(),
+            base_class: "QStringListModel".to_owned(),
             metaobjects: vec![
                 "Q_PROPERTY(int count READ count WRITE setCount NOTIFY countChanged)".to_owned(),
                 "Q_PROPERTY(bool longPropertyNameThatWrapsInClangFormat READ getToggle WRITE setToggle NOTIFY toggleChanged)"
@@ -152,7 +153,7 @@ mod tests {
 
         namespace cxx_qt::my_object {
 
-        class MyObject : public QObject
+        class MyObject : public QStringListModel
         {
           Q_OBJECT
           Q_PROPERTY(int count READ count WRITE setCount NOTIFY countChanged)
@@ -187,6 +188,8 @@ mod tests {
           bool m_toggle;
         };
 
+        static_assert(std::is_base_of<QObject, MyObject>::value, "MyObject must inherit from QObject");
+
         } // namespace cxx_qt::my_object
 
         namespace cxx_qt::my_object::cxx_qt_my_object {
@@ -214,7 +217,7 @@ mod tests {
 
 
 
-        class MyObject : public QObject
+        class MyObject : public QStringListModel
         {
           Q_OBJECT
           Q_PROPERTY(int count READ count WRITE setCount NOTIFY countChanged)
@@ -249,6 +252,8 @@ mod tests {
           bool m_toggle;
         };
 
+        static_assert(std::is_base_of<QObject, MyObject>::value, "MyObject must inherit from QObject");
+
 
 
         namespace cxx_qt_my_object {
@@ -268,7 +273,7 @@ mod tests {
         namespace cxx_qt::my_object {
 
         MyObject::MyObject(QObject* parent)
-          : QObject(parent)
+          : QStringListModel(parent)
           , m_rustObj(cxx_qt::my_object::cxx_qt_my_object::createRs())
         {
           cxx_qt::my_object::cxx_qt_my_object::initialiseCpp(*this);
@@ -353,7 +358,7 @@ mod tests {
 
 
         MyObject::MyObject(QObject* parent)
-          : QObject(parent)
+          : QStringListModel(parent)
           , m_rustObj(cxx_qt_my_object::createRs())
         {
           cxx_qt_my_object::initialiseCpp(*this);

cxx-qt-gen/src/writer/cpp/source.rs

@@ -19,7 +19,7 @@ pub fn write_cpp_source(generated: &GeneratedCppBlocks) -> String {
         {namespace_start}
 
         {ident}::{ident}(QObject* parent)
-          : QObject(parent)
+          : {base_class}(parent)
           , m_rustObj({namespace_internals}::createRs())
         {{
           {namespace_internals}::initialiseCpp(*this);
@@ -65,6 +65,7 @@ pub fn write_cpp_source(generated: &GeneratedCppBlocks) -> String {
       format!("}} // namespace {namespace}", namespace = generated.namespace)
     },
     namespace_internals = generated.namespace_internals,
+    base_class = generated.base_class,
     rust_ident = generated.rust_ident,
     methods = generated.methods.iter().map(pair_as_source).collect::<Vec<String>>().join("\n"),
     slots = generated.slots.iter().map(pair_as_source).collect::<Vec<String>>().join("\n"),

cxx-qt-gen/src/writer/rust/mod.rs

@@ -17,6 +17,7 @@ fn cxx_common_blocks(
     vec![
         quote! {
             unsafe extern "C++" {
+                include ! (< QtCore / QObject >);
                 include!("cxx-qt-lib/include/convert.h");
 
                 #[cxx_name = "unsafeRust"]
@@ -155,6 +156,7 @@ mod tests {
                 }
 
                 unsafe extern "C++" {
+                    include ! (< QtCore / QObject >);
                     include!("cxx-qt-lib/include/convert.h");
 
                     #[cxx_name = "unsafeRust"]

cxx-qt-gen/test_inputs/naming.rs

@@ -5,7 +5,11 @@ mod ffi {
         property_name: i32,
     }
 
-    #[cxx_qt::qobject]
+    unsafe extern "C++" {
+        include!(<QtCore/QStringListModel>);
+    }
+
+    #[cxx_qt::qobject(base = "QStringListModel")]
     #[derive(Default)]
     pub struct MyObject;
 

cxx-qt-gen/test_outputs/custom_default.rs

@@ -2,7 +2,6 @@
 mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-gen/include/my_object.cxxqt.h");
-        include ! (< QtCore / QObject >);
 
         #[cxx_name = "MyObject"]
         type MyObjectQt;
@@ -19,6 +18,7 @@ mod ffi {
     }
 
     unsafe extern "C++" {
+        include ! (< QtCore / QObject >);
         include!("cxx-qt-lib/include/convert.h");
 
         #[cxx_name = "unsafeRust"]

cxx-qt-gen/test_outputs/handlers.h

@@ -46,6 +46,9 @@ public Q_SLOTS:
   QString m_string;
 };
 
+static_assert(std::is_base_of<QObject, MyObject>::value,
+              "MyObject must inherit from QObject");
+
 } // namespace cxx_qt::my_object
 
 namespace cxx_qt::my_object::cxx_qt_my_object {

cxx-qt-gen/test_outputs/handlers.rs

@@ -3,7 +3,6 @@ mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-gen/include/my_object.cxxqt.h");
         include!("cxx-qt-lib/include/update_requester.h");
-        include ! (< QtCore / QObject >);
 
         #[cxx_name = "MyObject"]
         type MyObjectQt;
@@ -40,6 +39,7 @@ mod ffi {
     }
 
     unsafe extern "C++" {
+        include ! (< QtCore / QObject >);
         include!("cxx-qt-lib/include/convert.h");
 
         #[cxx_name = "unsafeRust"]

cxx-qt-gen/test_outputs/invokables.h

@@ -40,6 +40,9 @@ class MyObject : public QObject
   bool m_initialised = false;
 };
 
+static_assert(std::is_base_of<QObject, MyObject>::value,
+              "MyObject must inherit from QObject");
+
 } // namespace cxx_qt::my_object
 
 namespace cxx_qt::my_object::cxx_qt_my_object {

cxx-qt-gen/test_outputs/invokables.rs

@@ -2,7 +2,6 @@
 mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-gen/include/my_object.cxxqt.h");
-        include ! (< QtCore / QObject >);
 
         #[cxx_name = "MyObject"]
         type MyObjectQt;
@@ -45,6 +44,7 @@ mod ffi {
     }
 
     unsafe extern "C++" {
+        include ! (< QtCore / QObject >);
         include!("cxx-qt-lib/include/convert.h");
 
         #[cxx_name = "unsafeRust"]