Merge pull request #959 from pbor/prop-override

macros: support overrides in the properties macro

Author: sdroege

glib-macros/src/properties.rs

@@ -85,6 +85,10 @@ enum PropAttr {
     Get(Option<syn::Expr>),
     Set(Option<syn::Expr>),
 
+    // ident [= expr]
+    OverrideClass(syn::Type),
+    OverrideInterface(syn::Type),
+
     // ident = expr
     Type(syn::Type),
 
@@ -112,6 +116,8 @@ impl Parse for PropAttr {
                 "name" => PropAttr::Name(input.parse()?),
                 "get" => PropAttr::Get(Some(input.parse()?)),
                 "set" => PropAttr::Set(Some(input.parse()?)),
+                "override_class" => PropAttr::OverrideClass(input.parse()?),
+                "override_interface" => PropAttr::OverrideInterface(input.parse()?),
                 "type" => PropAttr::Type(input.parse()?),
                 "member" => PropAttr::Member(input.parse()?),
                 // Special case "default = ..." and map it to .default_value(...)
@@ -138,8 +144,7 @@ impl Parse for PropAttr {
                 }
             }
         } else {
-            // attributes with only the identifier
-            // name
+            // attributes with only the identifier name
             match &*name_str {
                 "get" => PropAttr::Get(None),
                 "set" => PropAttr::Set(None),
@@ -163,12 +168,15 @@ impl Parse for PropAttr {
 struct ReceivedAttrs {
     get: Option<MaybeCustomFn>,
     set: Option<MaybeCustomFn>,
+    override_class: Option<syn::Type>,
+    override_interface: Option<syn::Type>,
     ty: Option<syn::Type>,
     member: Option<syn::Ident>,
     name: Option<syn::LitStr>,
     builder: Option<(Punctuated<syn::Expr, Token![,]>, TokenStream2)>,
     builder_fields: HashMap<syn::Ident, Option<syn::Expr>>,
 }
+
 impl ReceivedAttrs {
     fn new(
         attrs_span: &proc_macro2::Span,
@@ -185,13 +193,24 @@ impl ReceivedAttrs {
                 "No `get` or `set` specified: at least one is required.".to_string(),
             ));
         }
+
+        if this.override_class.is_some() && this.override_interface.is_some() {
+            return Err(syn::Error::new(
+                *attrs_span,
+                "Both `override_class` and `override_interface` specified.".to_string(),
+            ));
+        }
+
         Ok(this)
     }
+
     fn set_from_attr(&mut self, attr: PropAttr) {
         match attr {
             PropAttr::Get(some_fn) => self.get = Some(some_fn.into()),
             PropAttr::Set(some_fn) => self.set = Some(some_fn.into()),
             PropAttr::Name(lit) => self.name = Some(lit),
+            PropAttr::OverrideClass(ty) => self.override_class = Some(ty),
+            PropAttr::OverrideInterface(ty) => self.override_interface = Some(ty),
             PropAttr::Type(ty) => self.ty = Some(ty),
             PropAttr::Member(member) => self.member = Some(member),
             PropAttr::Builder(required_params, optionals) => {
@@ -211,12 +230,15 @@ struct PropDesc {
     field_ident: syn::Ident,
     ty: syn::Type,
     name: syn::LitStr,
+    override_class: Option<syn::Type>,
+    override_interface: Option<syn::Type>,
     get: Option<MaybeCustomFn>,
     set: Option<MaybeCustomFn>,
     member: Option<syn::Ident>,
     builder: Option<(Punctuated<syn::Expr, Token![,]>, TokenStream2)>,
     builder_fields: HashMap<syn::Ident, Option<syn::Expr>>,
 }
+
 impl PropDesc {
     fn new(
         attrs_span: proc_macro2::Span,
@@ -227,6 +249,8 @@ impl PropDesc {
         let ReceivedAttrs {
             get,
             set,
+            override_class,
+            override_interface,
             ty,
             member,
             name,
@@ -247,11 +271,13 @@ impl PropDesc {
         Ok(Self {
             attrs_span,
             field_ident,
+            ty,
+            name,
+            override_class,
+            override_interface,
             get,
             set,
-            ty,
             member,
-            name,
             builder,
             builder_fields,
         })
@@ -273,6 +299,19 @@ fn expand_properties_fn(props: &[PropDesc]) -> TokenStream2 {
             (None, None) => unreachable!("No `get` or `set` specified"),
         };
 
+        match (&prop.override_class, &prop.override_interface) {
+            (Some(c), None) => {
+                return quote!(#crate_ident::ParamSpecOverride::for_class::<#c>(#name))
+            }
+            (None, Some(i)) => {
+                return quote!(#crate_ident::ParamSpecOverride::for_interface::<#i>(#name))
+            }
+            (Some(_), Some(_)) => {
+                unreachable!("Both `override_class` and `override_interface` specified")
+            }
+            (None, None) => (),
+        };
+
         let builder_call = builder
             .as_ref()
             .cloned()
@@ -309,6 +348,7 @@ fn expand_properties_fn(props: &[PropDesc]) -> TokenStream2 {
         }
     )
 }
+
 fn expand_property_fn(props: &[PropDesc]) -> TokenStream2 {
     let crate_ident = crate_ident_new();
     let match_branch_get = props.iter().flat_map(|p| {
@@ -360,6 +400,7 @@ fn expand_property_fn(props: &[PropDesc]) -> TokenStream2 {
         }
     )
 }
+
 fn expand_set_property_fn(props: &[PropDesc]) -> TokenStream2 {
     let crate_ident = crate_ident_new();
     let match_branch_set = props.iter().flat_map(|p| {

glib-macros/tests/properties.rs

@@ -3,6 +3,59 @@
 use glib::prelude::*;
 use glib::ParamFlags;
 
+#[cfg(test)]
+mod base {
+    use glib::prelude::*;
+    use glib::subclass::prelude::*;
+    use glib_macros::Properties;
+    use std::marker::PhantomData;
+
+    pub mod imp {
+        use glib::{ParamSpec, Value};
+
+        use super::*;
+
+        #[derive(Properties, Default)]
+        #[properties(wrapper_type = super::Base)]
+        pub struct Base {
+            #[property(get = Self::not_overridden)]
+            overridden: PhantomData<u32>,
+            #[property(get = Self::not_overridden)]
+            not_overridden: PhantomData<u32>,
+        }
+
+        impl ObjectImpl for Base {
+            fn properties() -> &'static [ParamSpec] {
+                Self::derived_properties()
+            }
+            fn set_property(&self, _id: usize, _value: &Value, _pspec: &ParamSpec) {
+                Self::derived_set_property(self, _id, _value, _pspec)
+            }
+            fn property(&self, id: usize, _pspec: &ParamSpec) -> Value {
+                Self::derived_property(self, id, _pspec)
+            }
+        }
+
+        #[glib::object_subclass]
+        impl ObjectSubclass for Base {
+            const NAME: &'static str = "MyBase";
+            type Type = super::Base;
+        }
+
+        impl Base {
+            fn not_overridden(&self) -> u32 {
+                42
+            }
+        }
+    }
+
+    glib::wrapper! {
+        pub struct Base(ObjectSubclass<imp::Base>);
+    }
+
+    unsafe impl<T: ObjectImpl> IsSubclassable<T> for Base {}
+}
+
 #[cfg(test)]
 mod foo {
     use glib::prelude::*;
@@ -14,6 +67,8 @@ mod foo {
     use std::marker::PhantomData;
     use std::sync::Mutex;
 
+    use super::base::Base;
+
     #[derive(Clone, Default, Debug, PartialEq, Eq, glib::Boxed)]
     #[boxed_type(name = "SimpleBoxedString")]
     pub struct SimpleBoxedString(pub String);
@@ -88,6 +143,8 @@ mod foo {
             once_cell: OnceCell<u8>,
             #[property(get, set)]
             cell: Cell<u8>,
+            #[property(get = Self::overridden, override_class = Base)]
+            overridden: PhantomData<u32>,
         }
 
         impl ObjectImpl for Foo {
@@ -106,6 +163,7 @@ mod foo {
         impl ObjectSubclass for Foo {
             const NAME: &'static str = "MyFoo";
             type Type = super::Foo;
+            type ParentType = Base;
         }
 
         impl Foo {
@@ -118,11 +176,14 @@ mod foo {
             fn set_fizz(&self, value: String) {
                 *self.fizz.borrow_mut() = format!("custom set: {}", value);
             }
+            fn overridden(&self) -> u32 {
+                43
+            }
         }
     }
 
     glib::wrapper! {
-        pub struct Foo(ObjectSubclass<imp::Foo>);
+        pub struct Foo(ObjectSubclass<imp::Foo>) @extends Base;
     }
 }
 
@@ -275,4 +336,12 @@ fn props() {
             "setter nick".to_string()
         );
     }
+
+    // overrides
+    {
+        let overridden: u32 = myfoo.property("overridden");
+        assert_eq!(overridden, 43);
+        let not_overridden: u32 = myfoo.property("not-overridden");
+        assert_eq!(not_overridden, 42);
+    }
 }