Merge pull request #1043 from SeaDve/value-delegate-improvements

Value delegate improvements

glib-macros/src/value_delegate_derive.rs

@@ -123,7 +123,9 @@ pub fn impl_value_delegate(input: ValueDelegateInput) -> syn::Result<proc_macro:
 
     // this must be called in a context where `this` is defined.
     let delegate_value = match mode {
-        DeriveMode::From => quote!(#delegated_ty::from(this)),
+        DeriveMode::From => {
+            quote!(<#delegated_ty as std::convert::From<_>>::from(this))
+        }
         DeriveMode::Private => quote!(this.0),
     };
 
@@ -132,7 +134,7 @@ pub fn impl_value_delegate(input: ValueDelegateInput) -> syn::Result<proc_macro:
             impl #crate_ident::value::ToValueOptional for #ident {
                 fn to_value_optional(s: Option<&Self>) -> #crate_ident::value::Value {
                     if let Some(this) = s {
-                        Some(&#delegate_value).to_value()
+                        #crate_ident::value::ToValue::to_value(&Some(&#delegate_value))
                     } else {
                         #crate_ident::value::ToValueOptional::to_value_optional(None::<&#delegated_ty>)
                     }
@@ -142,24 +144,28 @@ pub fn impl_value_delegate(input: ValueDelegateInput) -> syn::Result<proc_macro:
     });
 
     let from_value = match mode {
-        DeriveMode::From => quote!(#ident::from(#delegated_ty::from_value(value))),
-        DeriveMode::Private => quote!(#ident(#delegated_ty::from_value(value))),
+        DeriveMode::From => {
+            quote!(#ident::from(<#delegated_ty as #crate_ident::value::FromValue<'a>>::from_value(value)))
+        }
+        DeriveMode::Private => {
+            quote!(#ident(<#delegated_ty as #crate_ident::value::FromValue<'a>>::from_value(value)))
+        }
     };
 
     let res = quote! {
         impl #crate_ident::types::StaticType for #ident {
             fn static_type() -> glib::types::Type {
-                #delegated_ty::static_type()
+                <#delegated_ty as #crate_ident::types::StaticType>::static_type()
             }
         }
         impl #crate_ident::value::ToValue for #ident {
             fn to_value(&self) -> #crate_ident::value::Value {
                 let this = self;
-                #delegate_value.to_value()
+                #crate_ident::value::ToValue::to_value(&#delegate_value)
             }
             fn value_type(&self) -> #crate_ident::types::Type {
                 let this = self;
-                #delegate_value.value_type()
+                #crate_ident::value::ToValue::value_type(&#delegate_value)
             }
         }
 
@@ -179,7 +185,7 @@ pub fn impl_value_delegate(input: ValueDelegateInput) -> syn::Result<proc_macro:
             type BuilderFn = <#delegated_ty as #crate_ident::HasParamSpec>::BuilderFn;
 
             fn param_spec_builder() -> Self::BuilderFn {
-                #delegated_ty::param_spec_builder()
+                <#delegated_ty as #crate_ident::HasParamSpec>::param_spec_builder()
             }
         }
     };

glib-macros/tests/value_delegate_derive.rs

@@ -0,0 +1,73 @@
+use glib::{value::FromValue, HasParamSpec, StaticType, ToValue};
+
+#[test]
+fn higher_level_types() {
+    #[derive(Debug, glib::ValueDelegate)]
+    pub struct MyVec(Vec<String>);
+
+    #[derive(Debug, glib::ValueDelegate)]
+    #[value_delegate(from = Option<String>)]
+    struct MyVecManualFrom(Vec<String>);
+
+    impl From<Option<String>> for MyVecManualFrom {
+        fn from(v: Option<String>) -> Self {
+            Self(v.into_iter().collect::<Vec<_>>())
+        }
+    }
+    impl<'a> From<&'a MyVecManualFrom> for Option<String> {
+        fn from(v: &'a MyVecManualFrom) -> Self {
+            v.0.iter().next().cloned()
+        }
+    }
+
+    let vec = vec!["foo".to_string(), "bar".to_string()];
+    let vec_value = vec.to_value();
+    let my_vec_value = MyVec(vec.clone()).to_value();
+
+    assert_eq!(MyVec::static_type(), Vec::<String>::static_type());
+    assert_eq!(
+        vec_value.get::<Vec<String>>().unwrap(),
+        my_vec_value.get::<Vec<String>>().unwrap(),
+    );
+    assert_eq!(vec_value.value_type(), my_vec_value.value_type());
+    assert_eq!(unsafe { Vec::<String>::from_value(&vec_value) }, unsafe {
+        MyVec::from_value(&vec_value).0
+    });
+    assert_eq!(
+        unsafe { Vec::<String>::from_value(&my_vec_value) },
+        unsafe { MyVec::from_value(&my_vec_value).0 }
+    );
+
+    let opt = Some("foo".to_string());
+    let opt_value = opt.to_value();
+    let my_vec_manual_from_value = MyVecManualFrom::from(opt).to_value();
+
+    assert_eq!(
+        MyVecManualFrom::static_type(),
+        Option::<String>::static_type()
+    );
+    assert_eq!(
+        opt_value.get::<Option<String>>().unwrap(),
+        my_vec_manual_from_value.get::<Option<String>>().unwrap(),
+    );
+    assert_eq!(
+        opt_value.value_type(),
+        my_vec_manual_from_value.value_type()
+    );
+    assert_eq!(
+        unsafe {
+            Option::<String>::from_value(&opt_value)
+                .into_iter()
+                .collect::<Vec<_>>()
+        },
+        unsafe { MyVecManualFrom::from_value(&opt_value).0 }
+    );
+    assert_eq!(
+        unsafe {
+            Option::<String>::from_value(&my_vec_manual_from_value)
+                .into_iter()
+                .collect::<Vec<_>>()
+        },
+        unsafe { MyVecManualFrom::from_value(&my_vec_manual_from_value).0 }
+    );
+}