gio-macros: Add signal support to DBusInterfaceSkeleton derive

tautropfli · tautropfli · commit d2013b8f198b · 2026-03-29T21:30:55.000+02:00
diff --git a/examples/gio_dbus_register_object/hello_world.rs b/examples/gio_dbus_register_object/hello_world.rs
@@ -53,6 +53,7 @@ mod imp {
         fn hello(&self, name: String) -> String {
             let greet = format!("Hello {name}!");
             println!("{greet}");
+            _ = self.emit_greeted(&name);
             greet
         }
 
@@ -75,6 +76,7 @@ mod imp {
             glib::timeout_future(Duration::from_secs(delay as u64)).await;
             let greet = format!("Hello {name} after {delay} seconds!");
             println!("{greet}");
+            _ = self.emit_greeted(&name);
             Ok((greet, instant.elapsed().as_secs_f64()))
         }
 
@@ -107,5 +109,8 @@ mod imp {
         }
 
         fn r#raw_ident(&self) {}
+
+        #[dbus(signal)]
+        fn greeted(&self, name: &str) {}
     }
 }
diff --git a/gio-macros/src/dbus_interface/emit.rs b/gio-macros/src/dbus_interface/emit.rs
@@ -1,19 +1,25 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 use crate::dbus_interface::attributes::DBusInterfaceAttribute;
-use crate::dbus_interface::emit_info::{emit_interface_info, emit_method_info};
-use crate::dbus_interface::parse::{DBusItems, DBusMethod, DBusMethodArgumentProvider};
+use crate::dbus_interface::emit_info::{emit_interface_info, emit_method_info, emit_signal_info};
+use crate::dbus_interface::parse::{DBusItems, DBusMethod, DBusMethodArgumentProvider, DBusSignal};
+use crate::utils::ident_name;
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned};
+use quote::{ToTokens as _, quote, quote_spanned};
 use syn::spanned::Spanned as _;
-use syn::{Attribute, Ident, Type};
+use syn::{Attribute, Ident, ReturnType, Token, Type, parse_quote};
 
 pub(crate) fn emit_items(
     impl_attrs: &[Attribute],
     self_ty: &Type,
     items: &DBusItems,
+    gio: &TokenStream,
 ) -> syn::Result<TokenStream> {
     let emit_methods = items.methods.values().map(|method| &method.item);
+    let emit_signals = items
+        .signals
+        .values()
+        .map(|signal| emit_signal_fn(signal, gio));
     let emit_errors = items.errors.iter().map(|(item, error)| {
         let compile_error = error.to_compile_error();
         quote! { #item #compile_error }
@@ -23,6 +29,7 @@ pub(crate) fn emit_items(
         #(#impl_attrs)*
         impl #self_ty {
             #(#emit_methods)*
+            #(#emit_signals)*
             #(#emit_errors)*
         }
     })
@@ -109,13 +116,22 @@ pub(crate) fn emit_methods_impl(
         .values()
         .map(|method| emit_method_info(method, gio))
         .collect::<Result<Vec<_>, _>>()?;
+    let signal_infos = items
+        .signals
+        .values()
+        .map(|signal| emit_signal_info(signal, gio))
+        .collect::<Result<Vec<_>, _>>()?;
 
     Ok(quote! {
         impl #gio::__macro_helpers::dbus_interface_skeleton::DBusMethods for #self_ty {
             fn method_infos() -> impl IntoIterator<Item = #gio::DBusMethodInfo> {
                 [#(#method_infos,)*]
             }
 
+            fn signal_infos() -> impl IntoIterator<Item = #gio::DBusSignalInfo> {
+                [#(#signal_infos,)*]
+            }
+
             fn method_call(
                 &self,
                 connection: #gio::DBusConnection,
@@ -191,3 +207,35 @@ fn emit_method_call_handler(method: &DBusMethod) -> TokenStream {
         }
     }
 }
+
+fn emit_signal_fn(signal: &DBusSignal, gio: &TokenStream) -> TokenStream {
+    let ident = &signal.item.sig.ident;
+    let ident = Ident::new(&format!("emit_{}", ident_name(ident)), ident.span());
+    let arg_idents = signal.args.iter().map(|arg| &arg.ident);
+    let signal_name = &signal.dbus_name;
+    let return_type: Type = parse_quote!(Result<(), #gio::glib::Error>);
+    let block = parse_quote! {{
+        let obj = &*#gio::glib::subclass::types::ObjectSubclassExt::obj(self);
+        let connections = #gio::prelude::DBusInterfaceSkeletonExt::connections(obj);
+        let object_path = #gio::prelude::DBusInterfaceSkeletonExt::object_path(obj);
+        let object_path = object_path.as_deref();
+        let info = gio::prelude::DBusInterfaceSkeletonExt::info(obj);
+        let interface_name = info.name();
+        let variant = (#(#arg_idents,)*).to_variant();
+        for connection in connections {
+            connection.emit_signal(
+                None,
+                object_path.expect("object path should be set when there is at least one connection"),
+                interface_name,
+                #signal_name,
+                Some(&variant),
+            )?;
+        }
+        Ok(())
+    }};
+    let mut item = signal.item.clone();
+    item.block = block;
+    item.sig.ident = ident;
+    item.sig.output = ReturnType::Type(Token![->](Span::call_site()), Box::new(return_type));
+    item.into_token_stream()
+}
diff --git a/gio-macros/src/dbus_interface/emit_info.rs b/gio-macros/src/dbus_interface/emit_info.rs
@@ -1,7 +1,9 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 use crate::dbus_interface::attributes::DBusInterfaceAttribute;
-use crate::dbus_interface::parse::{DBusMethod, DBusMethodArgument, DBusMethodArgumentProvider};
+use crate::dbus_interface::parse::{
+    DBusMethod, DBusMethodArgument, DBusMethodArgumentProvider, DBusSignal, DBusSignalArgument,
+};
 use proc_macro2::TokenStream;
 use quote::quote;
 use std::borrow::Cow;
@@ -19,6 +21,7 @@ pub(crate) fn emit_interface_info(
         #gio::DBusInterfaceInfo::builder()
             .name(#name)
             .methods(<#ident as #helpers::DBusMethods>::method_infos())
+            .signals(<#ident as #helpers::DBusMethods>::signal_infos())
             .build()
     })
 }
@@ -33,15 +36,35 @@ pub(crate) fn emit_method_info(method: &DBusMethod, gio: &TokenStream) -> syn::R
     let out_args = emit_out_arg_infos(&return_type, method.out_arg_names.as_ref(), gio)?;
     let annotations = method
         .deprecated
-        .then_some(("org.freedesktop.DBus.Deprecated", "true"))
+        .then_some((DEPRECATED_ANNOTATION, "true"))
         .into_iter();
     let annotations = annotations.map(|(key, value)| emit_annotation(key, value, gio));
     Ok(quote! {
         #gio::DBusMethodInfo::builder()
+            .name(#name)
             .in_args([#(#in_args,)*])
             .out_args(#out_args)
             .annotations([#(#annotations,)*])
+            .build()
+    })
+}
+
+pub(crate) fn emit_signal_info(signal: &DBusSignal, gio: &TokenStream) -> syn::Result<TokenStream> {
+    let name = &signal.dbus_name;
+    let args = signal
+        .args
+        .iter()
+        .filter_map(|arg| emit_signal_arg_info(arg, gio));
+    let annotations = signal
+        .deprecated
+        .then_some((DEPRECATED_ANNOTATION, "true"))
+        .into_iter();
+    let annotations = annotations.map(|(key, value)| emit_annotation(key, value, gio));
+    Ok(quote! {
+        #gio::DBusSignalInfo::builder()
             .name(#name)
+            .args([#(#args,)*])
+            .annotations([#(#annotations,)*])
             .build()
     })
 }
@@ -77,6 +100,17 @@ fn emit_in_arg_info(argument: &DBusMethodArgument, gio: &TokenStream) -> Option<
     })
 }
 
+fn emit_signal_arg_info(argument: &DBusSignalArgument, gio: &TokenStream) -> Option<TokenStream> {
+    let name = &argument.dbus_name;
+    let signature = emit_signature_str(&argument.arg.ty, gio);
+    Some(quote! {
+        #gio::DBusArgInfo::builder()
+            .name(#name)
+            .signature(#signature)
+            .build()
+    })
+}
+
 // The out args are fundamentally different from the in args.
 //
 // Each function argument maps neatly to an in arg so we know the count and their names at generation time.
@@ -160,3 +194,5 @@ fn emit_annotation(key: &str, value: &str, gio: &TokenStream) -> TokenStream {
             .build()
     }
 }
+
+const DEPRECATED_ANNOTATION: &str = "org.freedesktop.DBus.Deprecated";
diff --git a/gio-macros/src/dbus_interface/mod.rs b/gio-macros/src/dbus_interface/mod.rs
@@ -77,7 +77,7 @@ fn try_dbus_methods(
 ) -> syn::Result<TokenStream> {
     let dbus_items = parse::parse_impl_items(items);
 
-    let items = emit_items(&attrs, &self_ty, &dbus_items)?;
+    let items = emit_items(&attrs, &self_ty, &dbus_items, gio)?;
     let exportable_interface_impl = emit_methods_impl(&self_ty, &dbus_items, gio)?;
     Ok(quote! {
         #items
diff --git a/gio-macros/src/dbus_interface/parse.rs b/gio-macros/src/dbus_interface/parse.rs
@@ -13,7 +13,9 @@ use std::collections::BTreeMap;
 use std::collections::btree_map::Entry;
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{Attribute, FnArg, Ident, ImplItem, ImplItemFn, LitStr, Pat, PatType, Token, Type};
+use syn::{
+    Attribute, FnArg, Ident, ImplItem, ImplItemFn, LitStr, Pat, PatIdent, PatType, Token, Type,
+};
 
 #[derive(Default)]
 pub(crate) struct DBusItems {
@@ -52,9 +54,16 @@ pub(crate) enum DBusMethodArgumentProvider {
 pub(crate) struct DBusSignal {
     pub(crate) item: ImplItemFn,
     pub(crate) dbus_name: LitStr,
+    pub(crate) args: Vec<DBusSignalArgument>,
     pub(crate) deprecated: bool,
 }
 
+pub(crate) struct DBusSignalArgument {
+    pub(crate) arg: PatType,
+    pub(crate) ident: Ident,
+    pub(crate) dbus_name: LitStr,
+}
+
 pub(crate) fn parse_impl_items(items: Vec<ImplItem>) -> DBusItems {
     let mut output = DBusItems::default();
     for item in items {
@@ -71,13 +80,17 @@ pub(crate) fn parse_impl_items(items: Vec<ImplItem>) -> DBusItems {
                     output.errors.push((ImplItem::Fn(method.item), error));
                 }
             }
-            DBusItem::Signal(dbus_signal) => {
-                let mut impl_item = ImplItem::Fn(dbus_signal.item);
-                remove_dbus_attribute_from_impl_item(&mut impl_item);
-                let span = impl_item.span();
-                output
-                    .errors
-                    .push((impl_item, syn::Error::new(span, "[TODO]")));
+            DBusItem::Signal(mut signal) => {
+                remove_dbus_attribute_from_item_fn(&mut signal.item);
+                if let Entry::Vacant(entry) = output.signals.entry(signal.dbus_name.value()) {
+                    entry.insert(signal);
+                } else {
+                    let error = syn::Error::new(
+                        signal.item.span(),
+                        "a signal with this name is already defined",
+                    );
+                    output.errors.push((ImplItem::Fn(signal.item), error));
+                }
             }
             DBusItem::Error(mut impl_item, error) => {
                 remove_dbus_attribute_from_impl_item(&mut impl_item);
@@ -149,6 +162,12 @@ fn parse_impl_item_fn_for_signal(
         .name
         .unwrap_or_else(|| default_method_name(&item.sig.ident));
     let deprecated = is_deprecated(&item.attrs);
+    let args = item
+        .sig
+        .inputs
+        .iter()
+        .filter_map(|input| parse_signal_arg(input.clone()).transpose())
+        .collect::<Result<_, _>>()?;
 
     if !item.block.stmts.is_empty() {
         return Err(syn::Error::new(
@@ -157,9 +176,17 @@ fn parse_impl_item_fn_for_signal(
         ));
     }
 
+    if matches!(item.sig.output, syn::ReturnType::Type(..)) {
+        return Err(syn::Error::new(
+            item.sig.output.span(),
+            "signal must not specify a return type",
+        ));
+    }
+
     Ok(DBusSignal {
         item,
         dbus_name,
+        args,
         deprecated,
     })
 }
@@ -187,6 +214,23 @@ fn parse_method_arg(
     }))
 }
 
+fn parse_signal_arg(arg: FnArg) -> syn::Result<Option<DBusSignalArgument>> {
+    let FnArg::Typed(typed) = arg else {
+        return Ok(None);
+    };
+    let Pat::Ident(PatIdent { ident, .. }) = typed.pat.as_ref() else {
+        return Err(syn::Error::new(
+            typed.pat.span(),
+            "signal parameter must have a name",
+        ));
+    };
+    Ok(Some(DBusSignalArgument {
+        dbus_name: default_method_name(ident),
+        ident: ident.clone(),
+        arg: typed,
+    }))
+}
+
 fn is_deprecated(attrs: &[Attribute]) -> bool {
     attrs.iter().any(|attr| attr.path().is_ident("deprecated"))
 }
diff --git a/gio/src/macro_helpers/dbus_interface_skeleton.rs b/gio/src/macro_helpers/dbus_interface_skeleton.rs
@@ -1,11 +1,13 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
-use crate::{DBusConnection, DBusMethodInfo, DBusMethodInvocation, ffi};
+use crate::{DBusConnection, DBusMethodInfo, DBusMethodInvocation, DBusSignalInfo, ffi};
 
 #[diagnostic::on_unimplemented(message = "No #[gio::dbus_methods] impl block found for {Self}")]
 pub trait DBusMethods {
     fn method_infos() -> impl IntoIterator<Item = DBusMethodInfo>;
 
+    fn signal_infos() -> impl IntoIterator<Item = DBusSignalInfo>;
+
     fn method_call(
         &self,
         connection: DBusConnection,

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ mod imp {`
`53`	`53`	`fn hello(&self, name: String) -> String {`
`54`	`54`	`let greet = format!("Hello {name}!");`
`55`	`55`	`println!("{greet}");`
	`56`	`+ _ = self.emit_greeted(&name);`
`56`	`57`	`greet`
`57`	`58`	`}`
`58`	`59`
`@@ -75,6 +76,7 @@ mod imp {`
`75`	`76`	`glib::timeout_future(Duration::from_secs(delay as u64)).await;`
`76`	`77`	`let greet = format!("Hello {name} after {delay} seconds!");`
`77`	`78`	`println!("{greet}");`
	`79`	`+ _ = self.emit_greeted(&name);`
`78`	`80`	`Ok((greet, instant.elapsed().as_secs_f64()))`
`79`	`81`	`}`
`80`	`82`
`@@ -107,5 +109,8 @@ mod imp {`
`107`	`109`	`}`
`108`	`110`
`109`	`111`	`fn r#raw_ident(&self) {}`
	`112`	`+`
	`113`	`+ #[dbus(signal)]`
	`114`	`+ fn greeted(&self, name: &str) {}`
`110`	`115`	`}`
`111`	`116`	`}`