Use traits to define inheritance impls

[ahayzen-kdab]

Current

To define a different base class you need to

• Specify the class in the qobject macro (eg #[cxx_qt::qobject(base = "QAbstractListModel")])
• Specify the include for the class for C++ in the CXX bridge (eg include!(<QtCore/QAbstractListModel>);
• Use the override macro to impl any methods (eg #[qinvokable(cxx_override = "true")])
• Specify anything on the base class on the CXX bridge (eg fn beginInsertRows(self: Pin<&mut MyModel>, first: i32, last: i32);
  • Note protected methods are tricky we have to proxy those to public methods for now

This looks something like

#[cxx_qt::bridge]
mod ffi {
    unsafe extern "C++" {
        include!(<QtCore/QAbstractListModel>);
    }

    unsafe extern "C++" {
        #[cxx_name = "beginInsertRows"]
        fn begin_insert_rows(self: Pin<&mut CustomBaseQt>, first: i32, last: i32);
        #[cxx_name = "endInsertRows"]
        fn end_insert_rows(self: Pin<&mut CustomBaseQt>);
    }

     #[cxx_qt::qobject(base = "QAbstractListModel")]
    #[derive(Default)]
    pub struct CustomBase {
        ...
    }

    impl cxx_qt::QObject<MyModel> {
        #[qinvokable(cxx_override = "true")]
        fn data(&self, index: &QModelIndex, role: i32) -> QVariant {
          ...
        }
   }
}

Current Problems

• If you don't implement a pure virtual method you won't know until you compile
• It's not totally idomatic for Rust
• You can't compose multiple base classes

Possible Solution

• Use traits to define and implement any base classes

First you would need to define the trait somewhere (or from cxx-qt-lib)

trait QAbstractListModel {
   fn data(&self, index: QModelIndex, role: i32) -> QVariant;
}

This can then be implemented onto the QObject struct

impl QAbstractListModel for MyModel {
    fn data(&self, index: &QModelIndex, _role: i32) -> QVariant {
        ...
    }
}

Then when parsing the module, if we spot these traits we can

• Use the trait name as one of the base classes of the QObject (?)
• Expose any methods as normal from the trait through to C++
  • automatically add override ?

This has the advantage of rust-analyzer being able to pick up the errors before compiling and is more idomatic to Rust.

Possible Solution Problems

• Where does the include for C++ go ? does the developer still add include!(<QtCore/QAbstractListModel>); to their bridge?
• How can we define existing methods on the base class ? (does the developer still add fn beginInsertRows(self: Pin<&mut MyModel>, first: i32, last: i32); to their bridge?)
• How do we tell the difference between traits that are Rust only and ones that are base class impls? Eg impl Default for MyModel and impl QAbstractListModel for MyModel ?
  • Maybe have a macro before the impl block ? #[cxx_qt::impl] or something
• Can you specify multiple impl T for MyModel ? what does that mean in C++ ?
• Note that the trait could be defined anywhere, so we can't read the data from the trait in the macro unless we only allow it in the module - but then it can't be in cxx-qt-lib
• Does the C++ name always match the trait name? could it be specified in another way? or would a #[cxx_name = "AnotherName"] above the impl be enough?

cc @nico264