glib: glib-macros: add SharedType and Shared derive macro

Added a SharedType trait that allows implementing reference-counted
types in terms os std::sync::Arc. In particular, the ffi methods that
increment reference counting can return always the same pointer value.
Also, added a `Shared` derive macro, similar to the existing `GBoxed`
one, that simplifies the creation of Shared objects.

Author: Matteo Biggio

glib-macros/src/lib.rs

@@ -8,6 +8,7 @@ mod gerror_domain_derive;
 mod gflags_attribute;
 mod object_interface_attribute;
 mod object_subclass_attribute;
+mod shared_derive;
 mod utils;
 
 use proc_macro::TokenStream;
@@ -300,6 +301,34 @@ pub fn gboxed_derive(input: TokenStream) -> TokenStream {
     gen.into()
 }
 
+/// Derive macro for defining a [`SharedType`]`::get_type` function and
+/// the [`glib::Value`] traits.
+///
+/// # Example
+///
+/// ```
+/// use glib::prelude::*;
+/// use glib::subclass::prelude::*;
+///
+/// #[derive(Clone, Debug, PartialEq, Eq)]
+/// struct MySharedInner {
+///   foo: String,
+/// }
+/// #[derive(Clone, Debug, PartialEq, Eq, glib::Shared)]
+/// #[shared(type_name = "MyShared")]
+/// struct MyShared(std::sync::Arc<MySharedInner>);
+/// ```
+///
+/// [`SharedType`]: subclass/shared/trait.SharedType.html
+/// [`glib::Value`]: value/struct.Value.html
+#[proc_macro_derive(Shared, attributes(shared))]
+#[proc_macro_error]
+pub fn shared_derive(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let gen = shared_derive::impl_shared(&input);
+    gen.into()
+}
+
 /// Attribute macro for defining flags using the `bitflags` crate.
 /// This macro will also define a `GFlags::get_type` function and
 /// the [`glib::Value`] traits.

glib-macros/src/shared_derive.rs

@@ -0,0 +1,191 @@
+use crate::utils::{crate_ident_new, find_attribute_meta, find_nested_meta, parse_type_name};
+use proc_macro2::{Ident, TokenStream};
+use proc_macro_error::abort_call_site;
+use quote::quote;
+
+fn gen_impl_set_value_optional(
+    name: &Ident,
+    inner_name: &syn::Path,
+    crate_ident: &Ident,
+) -> TokenStream {
+    quote! {
+        impl #crate_ident::value::SetValueOptional for #name {
+            unsafe fn set_value_optional(value: &mut #crate_ident::value::Value, this: Option<&Self>) {
+                let ptr: *mut #inner_name = match this {
+                    Some(this) => std::sync::Arc::into_raw(this.0.clone()) as *mut _,
+                    None => std::ptr::null_mut(),
+                };
+
+                #crate_ident::gobject_ffi::g_value_take_boxed(
+                    #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(value).0,
+                    ptr as *mut _,
+                );
+            }
+        }
+    }
+}
+
+fn gen_impl_from_value(name: &Ident, inner_name: &syn::Path, crate_ident: &Ident) -> TokenStream {
+    quote! {
+        impl<'a> #crate_ident::value::FromValue<'a> for #name {
+            unsafe fn from_value(value: &'a #crate_ident::value::Value) -> Self {
+                let ptr = #crate_ident::gobject_ffi::g_value_dup_boxed(
+                    #crate_ident::translate::ToGlibPtr::to_glib_none(value).0,
+                );
+                assert!(!ptr.is_null());
+                #name(std::sync::Arc::from_raw(ptr as *const #inner_name))
+            }
+        }
+    }
+}
+
+fn gen_ptr_to_option(name: &Ident, inner_name: &syn::Path, nullable: bool) -> TokenStream {
+    if nullable {
+        quote! {
+            if ptr.is_null() {
+                None
+            } else {
+                Some(#name(std::sync::Arc::from_raw(ptr as *const #inner_name)))
+            }
+        }
+    } else {
+        quote! {
+            assert!(!ptr.is_null());
+            Some(#name(std::sync::Arc::from_raw(ptr as *const #inner_name)))
+        }
+    }
+}
+
+fn inner_name(input: &syn::DeriveInput) -> Option<&syn::Path> {
+    let fields = match &input.data {
+        syn::Data::Struct(s) => &s.fields,
+        _ => return None,
+    };
+
+    let unnamed = match fields {
+        syn::Fields::Unnamed(u) if u.unnamed.len() == 1 => &u.unnamed[0],
+        _ => return None,
+    };
+
+    let path = match &unnamed.ty {
+        syn::Type::Path(p) => p,
+        _ => return None,
+    };
+
+    let inner = match path.path.segments.last() {
+        Some(s) if s.ident == "Arc" => &s.arguments,
+        _ => return None,
+    };
+
+    let inner = match &inner {
+        syn::PathArguments::AngleBracketed(a) if a.args.len() == 1 => &a.args[0],
+        _ => return None,
+    };
+
+    let inner = match &inner {
+        syn::GenericArgument::Type(syn::Type::Path(p)) => &p.path,
+        _ => return None,
+    };
+
+    Some(inner)
+}
+
+pub fn impl_shared(input: &syn::DeriveInput) -> proc_macro2::TokenStream {
+    let inner_name = match inner_name(input) {
+        Some(p) => p,
+        _ => abort_call_site!("derive(Shared) requires struct MyStruct(Arc<MyInnerStruct>)"),
+    };
+
+    let name = &input.ident;
+    let gtype_name = match parse_type_name(&input, "shared") {
+        Ok(v) => v,
+        Err(e) => abort_call_site!(
+            "{}: derive(Shared) requires #[shared(type_name = \"SharedTypeName\")]",
+            e
+        ),
+    };
+
+    let meta = find_attribute_meta(&input.attrs, "shared")
+        .unwrap()
+        .unwrap();
+    let nullable = find_nested_meta(&meta, "nullable").is_some();
+    let crate_ident = crate_ident_new();
+    let ptr_to_option = gen_ptr_to_option(name, inner_name, nullable);
+
+    let impl_from_value = if !nullable {
+        gen_impl_from_value(name, inner_name, &crate_ident)
+    } else {
+        quote! {}
+    };
+
+    let impl_set_value_optional = if nullable {
+        gen_impl_set_value_optional(name, inner_name, &crate_ident)
+    } else {
+        quote! {}
+    };
+
+    quote! {
+        impl #crate_ident::subclass::shared::SharedType for #name {
+            const NAME: &'static str = #gtype_name;
+
+            type InnerType = #inner_name;
+
+            fn ref_(this: *const Self::InnerType) -> *const Self::InnerType {
+                unsafe {
+                    use std::mem::ManuallyDrop;
+                    let this_arc = ManuallyDrop::new(std::sync::Arc::from_raw(this));
+                    std::sync::Arc::into_raw(ManuallyDrop::take(&mut this_arc.clone()))
+                }
+            }
+
+            fn unref(this: *const Self::InnerType) {
+                unsafe {
+                    let _ = std::sync::Arc::from_raw(this);
+                }
+            }
+
+            fn get_type() -> glib::Type {
+                static mut TYPE_: glib::Type = glib::Type::INVALID;
+                static ONCE: ::std::sync::Once = ::std::sync::Once::new();
+
+                ONCE.call_once(|| {
+                    let type_ = #crate_ident::subclass::shared::register_shared_type::<Self>();
+                    unsafe {
+                        TYPE_ = type_;
+                    }
+                });
+
+                unsafe { TYPE_ }
+            }
+        }
+
+        impl #crate_ident::StaticType for #name {
+            fn static_type() -> #crate_ident::Type {
+                <#name as #crate_ident::subclass::shared::SharedType>::get_type()
+            }
+        }
+
+        impl #crate_ident::value::SetValue for #name {
+            unsafe fn set_value(value: &mut #crate_ident::value::Value, this: &Self) {
+                let ptr: *mut #inner_name = std::sync::Arc::into_raw(this.0.clone()) as *mut _;
+                #crate_ident::gobject_ffi::g_value_take_boxed(
+                    #crate_ident::translate::ToGlibPtrMut::to_glib_none_mut(value).0,
+                    ptr as *mut _,
+                );
+            }
+        }
+
+        #impl_set_value_optional
+
+        impl<'a> #crate_ident::value::FromValueOptional<'a> for #name {
+            unsafe fn from_value_optional(value: &'a #crate_ident::value::Value) -> Option<Self> {
+                let ptr = #crate_ident::gobject_ffi::g_value_dup_boxed(
+                    #crate_ident::translate::ToGlibPtr::to_glib_none(value).0,
+                );
+                #ptr_to_option
+            }
+        }
+
+        #impl_from_value
+    }
+}

glib-macros/tests/test.rs

@@ -5,7 +5,7 @@
 use glib::prelude::*;
 use glib::subclass::prelude::*;
 use glib::translate::{FromGlib, ToGlib};
-use glib::{gflags, GBoxed, GEnum, GErrorDomain};
+use glib::{gflags, GBoxed, GEnum, GErrorDomain, Shared};
 
 #[test]
 fn derive_gerror_domain() {
@@ -22,6 +22,72 @@ fn derive_gerror_domain() {
     assert!(matches!(err.kind::<TestError>(), Some(TestError::Bad)));
 }
 
+#[test]
+fn derive_shared() {
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    struct MyInnerShared {
+        foo: String,
+    };
+    #[derive(Debug, Eq, PartialEq, Clone, Shared)]
+    #[shared(type_name = "MySharedType")]
+    struct MyShared(std::sync::Arc<MyInnerShared>);
+
+    assert_eq!(MyShared::get_type().name(), "MySharedType");
+
+    let p = MyShared(std::sync::Arc::new(MyInnerShared {
+        foo: String::from("bar"),
+    }));
+
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 1);
+    let v = p.to_value();
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 2);
+    let p_clone = v.get::<MyShared>().unwrap().unwrap();
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 3);
+    drop(p_clone);
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 2);
+    drop(v);
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 1);
+}
+
+#[test]
+fn derive_shared_nullable() {
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    struct MyInnerNullableShared {
+        foo: String,
+    };
+    #[derive(Clone, Debug, PartialEq, Eq, Shared)]
+    #[shared(type_name = "MyNullableSharedType", nullable)]
+    struct MyNullableShared(std::sync::Arc<MyInnerNullableShared>);
+
+    assert_eq!(MyNullableShared::get_type().name(), "MyNullableSharedType");
+
+    let p = MyNullableShared(std::sync::Arc::new(MyInnerNullableShared {
+        foo: String::from("bar"),
+    }));
+
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 1);
+    let _v = p.to_value();
+    assert_eq!(std::sync::Arc::strong_count(&p.0), 2);
+
+    let p = Some(MyNullableShared(std::sync::Arc::new(
+        MyInnerNullableShared {
+            foo: String::from("foo"),
+        },
+    )));
+
+    assert_eq!(std::sync::Arc::strong_count(&p.as_ref().unwrap().0), 1);
+    let v = p.to_value();
+    assert_eq!(std::sync::Arc::strong_count(&p.as_ref().unwrap().0), 2);
+    assert_eq!(
+        p.as_ref().unwrap().0.foo,
+        v.get::<MyNullableShared>().unwrap().unwrap().0.foo
+    );
+
+    let b: Option<MyNullableShared> = None;
+    let v = b.to_value();
+    assert_eq!(None, v.get::<MyNullableShared>().unwrap());
+}
+
 #[test]
 fn derive_genum() {
     #[derive(Debug, Eq, PartialEq, Clone, Copy, GEnum)]

glib/src/lib.rs

@@ -88,6 +88,7 @@ pub use once_cell;
 
 pub use glib_macros::{
     clone, gflags, object_interface, object_subclass, Downgrade, GBoxed, GEnum, GErrorDomain,
+    Shared,
 };
 
 pub use self::array::Array;

glib/src/subclass/mod.rs

@@ -249,13 +249,16 @@ pub mod object;
 #[macro_use]
 pub mod boxed;
 
+pub mod shared;
+
 pub mod signal;
 
 pub mod prelude {
     //! Prelude that re-exports all important traits from this crate.
     pub use super::boxed::BoxedType;
     pub use super::interface::{ObjectInterface, ObjectInterfaceExt, ObjectInterfaceType};
     pub use super::object::{ObjectClassSubclassExt, ObjectImpl, ObjectImplExt};
+    pub use super::shared::SharedType;
     pub use super::types::{
         ClassStruct, InstanceStruct, IsImplementable, IsSubclassable, ObjectSubclass,
         ObjectSubclassExt, ObjectSubclassType,