move the validation to separate function

Author: gotocoding-DB

derive-macros/src/lib.rs

@@ -119,39 +119,8 @@ fn gen_schema_fields(data: &Data) -> TokenStream {
                     }
                 });
                 if have_schema_null {
-                    // Check if the type is HashMap or Option<HashMap>
-                    let last_segment = type_path.path.segments.last();
-                    let is_valid = if let Some(seg) = last_segment {
-                        let last_ident = &seg.ident;
-                        if last_ident == "HashMap" {
-                            true
-                        } else if last_ident == "Option" {
-                            // Check if Option wraps HashMap
-                            if let PathArguments::AngleBracketed(args) = &seg.arguments {
-                                args.args.iter().any(|arg| {
-                                    if let syn::GenericArgument::Type(Type::Path(inner_path)) = arg {
-                                        inner_path.path.segments.last().map(|s| &s.ident) == Some(&syn::Ident::new("HashMap", Span::call_site()))
-                                    } else {
-                                        false
-                                    }
-                                })
-                            } else {
-                                false
-                            }
-                        } else {
-                            false
-                        }
-                    } else {
-                        false
-                    };
-
-                    if !is_valid {
-                        if let Some(last_ident) = last_segment.map(|seg| &seg.ident) {
-                            return Error::new(
-                                last_ident.span(),
-                                format!("Can only use allow_null_container_values on HashMap fields, not {last_ident}")
-                            ).to_compile_error()
-                        }
+                    if let Err(err) = validate_null_container_values(type_path) {
+                        return err.to_compile_error();
                     }
                     quote_spanned! { field.span() => #(#type_path_quoted)* get_nullable_container_struct_field(stringify!(#name))}
                 } else {
@@ -280,3 +249,42 @@ fn make_public(mut item: Item) -> Item {
 
     item
 }
+
+/// We allow only `HashMap` and `Option<HashMap>` to have `allow_null_container_values` set.
+fn validate_null_container_values(type_path: &syn::TypePath) -> Result<(), syn::Error> {
+    let last = type_path.path.segments.last();
+    match last.map(|seg| seg.ident.to_string()).as_deref() {
+        Some("HashMap") => Ok(()),
+        Some("Option") => {
+            if let Some(syn::PathArguments::AngleBracketed(args)) = last.map(|s| &s.arguments) {
+                if let Some(syn::GenericArgument::Type(syn::Type::Path(inner))) = args.args.first()
+                {
+                    let inner_ident = inner
+                        .path
+                        .segments
+                        .last()
+                        .map(|s| s.ident.to_string())
+                        .unwrap_or_else(|| "Unknown".to_string());
+                    if inner_ident == "HashMap" {
+                        return Ok(());
+                    }
+                    return Err(syn::Error::new(
+                        args.span(),
+                        format!(
+                            "Can only use allow_null_container_values on Option<HashMap> fields, not Option<{}>",
+                            inner_ident,
+                        ),
+                    ));
+                }
+            }
+            Err(syn::Error::new(
+                type_path.span(),
+                "Can only use allow_null_container_values on Option<HashMap> fields",
+            ))
+        }
+        _ => Err(syn::Error::new(
+            type_path.span(),
+            "Can only use allow_null_container_values on HashMap fields or Option<HashMap> fields",
+        )),
+    }
+}