Skip to main content

qtbridge_gen/qt_gen_impl/qt_meta_gen/
qsignal_info.rs

1// Copyright (C) 2025 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only
3
4use 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>,     // Attributes other than qsignal
27    meta_params: QSignalMetaParams, // Params extracted from qsignal attribute
28    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    /// Get count of arguments after &self
70    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                // TODO: check charset of name?
124            }
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                // Never exposed to QML: no QObject, hence no connections
170                // and no receivers - emitting is a no-op.
171                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}