Refactor and improve error msg

Author: Serock3

mullvad-types/intersection-derive/src/lib.rs

@@ -3,47 +3,60 @@
 extern crate proc_macro;
 
 use proc_macro::TokenStream;
-use proc_macro2::TokenStream as TokenStream2;
-use quote::{quote, TokenStreamExt};
-use syn::{parse_macro_input, spanned::Spanned, DeriveInput, Error};
+use syn::{parse_macro_input, DeriveInput};
 
 /// Derive macro for the [`Intersection`] trait on structs.
 #[proc_macro_derive(Intersection)]
 pub fn intersection_derive(item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as DeriveInput);
 
-    match &input.data {
-        syn::Data::Struct(data) => derive_for_struct(&input, data),
-        syn::Data::Enum(_) => todo!(),
-        syn::Data::Union(_) => todo!(),
-    }
-    .unwrap_or_else(Error::into_compile_error)
-    .into()
+    inner::derive(input).into()
 }
 
-fn derive_for_struct(input: &DeriveInput, data: &syn::DataStruct) -> syn::Result<TokenStream2> {
-    let my_type = &input.ident;
-    let mut field_conversions = quote! {};
-    for field in &data.fields {
-        let Some(name) = &field.ident else {
-            return Err(syn::Error::new(
-                field.span(),
-                "Tuple structs are not currently supported",
-            ));
-        };
-
-        field_conversions.append_all(quote! {
-            #name: Intersection::intersection(self.#name, other.#name)?,
-        })
+mod inner {
+    use proc_macro2::TokenStream;
+    use quote::{quote, TokenStreamExt};
+    use syn::{spanned::Spanned, DeriveInput, Error};
+
+    pub(crate) fn derive(input: DeriveInput) -> TokenStream {
+        if let syn::Data::Struct(data) = &input.data {
+            derive_for_struct(&input, data).unwrap_or_else(Error::into_compile_error)
+        } else {
+            syn::Error::new(
+                input.span(),
+                "Deriving `Intersection` is only supported for structs",
+            )
+            .into_compile_error()
+        }
     }
 
-    Ok(quote! {
-        impl Intersection for #my_type {
-            fn intersection(self, other: Self) -> ::core::option::Option<Self> {
-                ::core::option::Option::Some(Self {
-                    #field_conversions
-                })
-            }
+    pub(crate) fn derive_for_struct(
+        input: &DeriveInput,
+        data: &syn::DataStruct,
+    ) -> syn::Result<TokenStream> {
+        let my_type = &input.ident;
+        let mut field_conversions = quote! {};
+        for field in &data.fields {
+            let Some(name) = &field.ident else {
+                return Err(syn::Error::new(
+                    field.span(),
+                    "Tuple structs are not currently supported",
+                ));
+            };
+
+            field_conversions.append_all(quote! {
+                #name: Intersection::intersection(self.#name, other.#name)?,
+            })
         }
-    })
+
+        Ok(quote! {
+            impl Intersection for #my_type {
+                fn intersection(self, other: Self) -> ::core::option::Option<Self> {
+                    ::core::option::Option::Some(Self {
+                        #field_conversions
+                    })
+                }
+            }
+        })
+    }
 }