glib-macros: Allow to omit set for construct_only properties

Author: felinira

glib-macros/src/properties.rs

@@ -236,6 +236,7 @@ struct PropDesc {
     member: Option<syn::Ident>,
     builder: Option<(Punctuated<syn::Expr, Token![,]>, TokenStream2)>,
     builder_fields: HashMap<syn::Ident, Option<syn::Expr>>,
+    is_construct_only: bool,
 }
 
 impl PropDesc {
@@ -248,7 +249,7 @@ impl PropDesc {
         let ReceivedAttrs {
             nullable,
             get,
-            set,
+            mut set,
             override_class,
             override_interface,
             ty,
@@ -258,6 +259,17 @@ impl PropDesc {
             builder_fields,
         } = attrs;
 
+        let is_construct_only = if builder_fields.iter().any(|(k, _)| *k == "construct_only") {
+            // Insert a default setter automatically
+            if set.is_none() {
+                set = Some(MaybeCustomFn::Default);
+            }
+
+            true
+        } else {
+            false
+        };
+
         if get.is_none() && set.is_none() {
             return Err(syn::Error::new(
                 attrs_span,
@@ -295,6 +307,7 @@ impl PropDesc {
             member,
             builder,
             builder_fields,
+            is_construct_only,
         })
     }
 }
@@ -534,8 +547,8 @@ fn expand_wrapper_getset_properties(props: &[PropDesc]) -> TokenStream2 {
                  self.property::<<#ty as #crate_ident::Property>::Value>(#stripped_name)
             })
         });
-        let is_construct_only = p.builder_fields.iter().any(|(k, _)| *k == "construct_only");
-        let setter = (p.set.is_some() && !is_construct_only).then(|| {
+
+        let setter = (p.set.is_some() && !p.is_construct_only).then(|| {
             let ident = format_ident!("set_{}", ident);
             let target_ty = quote!(<<#ty as #crate_ident::Property>::Value as #crate_ident::HasParamSpec>::SetValue);
             let set_ty = if p.nullable {

glib-macros/tests/properties.rs

@@ -160,6 +160,10 @@ mod foo {
             weak_ref_prop: glib::WeakRef<glib::Object>,
             #[property(get, set)]
             send_weak_ref_prop: glib::SendWeakRef<glib::Object>,
+            #[property(get, default_value = 0, construct_only)]
+            construct_only_cell: OnceCell<u32>,
+            #[property(get, set = Self::set_construct_only_custom, construct_only)]
+            construct_only_custom_setter: OnceCell<Option<String>>,
         }
 
         impl ObjectImpl for Foo {
@@ -194,6 +198,11 @@ mod foo {
             fn overridden(&self) -> u32 {
                 43
             }
+            fn set_construct_only_custom(&self, value: Option<String>) {
+                self.construct_only_custom_setter
+                    .set(value.map(|v| format!("custom set: {}", v)))
+                    .expect("Setter to be only called once");
+            }
         }
     }
 
@@ -382,7 +391,22 @@ fn props() {
     // object subclass
     let myobj = glib::BoxedAnyObject::new("");
     myfoo.set_object(Some(myobj.upcast_ref()));
-    assert_eq!(myfoo.object(), Some(myobj.upcast()))
+    assert_eq!(myfoo.object(), Some(myobj.upcast()));
+
+    // construct_only
+    let myfoo: foo::Foo = glib::object::Object::builder()
+        .property("construct-only-cell", 1u32)
+        .build();
+    assert_eq!(myfoo.construct_only_cell(), 1u32);
+
+    // construct_only with custom setter
+    let myfoo: foo::Foo = glib::object::Object::builder()
+        .property("construct-only-custom-setter", "foo")
+        .build();
+    assert_eq!(
+        myfoo.construct_only_custom_setter(),
+        Some("custom set: foo".to_owned())
+    );
 }
 
 #[cfg(test)]