rocketmq-macros/src/lib.rs (3)

Line range hint 94-146: Consider simplifying the nested type checking logic.

While the implementation is correct, the readability could be improved by:

1. Using pattern matching instead of nested if-let chains
2. Following Rust comment conventions (using // for single-line comments)

Consider this refactoring:

 fn is_struct_type(ty: &Type) -> bool {
-    // Check if the type is a path (i.e., a named type)
     if let Type::Path(TypePath { path, .. }) = ty {
-        // Check if the type is Option<T>
-        if let Some(segment) = path.segments.first() {
-            // If it's Option, check its generic argument
-            if segment.ident == "Option" {
-                if let syn::PathArguments::AngleBracketed(ref args) = &segment.arguments {
-                    // Extract the first argument (T) inside Option
-                    if let Some(syn::GenericArgument::Type(inner_ty)) = args.args.first() {
-                        // Recursively check the inner type, if it's not basic or String, return
-                        // true
-                        return !is_basic_or_string_type(inner_ty);
-                    }
-                }
-            }
+        // Handle Option<T> case
+        match path.segments.first() {
+            Some(segment) if segment.ident == "Option" => {
+                match &segment.arguments {
+                    syn::PathArguments::AngleBracketed(args) => {
+                        if let Some(syn::GenericArgument::Type(inner_ty)) = args.args.first() {
+                            return !is_basic_or_string_type(inner_ty);
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
         }

-        // Check the last segment of the path to determine if it's a basic type or String,
-        // CheetahString
         if let Some(_segment) = path.segments.last() {
-            // If it's a basic type or String/CheetahString, return false
-            if is_basic_or_string_type(ty) {
-                return false;
-            }
-
-            // If it's neither basic nor String/CheetahString, it's likely a struct
-            return true;
+            return !is_basic_or_string_type(ty);
         }
     }
-
-    // If none of the conditions match, it's not a struct
     false
 }

---

Line range hint 147-191: Consider optimizing type checking and adding support for more primitive types.

The current implementation could be enhanced by:

1. Using a const array or HashSet for type checking
2. Adding support for isize, usize, char

Consider this optimization:

+use std::collections::HashSet;
+use once_cell::sync::Lazy;
+
+static BASIC_TYPES: Lazy<HashSet<&'static str>> = Lazy::new(|| {
+    vec![
+        "String", "CheetahString",
+        "i8", "i16", "i32", "i64", "isize",
+        "u8", "u16", "u32", "u64", "usize",
+        "f32", "f64",
+        "bool", "char",
+    ].into_iter().collect()
+});

 fn is_basic_or_string_type(ty: &syn::Type) -> bool {
     if let syn::Type::Path(syn::TypePath { path, .. }) = ty {
         if let Some(segment) = path.segments.last() {
-            return segment_ident == "String"
-                || segment_ident == "CheetahString"
-                || segment_ident == "i8"
-                || segment_ident == "i16"
-                || segment_ident == "i32"
-                || segment_ident == "i64"
-                || segment_ident == "u8"
-                || segment_ident == "u16"
-                || segment_ident == "u32"
-                || segment_ident == "u64"
-                || segment_ident == "f32"
-                || segment_ident == "f64"
-                || segment_ident == "bool";
+            return BASIC_TYPES.contains(segment_ident.to_string().as_str());
         }
     }
     false
 }

---

236-279: Consider adding property-based testing.

While the current test coverage is good, consider adding property-based tests using proptest or quickcheck to:

1. Test with randomly generated strings
2. Verify invariants like length preservation

Example addition:

#[cfg(test)]
mod property_tests {
    use super::*;
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn test_snake_to_camel_case_properties(s in "[a-z_]{1,10}") {
            let camel = snake_to_camel_case(&s);
            // Verify no underscores in result
            assert!(!camel.contains('_'));
            // Verify length invariant
            assert!(camel.len() <= s.len());
        }
    }
}

rocketmq-macros/src/request_header_custom.rs (1)

150-245: Consider improving error handling in the FromMap implementation.

The current error handling could be more informative by:

1. Including the actual value that failed to parse
2. Adding context about expected types

Example enhancement:

 .map_err(|_| Self::Error::RemotingCommandError(
-    format!("Parse {} field error", Self::#static_name),
+    format!("Failed to parse {} field: expected {}, got '{}'",
+        Self::#static_name,
+        stringify!(#types),
+        s
+    ),
 ))?

Configuration used: .coderabbit.yaml
Review profile: CHILL