glib-macros: use a common gen_enum_from_glib fn

Signed-off-by: Marc-André Lureau <[email protected]>

Author: elmarco

Diff for: glib-macros/src/genum_derive.rs

@@ -6,26 +6,9 @@ use proc_macro_error::abort_call_site;
 use quote::{format_ident, quote, quote_spanned};
 use syn::{punctuated::Punctuated, spanned::Spanned, token::Comma, Data, Ident, Variant};
 
-use crate::utils::{crate_ident_new, parse_item_attributes, parse_type_name, ItemAttribute};
-
-// Generate i32 to enum mapping, used to implement glib::translate::FromGlib<i32>, such as:
-//   if value == Animal::Goat as i32 {
-//       return Animal::Goat;
-//   }
-fn gen_from_glib(enum_name: &Ident, enum_variants: &Punctuated<Variant, Comma>) -> TokenStream {
-    // FIXME: can we express this with a match()?
-    let recurse = enum_variants.iter().map(|v| {
-        let name = &v.ident;
-        quote_spanned! {v.span()=>
-            if value == #enum_name::#name as i32 {
-                return #enum_name::#name;
-            }
-        }
-    });
-    quote! {
-        #(#recurse)*
-    }
-}
+use crate::utils::{
+    crate_ident_new, gen_enum_from_glib, parse_item_attributes, parse_type_name, ItemAttribute,
+};
 
 // Generate glib::gobject_ffi::GEnumValue structs mapping the enum such as:
 //     glib::gobject_ffi::GEnumValue {
@@ -100,7 +83,7 @@ pub fn impl_genum(input: &syn::DeriveInput) -> TokenStream {
         ),
     };
     let get_type = format_ident!("{}_get_type", name.to_string().to_snake_case());
-    let from_glib = gen_from_glib(name, enum_variants);
+    let from_glib = gen_enum_from_glib(name, enum_variants);
     let (genum_values, nb_genum_values) = gen_genum_values(name, enum_variants);
 
     quote! {
@@ -112,10 +95,23 @@ pub fn impl_genum(input: &syn::DeriveInput) -> TokenStream {
             }
         }
 
+        impl #crate_ident::translate::TryFromGlib<i32> for #name {
+            type Error = i32;
+
+            fn try_from_glib(value: i32) -> Result<Self, i32> {
+                let from_glib = || {
+                    #from_glib
+                };
+
+                from_glib().ok_or(value)
+            }
+        }
+
         impl #crate_ident::translate::FromGlib<i32> for #name {
             unsafe fn from_glib(value: i32) -> Self {
-                #from_glib
-                unreachable!();
+                use #crate_ident::translate::TryFromGlib;
+
+                Self::try_from_glib(value).unwrap()
             }
         }
 

Diff for: glib-macros/src/gerror_domain_derive.rs

@@ -2,29 +2,10 @@
 
 use proc_macro2::TokenStream;
 use proc_macro_error::abort_call_site;
-use quote::{quote, quote_spanned};
-use syn::{punctuated::Punctuated, spanned::Spanned, token::Comma, Data, Ident, Variant};
+use quote::quote;
+use syn::Data;
 
-use crate::utils::{crate_ident_new, parse_name};
-
-// FIXME: merge with genum version
-fn gen_enum_from_glib(
-    enum_name: &Ident,
-    enum_variants: &Punctuated<Variant, Comma>,
-) -> TokenStream {
-    // FIXME: can we express this with a match()?
-    let recurse = enum_variants.iter().map(|v| {
-        let name = &v.ident;
-        quote_spanned! {v.span()=>
-            if code == #enum_name::#name as i32 {
-                return Some(#enum_name::#name);
-            }
-        }
-    });
-    quote! {
-        #(#recurse)*
-    }
-}
+use crate::utils::{crate_ident_new, gen_enum_from_glib, parse_name};
 
 pub fn impl_gerror_domain(input: &syn::DeriveInput) -> TokenStream {
     let name = &input.ident;
@@ -61,12 +42,11 @@ pub fn impl_gerror_domain(input: &syn::DeriveInput) -> TokenStream {
                 self as i32
             }
 
-            fn from(code: i32) -> Option<Self>
+            fn from(value: i32) -> Option<Self>
             where
                 Self: Sized
             {
                 #from_glib
-                None
             }
         }
     }

Diff for: glib-macros/src/utils.rs

@@ -1,9 +1,13 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 use anyhow::{bail, Result};
-use proc_macro2::{Ident, Span};
+use proc_macro2::{Ident, Span, TokenStream};
 use proc_macro_crate::crate_name;
-use syn::{Attribute, DeriveInput, Lit, Meta, MetaList, NestedMeta};
+use quote::{quote, quote_spanned};
+use syn::{
+    punctuated::Punctuated, spanned::Spanned, token::Comma, Attribute, DeriveInput, Lit, Meta,
+    MetaList, NestedMeta, Variant,
+};
 
 // find the #[@attr_name] attribute in @attrs
 pub fn find_attribute_meta(attrs: &[Attribute], attr_name: &str) -> Result<Option<MetaList>> {
@@ -156,3 +160,28 @@ pub fn crate_ident_new() -> Ident {
 
     Ident::new(&crate_name, Span::call_site())
 }
+
+// Generate i32 to enum mapping, used to implement
+// glib::translate::TryFromGlib<i32>, such as:
+//
+//   if value == Animal::Goat as i32 {
+//       return Some(Animal::Goat);
+//   }
+pub fn gen_enum_from_glib(
+    enum_name: &Ident,
+    enum_variants: &Punctuated<Variant, Comma>,
+) -> TokenStream {
+    // FIXME: can we express this with a match()?
+    let recurse = enum_variants.iter().map(|v| {
+        let name = &v.ident;
+        quote_spanned! { v.span() =>
+            if value == #enum_name::#name as i32 {
+                return Some(#enum_name::#name);
+            }
+        }
+    });
+    quote! {
+        #(#recurse)*
+        None
+    }
+}