Skip to content

Commit

Permalink
cxx-qt-gen: remove wrapper method for C++ -> Rust invokables
Browse files Browse the repository at this point in the history 
This then avoids us needing to generate Rust methods with
fully qualified types on the Rust side and removes a load of
generation.

Related to KDAB#404
  • Loading branch information
@ahayzen-kdab
ahayzen-kdab committed Jul 18, 2023
1 parent 11d6dcf commit 53294aa
Show file tree
Hide file tree
Showing 14 changed files with 157 additions and 241 deletions.
94 changes: 80 additions & 14 deletions crates/cxx-qt-gen/src/generator/cpp/invokable.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -67,11 +67,11 @@ pub fn generate_cpp_invokables(
.collect::<Result<Vec<CppNamedType>>>()?;

let body = format!(
"m_rustObj->{ident}({parameter_names})",
"{ident}({parameter_names})",
ident = idents.wrapper.cpp,
parameter_names = vec!["*this"]
.into_iter()
.chain(parameters.iter().map(|parameter| parameter.ident.as_str()))
parameter_names = parameters
.iter()
.map(|parameter| parameter.ident.as_str())
.collect::<Vec<&str>>()
.join(", "),
);
Expand Down Expand Up @@ -140,6 +140,25 @@ pub fn generate_cpp_invokables(
},
},
});

// Note that we are generating a header to match the extern "Rust" method
// in Rust for our invokable.
//
// CXX generates the source and we just need the matching header.
//
// TODO: this could be private ?
//
// TODO: will this always be noexcept ? If the return type is Result is this then removed?
generated.methods.push(CppFragment::Header(format!(
"{return_cxx_ty} {ident}({parameter_types}){is_const} noexcept;",
return_cxx_ty = if let Some(return_cxx_ty) = &return_cxx_ty {
return_cxx_ty.as_cxx_ty()
} else {
"void"
},
ident = idents.wrapper.cpp,
parameter_types = parameter_types,
)));
}

Ok(generated)
Expand Down Expand Up @@ -219,7 +238,7 @@ mod tests {
.unwrap();

// methods
assert_eq!(generated.methods.len(), 4);
assert_eq!(generated.methods.len(), 8);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[0] {
(header, source)
Expand All @@ -234,12 +253,19 @@ mod tests {
MyObject::voidInvokable() const
{
// ::std::lock_guard
m_rustObj->voidInvokableWrapper(*this);
voidInvokableWrapper();
}
"#}
);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[1] {
let header = if let CppFragment::Header(header) = &generated.methods[1] {
header
} else {
panic!("Expected header")
};
assert_str_eq!(header, "void voidInvokableWrapper() const noexcept;");

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[2] {
(header, source)
} else {
panic!("Expected pair")
Expand All @@ -255,12 +281,22 @@ mod tests {
MyObject::trivialInvokable(::std::int32_t param) const
{
// ::std::lock_guard
return m_rustObj->trivialInvokableWrapper(*this, param);
return trivialInvokableWrapper(param);
}
"#}
);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[2] {
let header = if let CppFragment::Header(header) = &generated.methods[3] {
header
} else {
panic!("Expected header")
};
assert_str_eq!(
header,
"::std::int32_t trivialInvokableWrapper(::std::int32_t param) const noexcept;"
);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[4] {
(header, source)
} else {
panic!("Expected pair")
Expand All @@ -276,12 +312,22 @@ mod tests {
MyObject::opaqueInvokable(QColor const& param)
{
// ::std::lock_guard
return m_rustObj->opaqueInvokableWrapper(*this, param);
return opaqueInvokableWrapper(param);
}
"#}
);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[3] {
let header = if let CppFragment::Header(header) = &generated.methods[5] {
header
} else {
panic!("Expected header")
};
assert_str_eq!(
header,
"::std::unique_ptr<QColor> opaqueInvokableWrapper(QColor const& param) noexcept;"
);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[6] {
(header, source)
} else {
panic!("Expected pair")
Expand All @@ -297,10 +343,20 @@ mod tests {
MyObject::specifiersInvokable(::std::int32_t param) const
{
// ::std::lock_guard
return m_rustObj->specifiersInvokableWrapper(*this, param);
return specifiersInvokableWrapper(param);
}
"#}
);

let header = if let CppFragment::Header(header) = &generated.methods[7] {
header
} else {
panic!("Expected header")
};
assert_str_eq!(
header,
"::std::int32_t specifiersInvokableWrapper(::std::int32_t param) const noexcept;"
);
}

#[test]
Expand Down Expand Up @@ -335,7 +391,7 @@ mod tests {
.unwrap();

// methods
assert_eq!(generated.methods.len(), 1);
assert_eq!(generated.methods.len(), 2);

let (header, source) = if let CppFragment::Pair { header, source } = &generated.methods[0] {
(header, source)
Expand All @@ -350,9 +406,19 @@ mod tests {
MyObject::trivialInvokable(A1 param) const
{
// ::std::lock_guard
return m_rustObj->trivialInvokableWrapper(*this, param);
return trivialInvokableWrapper(param);
}
"#}
);

let header = if let CppFragment::Header(header) = &generated.methods[1] {
header
} else {
panic!("Expected header")
};
assert_str_eq!(
header,
"B2 trivialInvokableWrapper(A1 param) const noexcept;"
);
}
}
106 changes: 22 additions & 84 deletions crates/cxx-qt-gen/src/generator/rust/invokable.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,34 +12,29 @@ use crate::{
};
use proc_macro2::TokenStream;
use quote::quote;
use syn::{Ident, Result, ReturnType};
use syn::Result;

pub fn generate_rust_invokables(
invokables: &Vec<ParsedQInvokable>,
qobject_idents: &QObjectName,
) -> Result<GeneratedRustQObjectBlocks> {
let mut generated = GeneratedRustQObjectBlocks::default();
let cpp_class_name_rust = &qobject_idents.cpp_class.rust;
let rust_struct_name_rust = &qobject_idents.rust_struct.rust;

for invokable in invokables {
let idents = QInvokableName::from(invokable);
let wrapper_ident_cpp = idents.wrapper.cpp.to_string();
let wrapper_ident_rust = &idents.wrapper.rust;
let invokable_ident_rust = &idents.name.rust;

// TODO: once we aren't using qobject::T in the extern "RustQt"
// we can just pass through the original ExternFn block and add the attribute?
let cpp_struct = if invokable.mutable {
quote! { Pin<&mut #cpp_class_name_rust> }
quote! { Pin<&mut #cpp_class_name_rust> }
} else {
quote! { &#cpp_class_name_rust }
};
let rust_struct = if invokable.mutable {
quote! { &mut #rust_struct_name_rust }
} else {
quote! { &#rust_struct_name_rust }
};
let parameter_signatures = if invokable.parameters.is_empty() {
quote! { self: #rust_struct, cpp: #cpp_struct }
quote! { self: #cpp_struct }
} else {
let parameters = invokable
.parameters
Expand All @@ -50,46 +45,29 @@ pub fn generate_rust_invokables(
quote! { #ident: #ty }
})
.collect::<Vec<TokenStream>>();
quote! { self: #rust_struct, cpp: #cpp_struct, #(#parameters),* }
quote! { self: #cpp_struct, #(#parameters),* }
};
let return_type = &invokable.method.sig.output;
let has_return = if matches!(invokable.method.sig.output, ReturnType::Default) {
quote! {}
} else {
quote! { return }
};

let mut unsafe_block = None;
let mut unsafe_call = Some(quote! { unsafe });
if invokable.safe {
std::mem::swap(&mut unsafe_call, &mut unsafe_block);
}

let parameter_names = invokable
.parameters
.iter()
.map(|parameter| parameter.ident.clone())
.collect::<Vec<Ident>>();

let fragment = RustFragmentPair {
cxx_bridge: vec![quote! {
// TODO: is an unsafe block valid?
// Note: extern "Rust" block does not need to be unsafe
extern "Rust" {
// Note that we are exposing a Rust method on the C++ type to C++
//
// CXX ends up generating the source, then we generate the matching header.
#[doc(hidden)]
#[cxx_name = #wrapper_ident_cpp]
#unsafe_call fn #wrapper_ident_rust(#parameter_signatures) #return_type;
#unsafe_call fn #invokable_ident_rust(#parameter_signatures) #return_type;
}
}],
implementation: vec![
// TODO: not all methods have a wrapper
quote! {
impl #rust_struct_name_rust {
#[doc(hidden)]
pub #unsafe_call fn #wrapper_ident_rust(#parameter_signatures) #return_type {
#has_return cpp.#invokable_ident_rust(#(#parameter_names),*);
}
}
},
],
implementation: vec![],
};

generated
Expand Down Expand Up @@ -164,26 +142,16 @@ mod tests {
let generated = generate_rust_invokables(&invokables, &qobject_idents).unwrap();

assert_eq!(generated.cxx_mod_contents.len(), 4);
assert_eq!(generated.cxx_qt_mod_contents.len(), 4);
assert_eq!(generated.cxx_qt_mod_contents.len(), 0);

// void_invokable
assert_tokens_eq(
&generated.cxx_mod_contents[0],
quote! {
extern "Rust" {
#[cxx_name = "voidInvokableWrapper"]
fn void_invokable_wrapper(self: &MyObjectRust, cpp: &MyObject);
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[0],
quote! {
impl MyObjectRust {
#[doc(hidden)]
pub fn void_invokable_wrapper(self: &MyObjectRust, cpp: &MyObject) {
cpp.void_invokable();
}
#[cxx_name = "voidInvokableWrapper"]
fn void_invokable(self: &MyObject);
}
},
);
Expand All @@ -193,19 +161,9 @@ mod tests {
&generated.cxx_mod_contents[1],
quote! {
extern "Rust" {
#[cxx_name = "trivialInvokableWrapper"]
fn trivial_invokable_wrapper(self: &MyObjectRust, cpp: &MyObject, param: i32) -> i32;
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[1],
quote! {
impl MyObjectRust {
#[doc(hidden)]
pub fn trivial_invokable_wrapper(self: &MyObjectRust, cpp: &MyObject, param: i32) -> i32 {
return cpp.trivial_invokable(param);
}
#[cxx_name = "trivialInvokableWrapper"]
fn trivial_invokable(self: &MyObject, param: i32) -> i32;
}
},
);
Expand All @@ -215,19 +173,9 @@ mod tests {
&generated.cxx_mod_contents[2],
quote! {
extern "Rust" {
#[cxx_name = "opaqueInvokableWrapper"]
fn opaque_invokable_wrapper(self: &mut MyObjectRust, cpp: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor>;
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[2],
quote! {
impl MyObjectRust {
#[doc(hidden)]
pub fn opaque_invokable_wrapper(self: &mut MyObjectRust, cpp: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor> {
return cpp.opaque_invokable(param);
}
#[cxx_name = "opaqueInvokableWrapper"]
fn opaque_invokable(self: Pin<&mut MyObject>, param: &QColor) -> UniquePtr<QColor>;
}
},
);
Expand All @@ -237,19 +185,9 @@ mod tests {
&generated.cxx_mod_contents[3],
quote! {
extern "Rust" {
#[cxx_name = "unsafeInvokableWrapper"]
unsafe fn unsafe_invokable_wrapper(self: &MyObjectRust, cpp: &MyObject, param: *mut T) -> *mut T;
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[3],
quote! {
impl MyObjectRust {
#[doc(hidden)]
pub unsafe fn unsafe_invokable_wrapper(self: &MyObjectRust, cpp: &MyObject, param: *mut T) -> *mut T {
return cpp.unsafe_invokable(param);
}
#[cxx_name = "unsafeInvokableWrapper"]
unsafe fn unsafe_invokable(self:&MyObject, param: *mut T) -> *mut T;
}
},
);
Expand Down
4 changes: 2 additions & 2 deletions crates/cxx-qt-gen/test_outputs/inheritance.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,14 +18,14 @@ QVariant
MyObject::data(QModelIndex const& _index, ::std::int32_t _role) const
{
const ::std::lock_guard<::std::recursive_mutex> guard(*m_rustObjMutex);
return m_rustObj->dataWrapper(*this, _index, _role);
return dataWrapper(_index, _role);
}

bool
MyObject::hasChildren(QModelIndex const& _parent) const
{
const ::std::lock_guard<::std::recursive_mutex> guard(*m_rustObjMutex);
return m_rustObj->hasChildrenWrapper(*this, _parent);
return hasChildrenWrapper(_parent);
}

MyObject::MyObject(QObject* parent)
Expand Down
3 changes: 3 additions & 0 deletions crates/cxx-qt-gen/test_outputs/inheritance.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,7 +24,10 @@ class MyObject : public QAbstractItemModel
public:
Q_INVOKABLE QVariant data(QModelIndex const& _index,
::std::int32_t _role) const override;
QVariant dataWrapper(QModelIndex const& _index,
::std::int32_t _role) const noexcept;
Q_INVOKABLE bool hasChildren(QModelIndex const& _parent) const override;
bool hasChildrenWrapper(QModelIndex const& _parent) const noexcept;
template<class... Args>
bool hasChildrenCxxQtInherit(Args... args) const
{
Expand Down
Loading

0 comments on commit 53294aa

Please sign in to comment.