qtbridge_gen/qt_gen_impl/qt_meta_gen/
qsignal_info.rs1use proc_macro2::TokenStream;
5use quote::quote;
6use syn::{Ident, LitStr};
7use syn::spanned::Spanned;
8
9use crate::utils::case_conv;
10use crate::function_with_attributes::{FunctionWithAttributes, BlockOrSemi};
11use crate::utils::parse_utils::{parse_name_value, partition_attr_by};
12use crate::utils::signature_utils::{get_typed_args, get_typed_args_types, is_self_mut};
13use crate::utils::type_utils::remove_refs;
14use crate::meta_call_check::check_meta_call_signature;
15use crate::qt_gen_impl::qt_meta_gen;
16use crate::qt_gen_impl::qobject_macro_params::QObjectMacroParams;
17use qt_meta_gen::meta_call_bridge_generator::MetaCallBridgeGenerator;
18use qt_meta_gen::traits::{ExpandTokens, QmlName};
19
20#[derive(Default)]
21struct QSignalMetaParams {
22 name: Option<syn::LitStr>,
23}
24
25pub struct QSignalInfo {
26 attrs: Vec<syn::Attribute>, meta_params: QSignalMetaParams, vis: syn::Visibility,
29 sig: syn::Signature,
30 global_options: QObjectMacroParams,
31}
32
33impl QSignalInfo {
34 pub fn new(input: FunctionWithAttributes, global_options: QObjectMacroParams) -> syn::Result<Self> {
35 Self::check_signature(&input.sig)?;
36
37 let (attrs, signal_attr) = partition_attr_by(input.attrs.clone(), Self::is_for_me);
38 let signal = signal_attr
39 .ok_or_else(|| syn::Error::new(input.sig.span(), "qsignal attribute was not found for the function"))?;
40
41 if let BlockOrSemi::Block(block) = input.block
42 && !block.stmts.is_empty() {
43 return Err(syn::Error::new(block.span(), "qsignal must not contain any code in brackets"));
44 }
45
46 let meta_params = get_qsignal_meta_params(&signal)?;
47
48 Ok(QSignalInfo{
49 attrs,
50 meta_params,
51 vis: input.vis,
52 sig: input.sig,
53 global_options,
54 })
55 }
56
57 pub fn is_mut(&self) -> bool {
58 is_self_mut(&self.sig)
59 }
60
61 pub fn is_for_me(attr: &syn::Attribute) -> bool {
62 attr.style == syn::AttrStyle::Outer && attr.path().is_ident("qsignal")
63 }
64
65 pub fn get_rust_name(&self) -> syn::Ident {
66 self.sig.ident.clone()
67 }
68
69 pub fn get_typed_arg_count(&self) -> usize {
71 get_typed_args(&self.sig).count()
72 }
73
74 pub fn get_arg_type(&self, num: usize) -> syn::Result<&syn::Type> {
75 get_typed_args_types(&self.sig)
76 .nth(num)
77 .ok_or_else(|| syn::Error::new(self.sig.span(), format!("Failed to get typed argument #{num}")))
78 }
79
80 pub fn get_meta_registration_code(&self) -> syn::Result<TokenStream> {
81 let sig = &self.sig;
82
83 let name = self.get_qml_name_span().0;
84 let arg_types_no_ref: Vec<syn::Type> = get_typed_args_types(sig)
85 .map(|ty| remove_refs(ty).clone())
86 .collect();
87
88 let register_signal = quote!{
89 meta_obj.as_mut().register_signal(
90 #name,
91 &[#(<#arg_types_no_ref as QMetaTypeCompatible>::compatible_qmetatype()),*]);
92 };
93 Ok(register_signal)
94 }
95
96 fn check_signature(sign: &syn::Signature) -> syn::Result<()> {
97 check_meta_call_signature(sign)
98 }
99}
100
101mod qsignal_keywords {
102 syn::custom_keyword!(qml_name);
103}
104
105fn get_qsignal_meta_params(attr: &syn::Attribute) -> syn::Result<QSignalMetaParams> {
106 match &attr.meta {
107 syn::Meta::Path(_) => Ok(QSignalMetaParams::default()),
108 syn::Meta::List(meta_list) => match syn::parse2::<QSignalMetaParams>(meta_list.tokens.clone()) {
109 Ok(params) => Ok(params),
110 Err(err) => Err(syn::Error::new(err.span(), format!("Failed to parse qsignal attributes: {}", err))),
111 },
112 _ => Err(syn::Error::new(attr.span(), "Unexpected format of qsignal attributes"))
113 }
114}
115
116impl syn::parse::Parse for QSignalMetaParams {
117 fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
118 let mut name = None;
119
120 while !input.is_empty() {
121 if input.peek(qsignal_keywords::qml_name) {
122 name = Some(parse_name_value::<Ident, LitStr>(input)?.1);
123 }
125 else {
126 return Err(input.error("Unsupported qsignal parameter attribute"));
127 }
128 }
129
130 Ok(Self{
131 name,
132 })
133 }
134}
135
136impl QmlName for QSignalInfo {
137 fn get_qml_name_span(&self) -> (String, proc_macro2::Span) {
138 if let Some(name) = self.meta_params.name.as_ref() {
139 (name.value(), name.span())
140 }
141 else if self.global_options.convert_to_camel_case {
142 let ident = &self.sig.ident;
143 (case_conv::snake_to_camel(&ident.to_string()), ident.span())
144 }
145 else {
146 (self.sig.ident.to_string(), self.sig.ident.span())
147 }
148 }
149}
150
151impl ExpandTokens for QSignalInfo {
152 fn expand_tokens(&self) -> syn::Result<TokenStream> {
153 let Self { attrs, vis, sig, .. } = self;
154 let bridge_generator = MetaCallBridgeGenerator::new(sig);
155 let qml_name = self.get_qml_name_span().0;
156 let argv_setup = bridge_generator.generate_argv_setup_for_signals()?;
157 if !self.is_mut() {
158 let err_span = sig.receiver()
159 .map_or_else(|| sig.ident.span(), |r| r.self_token.span());
160 return Err(syn::Error::new(err_span,
161 "The function signature of a signal has to be mutable."))
162 }
163 let code = quote! {
164 #(#attrs)*
165 #vis
166 #sig
167 {
168 use qtbridge::qtbridge_runtime::QMetaTypeCompatible;
169 let Some(proxy) = <Self as qtbridge::QObjectHolder>::try_get_rust_proxy_ptr(self) else {
172 return;
173 };
174 #argv_setup
175 qtbridge::qtbridge_runtime::qproxies::QRustProxy::emit_signal(unsafe { &*proxy }, self, #qml_name, argv.as_slice())
176 }
177 };
178 Ok(code)
179 }
180}