feat: v2.0.0

Author: eastspire

debug/src/main.rs

@@ -1,5 +1,5 @@
 use lombok_macros::*;
-use std::fmt::Debug;
+use std::{f64::consts::PI, fmt::Debug};
 
 #[derive(Data, Debug, Clone, DisplayDebugFormat)]
 struct LombokTest<'a, T: Clone + Debug> {
@@ -121,9 +121,9 @@ struct ComplexNestedStruct {
 
 #[derive(CustomDebug)]
 enum ComplexEnum {
-    SimpleVariant,
-    TupleVariant(String, i32),
-    StructVariant {
+    Simple,
+    Tuple(String, i32),
+    Struct {
         field1: String,
         #[debug(skip)]
         _secret: String,
@@ -181,7 +181,6 @@ struct MultiAttributes {
     complex_field: Vec<String>,
 }
 
-#[test]
 fn main() {
     let mut data: LombokTest<usize> = LombokTest {
         list: Vec::new(),
@@ -300,17 +299,17 @@ fn main() {
     assert_eq!(complex.get_nested().get_name(), "inner");
     assert_eq!(complex.get_nested_list().len(), 1);
     assert_eq!(complex.get_metadata().get("key").unwrap(), "value");
-    let simple = ComplexEnum::SimpleVariant;
-    let tuple = ComplexEnum::TupleVariant("test".to_string(), 123);
-    let struct_variant = ComplexEnum::StructVariant {
+    let simple = ComplexEnum::Simple;
+    let tuple = ComplexEnum::Tuple("test".to_string(), 123);
+    let struct_variant = ComplexEnum::Struct {
         field1: "visible".to_string(),
         _secret: "hidden".to_string(),
-        value: 3.14,
+        value: PI,
     };
     let simple_debug = format!("{simple:?}");
     let tuple_debug = format!("{tuple:?}");
     let struct_debug = format!("{struct_variant:?}");
-    assert!(simple_debug.contains("SimpleVariant"));
+    assert!(simple_debug.contains("Simple"));
     assert!(tuple_debug.contains("test"));
     assert!(tuple_debug.contains("123"));
     assert!(struct_debug.contains("visible"));

src/parse/fn.rs

@@ -29,10 +29,8 @@ pub(crate) fn parse_tokens(tokens: TokenStream2, config: &mut Config) {
                     config.visibility = Visibility::PublicCrate;
                 } else if ident_str == PUBLIC_SUPER && config.visibility.is_public() {
                     config.visibility = Visibility::PublicSuper;
-                } else if ReturnType::is_known(&ident_str) {
-                    if config.return_type.is_default() {
-                        config.return_type = ident_str.parse::<ReturnType>().unwrap_or_default();
-                    }
+                } else if ReturnType::is_known(&ident_str) && config.return_type.is_default() {
+                    config.return_type = ident_str.parse::<ReturnType>().unwrap_or_default();
                 }
             }
             TokenTree2::Group(group) => {

tests/comprehensive_reference_clone_test.rs

@@ -2,38 +2,27 @@ use lombok_macros::*;
 
 #[derive(Getter, Clone)]
 struct ComprehensiveTestStruct {
-    // Basic types
     #[get(pub, reference)]
     name_ref: String,
-
     #[get(pub, clone)]
     name_clone: String,
-
-    // Option types
     #[get(pub, reference)]
     optional_string_ref: Option<String>,
-
     #[get(pub, clone)]
     optional_string_clone: Option<String>,
-
-    // Vec types
     #[get(pub, reference)]
     vec_ref: Vec<i32>,
-
     #[get(pub, clone)]
     vec_clone: Vec<i32>,
-
-    // With visibility and other attributes
     #[get(pub(crate), reference)]
     _crate_ref: String,
-
     #[get(private, clone)]
     _private_clone: String,
 }
 
 #[test]
 fn test_comprehensive_reference_clone() {
-    let test = ComprehensiveTestStruct {
+    let test: ComprehensiveTestStruct = ComprehensiveTestStruct {
         name_ref: "reference_name".to_string(),
         name_clone: "clone_name".to_string(),
         optional_string_ref: Some("opt_ref".to_string()),
@@ -43,28 +32,16 @@ fn test_comprehensive_reference_clone() {
         _crate_ref: "crate_reference".to_string(),
         _private_clone: "private_clone".to_string(),
     };
-
-    // Test basic reference returns &String
     let name_ref: &String = test.get_name_ref();
     assert_eq!(*name_ref, "reference_name");
-
-    // Test basic clone returns String
     let name_clone: String = test.get_name_clone();
     assert_eq!(name_clone, "clone_name");
-
-    // Test option reference returns &Option<String>
     let opt_ref: &Option<String> = test.get_optional_string_ref();
     assert_eq!(opt_ref, &Some("opt_ref".to_string()));
-
-    // Test option clone returns Option<String>
     let opt_clone: Option<String> = test.get_optional_string_clone();
     assert_eq!(opt_clone, Some("opt_clone".to_string()));
-
-    // Test vec reference returns &Vec<i32>
     let vec_ref: &Vec<i32> = test.get_vec_ref();
     assert_eq!(vec_ref, &vec![1, 2, 3]);
-
-    // Test vec clone returns Vec<i32>
     let vec_clone: Vec<i32> = test.get_vec_clone();
     assert_eq!(vec_clone, vec![4, 5, 6]);
 }
@@ -73,23 +50,18 @@ fn test_comprehensive_reference_clone() {
 struct TestDefaultBehavior {
     #[get(pub)]
     default_field: String,
-
     #[get(pub)]
     default_option: Option<String>,
 }
 
 #[test]
 fn test_default_behavior() {
-    let test = TestDefaultBehavior {
+    let test: TestDefaultBehavior = TestDefaultBehavior {
         default_field: "default".to_string(),
         default_option: Some("option_default".to_string()),
     };
-
-    // Default should return reference for non-Option types
     let default_ref: &String = test.get_default_field();
     assert_eq!(*default_ref, "default");
-
-    // Default should return inner value for Option types (cloned)
     let default_option: String = test.get_default_option();
     assert_eq!(default_option, "option_default");
 }

tests/reference_clone_test.rs

@@ -4,74 +4,54 @@ use lombok_macros::*;
 struct TestStruct {
     #[get(pub, reference)]
     field_ref: String,
-
     #[get(pub, clone)]
     field_clone: String,
-
     #[get(pub)]
     field_default: String,
-
     #[get(pub, reference)]
     optional_ref: Option<String>,
-
     #[get(pub, clone)]
     optional_clone: Option<String>,
 }
 
 #[test]
 fn test_reference_clone_getters() {
-    let test = TestStruct {
+    let test: TestStruct = TestStruct {
         field_ref: "reference_field".to_string(),
         field_clone: "clone_field".to_string(),
         field_default: "default_field".to_string(),
         optional_ref: Some("optional_ref".to_string()),
         optional_clone: Some("optional_clone".to_string()),
     };
-
-    // Test reference getter - should return &String
     let ref_result: &String = test.get_field_ref();
     assert_eq!(*ref_result, "reference_field");
-
-    // Test clone getter - should return String
     let clone_result: String = test.get_field_clone();
     assert_eq!(clone_result, "clone_field");
-
-    // Test default getter - should return &String (default behavior for non-Option)
     let default_result: &String = test.get_field_default();
     assert_eq!(*default_result, "default_field");
-
-    // Test reference getter for Option - should return &Option<String>
     let opt_ref_result: &Option<String> = test.get_optional_ref();
     assert_eq!(opt_ref_result, &Some("optional_ref".to_string()));
-
-    // Test clone getter for Option - should return Option<String>
     let opt_clone_result: Option<String> = test.get_optional_clone();
     assert_eq!(opt_clone_result, Some("optional_clone".to_string()));
 }
 
 #[test]
 fn test_return_type_behavior() {
-    let test = TestStruct {
+    let test: TestStruct = TestStruct {
         field_ref: "test".to_string(),
         field_clone: "test".to_string(),
         field_default: "test".to_string(),
         optional_ref: Some("test".to_string()),
         optional_clone: Some("test".to_string()),
     };
-
-    // Verify reference returns work correctly
-    let ref_val = test.get_field_ref();
-    let same_ref_val = test.get_field_ref();
-    // Both should point to the same underlying data
+    let ref_val: &String = test.get_field_ref();
+    let same_ref_val: &String = test.get_field_ref();
     assert!(std::ptr::eq(ref_val, same_ref_val));
-
-    // Verify clone returns work correctly
-    let clone_val1 = test.get_field_clone();
-    let clone_val2 = test.get_field_clone();
-    // These should be different owned values
+    let clone_val1: String = test.get_field_clone();
+    let clone_val2: String = test.get_field_clone();
     assert_ne!(
         std::ptr::addr_of!(clone_val1),
         std::ptr::addr_of!(clone_val2)
     );
-    assert_eq!(clone_val1, clone_val2); // But have the same content
+    assert_eq!(clone_val1, clone_val2);
 }