Add initial glib::signals! macro

examples/object_subclass/author.rs

@@ -4,14 +4,13 @@
 use glib::prelude::*;
 use glib::subclass::prelude::*;
 use glib::subclass::Signal;
-use glib::Properties;
+use glib::subclass::object::DerivedObjectSignals;
 use std::cell::RefCell;
-use std::sync::OnceLock;
 
 mod imp {
     use super::*;
 
-    #[derive(Properties, Default)]
+    #[derive(glib::Properties, Default)]
     #[properties(wrapper_type = super::Author)]
     pub struct Author {
         #[property(get, set)]
@@ -20,11 +19,17 @@ mod imp {
         surname: RefCell<String>,
     }
 
+    #[glib::signals(wrapper_type = super::Author)]
+    impl Author {
+
+        #[signal]
+        fn awarded(&self) {}
+    }
+
     #[glib::derived_properties]
     impl ObjectImpl for Author {
         fn signals() -> &'static [Signal] {
-            static SIGNALS: OnceLock<Vec<Signal>> = OnceLock::new();
-            SIGNALS.get_or_init(|| vec![Signal::builder("awarded").build()])
+            Self::derived_signals()
         }
     }
 
@@ -38,6 +43,7 @@ mod imp {
 glib::wrapper! {
     pub struct Author(ObjectSubclass<imp::Author>);
 }
+
 impl Author {
     pub fn new(name: &str, surname: &str) -> Self {
         glib::Object::builder()

glib-macros/src/lib.rs

@@ -14,13 +14,14 @@ mod properties;
 mod shared_boxed_derive;
 mod value_delegate_derive;
 mod variant_derive;
+mod signals;
 
 mod utils;
 
 use flags_attribute::AttrInput;
 use proc_macro::TokenStream;
 use proc_macro2::Span;
-use syn::{parse_macro_input, DeriveInput};
+use syn::{parse_macro_input, DeriveInput, Error};
 use utils::{parse_nested_meta_items_from_stream, NestedMetaItem};
 
 /// Macro for passing variables as strong or weak references into a closure.
@@ -1587,3 +1588,19 @@ pub fn derive_value_delegate(input: TokenStream) -> TokenStream {
 pub fn async_test(args: TokenStream, item: TokenStream) -> TokenStream {
     async_test::async_test(args, item)
 }
+
+#[proc_macro_attribute]
+pub fn signals(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(attr as signals::SignalsArgs);
+    match syn::parse::<syn::ItemImpl>(item) {
+        Ok(input) => signals::impl_signals(input, args)
+            .unwrap_or_else(syn::Error::into_compile_error)
+            .into(),
+        Err(_) => Error::new(
+            Span::call_site(),
+            signals::WRONG_PLACE_MSG,
+        )
+        .into_compile_error()
+        .into(),
+    }
+}