Merge pull request #565 from arcnmx/variant-asref

glib: impl AsRef<Variant> for Variant

Author: sdroege

glib-macros/src/variant_derive.rs

@@ -35,6 +35,7 @@ pub fn derive_variant_for_struct(
                 .collect::<Vec<_>>();
 
             let idents = (0..types.len()).map(syn::Index::from).collect::<Vec<_>>();
+            let idents_len = idents.len();
 
             let static_variant_type = quote! {
                 impl #generics #glib::StaticVariantType for #ident #generics {
@@ -62,7 +63,7 @@ pub fn derive_variant_for_struct(
             let to_variant = quote! {
                 impl #generics #glib::ToVariant for #ident #generics {
                     fn to_variant(&self) -> #glib::Variant {
-                        #glib::Variant::tuple_from_iter(::std::array::IntoIter::new([
+                        #glib::Variant::tuple_from_iter(::std::array::IntoIter::<#glib::Variant, #idents_len>::new([
                             #(
                                 #glib::ToVariant::to_variant(&self.#idents)
                             ),*

glib/src/variant.rs

@@ -439,7 +439,7 @@ impl Variant {
     ///
     /// This function panics if not all variants are of type `type_`.
     #[doc(alias = "g_variant_new_array")]
-    pub fn array_from_iter_with_type<I: IntoIterator<Item = Variant>>(
+    pub fn array_from_iter_with_type<T: AsRef<Variant>, I: IntoIterator<Item = T>>(
         type_: &VariantTy,
         children: I,
     ) -> Self {
@@ -448,6 +448,7 @@ impl Variant {
             ffi::g_variant_builder_init(builder.as_mut_ptr(), type_.as_array().to_glib_none().0);
             let mut builder = builder.assume_init();
             for value in children.into_iter() {
+                let value = value.as_ref();
                 if ffi::g_variant_is_of_type(value.to_glib_none().0, type_.to_glib_none().0)
                     == ffi::GFALSE
                 {
@@ -480,13 +481,13 @@ impl Variant {
     // rustdoc-stripper-ignore-next
     /// Creates a new Variant tuple from children.
     #[doc(alias = "g_variant_new_tuple")]
-    pub fn tuple_from_iter(children: impl IntoIterator<Item = Variant>) -> Self {
+    pub fn tuple_from_iter(children: impl IntoIterator<Item = impl AsRef<Variant>>) -> Self {
         unsafe {
             let mut builder = mem::MaybeUninit::uninit();
             ffi::g_variant_builder_init(builder.as_mut_ptr(), VariantTy::TUPLE.to_glib_none().0);
             let mut builder = builder.assume_init();
             for value in children.into_iter() {
-                ffi::g_variant_builder_add_value(&mut builder, value.to_glib_none().0);
+                ffi::g_variant_builder_add_value(&mut builder, value.as_ref().to_glib_none().0);
             }
             from_glib_none(ffi::g_variant_builder_end(&mut builder))
         }
@@ -881,6 +882,12 @@ impl Hash for Variant {
     }
 }
 
+impl AsRef<Variant> for Variant {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
 // rustdoc-stripper-ignore-next
 /// Converts to `Variant`.
 pub trait ToVariant {