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 #404
  • Loading branch information
@ahayzen-kdab
ahayzen-kdab committed Jul 4, 2023
1 parent b1f7da5 commit b391c01
Show file tree
Hide file tree
Showing 5 changed files with 137 additions and 182 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: &MyObject, cpp: &MyObjectQt);
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[0],
quote! {
impl MyObject {
#[doc(hidden)]
pub fn void_invokable_wrapper(self: &MyObject, cpp: &MyObjectQt) {
cpp.void_invokable();
}
#[cxx_name = "voidInvokableWrapper"]
fn void_invokable(self: &MyObjectQt);
}
},
);
Expand All @@ -193,19 +161,9 @@ mod tests {
&generated.cxx_mod_contents[1],
quote! {
extern "Rust" {
#[cxx_name = "trivialInvokableWrapper"]
fn trivial_invokable_wrapper(self: &MyObject, cpp: &MyObjectQt, param: i32) -> i32;
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[1],
quote! {
impl MyObject {
#[doc(hidden)]
pub fn trivial_invokable_wrapper(self: &MyObject, cpp: &MyObjectQt, param: i32) -> i32 {
return cpp.trivial_invokable(param);
}
#[cxx_name = "trivialInvokableWrapper"]
fn trivial_invokable(self: &MyObjectQt, 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 MyObject, cpp: Pin<&mut MyObjectQt>, param: &QColor) -> UniquePtr<QColor>;
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[2],
quote! {
impl MyObject {
#[doc(hidden)]
pub fn opaque_invokable_wrapper(self: &mut MyObject, cpp: Pin<&mut MyObjectQt>, param: &QColor) -> UniquePtr<QColor> {
return cpp.opaque_invokable(param);
}
#[cxx_name = "opaqueInvokableWrapper"]
fn opaque_invokable(self: Pin<&mut MyObjectQt>, 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: &MyObject, cpp: &MyObjectQt, param: *mut T) -> *mut T;
}
},
);
assert_tokens_eq(
&generated.cxx_qt_mod_contents[3],
quote! {
impl MyObject {
#[doc(hidden)]
pub unsafe fn unsafe_invokable_wrapper(self: &MyObject, cpp: &MyObjectQt, param: *mut T) -> *mut T {
return cpp.unsafe_invokable(param);
}
#[cxx_name = "unsafeInvokableWrapper"]
unsafe fn unsafe_invokable(self:&MyObjectQt, param: *mut T) -> *mut T;
}
},
);
Expand Down
Loading

0 comments on commit b391c01

Please sign in to comment.