Signal macro

glib-macros/Cargo.toml

@@ -18,6 +18,7 @@ proc-macro2 = "1.0"
 quote = "1.0"
 syn = { version = "2.0.96", features = ["full"] }
 proc-macro-crate = "3.1"
+bitflags.workspace = true
 
 [lib]
 proc-macro = true

glib-macros/src/derived_signals_attribute.rs

@@ -0,0 +1,53 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use proc_macro2::{Span, TokenStream};
+use quote::quote;
+
+pub const WRONG_PLACE_MSG: &str =
+    "This macro should be used on `impl` block for `glib::ObjectImpl` trait";
+
+pub fn impl_derived_signals(input: &syn::ItemImpl) -> syn::Result<TokenStream> {
+    let syn::ItemImpl {
+        attrs,
+        generics,
+        trait_,
+        self_ty,
+        items,
+        ..
+    } = input;
+
+    let trait_path = &trait_
+        .as_ref()
+        .ok_or_else(|| syn::Error::new(Span::call_site(), WRONG_PLACE_MSG))?
+        .1;
+
+    let mut has_signals = false;
+
+    for item in items {
+        if let syn::ImplItem::Fn(method) = item {
+            let ident = &method.sig.ident;
+
+            if ident == "signals" {
+                has_signals = true;
+            }
+        }
+    }
+
+    let glib = crate::utils::crate_ident_new();
+
+    let signals = quote!(
+        fn signals() -> &'static [#glib::subclass::signal::Signal] {
+            Self::derived_signals()
+        }
+    );
+
+    let generated = [(!has_signals).then_some(signals)];
+
+    Ok(quote!(
+        #(#attrs)*
+        impl #generics #trait_path for #self_ty {
+            #(#items)*
+            #(#generated)*
+        }
+    ))
+}

glib-macros/src/lib.rs

@@ -5,13 +5,15 @@ mod boxed_derive;
 mod clone;
 mod closure;
 mod derived_properties_attribute;
+mod derived_signals_attribute;
 mod downgrade_derive;
 mod enum_derive;
 mod error_domain_derive;
 mod flags_attribute;
 mod object_impl_attributes;
 mod properties;
 mod shared_boxed_derive;
+mod signals_attribute;
 mod value_delegate_derive;
 mod variant_derive;
 
@@ -1501,6 +1503,32 @@ pub fn derived_properties(_attr: TokenStream, item: TokenStream) -> TokenStream
         .into()
 }
 
+/// This macro enables you to implement object signals in a quick way.
+#[proc_macro_attribute]
+pub fn signals(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr_input = syn::parse_macro_input!(attr as signals_attribute::Args);
+
+    syn::parse::<syn::ItemImpl>(item)
+        .map_err(|_| syn::Error::new(Span::call_site(), signals_attribute::WRONG_PLACE_MSG))
+        .and_then(|item_input| signals_attribute::impl_signals(attr_input, item_input))
+        .unwrap_or_else(syn::Error::into_compile_error)
+        .into()
+}
+
+#[proc_macro_attribute]
+pub fn derived_signals(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    syn::parse::<syn::ItemImpl>(item)
+        .map_err(|_| {
+            syn::Error::new(
+                Span::call_site(),
+                derived_signals_attribute::WRONG_PLACE_MSG,
+            )
+        })
+        .and_then(|input| derived_signals_attribute::impl_derived_signals(&input))
+        .unwrap_or_else(syn::Error::into_compile_error)
+        .into()
+}
+
 /// # Example
 /// ```
 /// use glib::prelude::*;