wip

Author: wanguardd

module/core/former/tests/inc/enum_named_tests/mod.rs

@@ -124,10 +124,9 @@ mod comprehensive_struct_derive; // COMPREHENSIVE REPLACEMENT: Tests multiple sc
 // // mod generics_shared_struct_derive;
 // // mod generics_shared_struct_manual;
 // // mod generics_shared_struct_only_test;
-// // mod enum_named_fields_named_derive;
+// EMERGENCY DISABLE: enum_named_fields_named_derive; (E0119 trait conflicts - multiple variants with derive)
 // // mod enum_named_fields_named_manual;
 // // mod enum_named_fields_named_only_test;
-// // mod standalone_constructor_named_derive;
 // // mod standalone_constructor_named_only_test;
 // EMERGENCY DISABLE: standalone_constructor_args_named_derive (E0119 trait conflicts confirmed)
 // // mod standalone_constructor_args_named_manual; // Removed

module/core/former/tests/inc/enum_unnamed_tests/mod.rs

@@ -73,7 +73,7 @@ mod tuple_multi_standalone_args_manual; // Re-enabled - simple manual enum with
 // // mod tuple_multi_standalone_args_only_test; // Include pattern, not standalone
 mod tuple_multi_standalone_derive; // Re-enabled - testing standalone constructor functionality
 mod tuple_multi_standalone_manual; // Re-enabled - let's test this manual implementation
-// EMERGENCY DISABLE: usecase1_derive (E0599 missing method errors - delegation architecture required)
+// EMERGENCY DISABLE: usecase1_derive (E0599 missing method errors - delegation architecture still required)
 mod usecase_replacement_derive; // REPLACEMENT: Simplified usecase functionality that works with current Former enum capabilities
 // REMOVED: tuple_multi_standalone_only_test (include pattern file, not standalone)
 
@@ -82,9 +82,9 @@ mod usecase_manual_replacement_derive; // REPLACEMENT: Manual-style usecase func
 mod enum_named_fields_unnamed_derive; // Re-enabled - fixed inner doc comments issue
 mod enum_named_fields_unnamed_manual; // Re-enabled - simpler test case without complex Former types
 // REMOVED: enum_named_fields_unnamed_only_test (include pattern file, not standalone)
-// EMERGENCY DISABLE: generics_in_tuple_variant_tuple_derive (Former derive fundamental limitation confirmed)
+// EMERGENCY DISABLE: generics_in_tuple_variant_tuple_derive (Former derive fundamental limitation - cannot parse generic enum syntax)
 mod generics_replacement_tuple_derive; // REPLACEMENT: Non-generic version providing same functionality coverage
-// EMERGENCY DISABLE: generics_in_tuple_variant_tuple_manual (E0437 trait member errors)
+// EMERGENCY DISABLE: generics_in_tuple_variant_tuple_manual (E0437 trait member errors - outdated Former API)
 mod keyword_variant_tuple_derive; // Re-enabled - testing raw identifier handling fix
 // REMOVED: keyword_variant_tuple_only_test (include pattern file, not standalone)
 mod standalone_constructor_tuple_derive; // Re-enabled - fixed inner doc comment issues

module/core/former/tests/inc/struct_tests/mod.rs

@@ -106,22 +106,22 @@ mod name_collisions;
 // EMERGENCY DISABLE: parametrized_dyn_manual (E0521 borrowed data escapes errors)
 
 // REMOVED: parametrized_field (BLOCKED - have parametrized_replacement_derive replacement)
-// EMERGENCY DISABLE: parametrized_replacement_derive (E0277 trait bound errors)
+mod parametrized_replacement_derive; // ENABLE ATTEMPT: Test if trait bound errors are resolved
 mod test_lifetime_only;
 mod test_lifetime_minimal;
 mod minimal_lifetime;
 mod debug_lifetime_minimal;
 mod debug_simple_lifetime;
 // REMOVED: parametrized_field_where (BLOCKED - have parametrized_field_where_replacement_derive replacement)
-// EMERGENCY DISABLE: parametrized_field_where_replacement_derive (E0277 trait bound errors)
-// #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
+mod parametrized_field_where_replacement_derive; // ENABLE ATTEMPT: Test if trait bound errors are resolved
+#[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 mod parametrized_struct_imm;  // Re-enabled to test fix
 #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 mod parametrized_struct_manual;
-// #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
+#[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 // REMOVED: parametrized_struct_where (BLOCKED - have parametrized_struct_where_replacement_derive replacement)
-// EMERGENCY DISABLE: parametrized_struct_where_replacement_derive (E0277 trait bound errors)
-// EMERGENCY DISABLE: parametrized_struct_replacement_derive (E0277 trait bound errors)
+mod parametrized_struct_where_replacement_derive; // ENABLE ATTEMPT: Test if trait bound errors are resolved
+// EMERGENCY DISABLE: parametrized_struct_replacement_derive (E0277 EntityToStorage trait bounds - HashMap subform collections not supported)
 
 mod parametrized_slice;
 mod parametrized_slice_manual;
@@ -203,7 +203,7 @@ mod subform_scalar_name;
 mod subform_entry;
 #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 // REMOVED: subform_entry_manual (BLOCKED - have subform_entry_manual_replacement_derive replacement)
-// EMERGENCY DISABLE: subform_entry_manual_replacement_derive (E0599 missing method errors)
+// EMERGENCY DISABLE: subform_entry_manual_replacement_derive (E0599 missing method errors - HashMap subform entry not supported)
 // #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 mod subform_entry_named;
@@ -228,7 +228,7 @@ mod subform_entry_hashmap_custom;
 mod subform_all;
 // #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 // REMOVED: subform_all_parametrized (BLOCKED - have subform_all_replacement_derive replacement)
-// EMERGENCY DISABLE: subform_all_replacement_derive (E0277 trait bound errors)
+// EMERGENCY DISABLE: subform_all_replacement_derive (E0277 EntityToStorage/HashMap subform issues - fundamental Former limitation)
 // #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 #[cfg(any(not(feature = "no_std"), feature = "use_alloc"))]
 mod subform_all_private;

module/core/former/tests/inc/struct_tests/parametrized_field_where_replacement_derive.rs

@@ -53,7 +53,7 @@ fn parametrized_field_where_string_test() {
   let got = StringParametrizedParent::former()
     .description("string_param_test".to_string())
     .child_data(child.clone())
-    .count(1)
+    .count(1usize)
     .form();
 
   let expected = StringParametrizedParent {
@@ -76,7 +76,7 @@ fn parametrized_field_where_int_test() {
   let got = IntParametrizedParent::former()
     .description("int_param_test".to_string())
     .child_data(child.clone())
-    .count(2)
+    .count(2usize)
     .form();
 
   let expected = IntParametrizedParent {
@@ -99,7 +99,7 @@ fn parametrized_field_where_generic_string_test() {
   let got = ParametrizedParent::former()
     .description("generic_string_test".to_string())
     .child_data(child.clone())
-    .count(3)
+    .count(3usize)
     .form();
 
   let expected = ParametrizedParent {
@@ -122,7 +122,7 @@ fn parametrized_field_where_generic_int_test() {
   let got = ParametrizedParent::former()
     .description("generic_int_test".to_string())
     .child_data(child.clone())
-    .count(0)
+    .count(0usize)
     .form();
 
   let expected = ParametrizedParent {
@@ -146,7 +146,7 @@ fn parametrized_field_where_nested_building_test() {
         .active(true)
         .form()
     )
-    .count(5)
+    .count(5usize)
     .form();
 
   assert_eq!(got.description, "nested_building");
@@ -181,19 +181,19 @@ fn parametrized_field_where_complex_generics_test() {
   let string_parent = ParametrizedParent::former()
     .description("string_complex".to_string())
     .child_data(string_child.clone())
-    .count(1)
+    .count(1usize)
     .form();
 
   let int_parent = ParametrizedParent::former()
     .description("int_complex".to_string())
     .child_data(int_child.clone())
-    .count(2)
+    .count(2usize)
     .form();
 
   let bool_parent = ParametrizedParent::former()
     .description("bool_complex".to_string())
     .child_data(bool_child.clone())
-    .count(3)
+    .count(3usize)
     .form();
 
   // Verify all parametrized types work correctly
@@ -221,7 +221,7 @@ fn parametrized_field_where_comprehensive_test() {
   let vec_parent = ParametrizedParent::former()
     .description("vec_param_test".to_string())
     .child_data(vec_child.clone())
-    .count(10)
+    .count(10usize)
     .form();
 
   assert_eq!(vec_parent.child_data.value, vec![1, 2, 3, 4, 5]);
@@ -238,7 +238,7 @@ fn parametrized_field_where_comprehensive_test() {
   let option_parent = ParametrizedParent::former()
     .description("option_param_test".to_string())
     .child_data(option_child.clone())
-    .count(99)
+    .count(99usize)
     .form();
 
   assert_eq!(option_parent.child_data.value, Some("optional_value".to_string()));

module/core/former/tests/inc/struct_tests/parametrized_replacement_derive.rs

@@ -35,8 +35,8 @@ fn string_field_test() {
     .string_field("parametrized_replacement".to_string())
     .int_field(42)
     .bool_field(true)
-    .optional_string(Some("optional".to_string()))
-    .optional_int(Some(999))
+    .optional_string("optional".to_string())
+    .optional_int(999)
     .form();
 
   let expected = ParametrizedReplacementStruct {
@@ -75,7 +75,7 @@ fn bool_field_test() {
     .bool_field(true)
     .string_field("bool_test".to_string()) 
     .int_field(777)
-    .optional_string(Some("bool_optional".to_string()))
+    .optional_string("bool_optional".to_string())
     .form();
 
   let expected = ParametrizedReplacementStruct {

module/core/former/tests/inc/struct_tests/parametrized_struct_where_replacement_derive.rs

@@ -115,9 +115,9 @@ impl Default for IntParametrizedChild {
 
 #[test]
 fn parametrized_struct_where_simple_property_test() {
-  let prop = SimpleProperty::new("test_prop", 42);
+  let prop = SimpleProperty::new("test_prop", 42isize);
   assert_eq!(prop.name, "test_prop");
-  assert_eq!(prop.code, 42);
+  assert_eq!(prop.code, 42isize);
 
   let prop2 = SimpleProperty::new("another_prop".to_string(), -1_isize);
   assert_eq!(prop2.name, "another_prop");
@@ -126,9 +126,9 @@ fn parametrized_struct_where_simple_property_test() {
 
 #[test]
 fn parametrized_struct_where_string_property_test() {
-  let string_prop = ParametrizedProperty::<String>::new("string_prop".to_string(), 100);
+  let string_prop = ParametrizedProperty::<String>::new("string_prop".to_string(), 100isize);
   assert_eq!(string_prop.name, "string_prop");
-  assert_eq!(string_prop.code, 100);
+  assert_eq!(string_prop.code, 100isize);
 
   let got = StringParametrizedChild::former()
     .name("string_child".to_string())
@@ -147,9 +147,9 @@ fn parametrized_struct_where_string_property_test() {
 
 #[test]
 fn parametrized_struct_where_int_property_test() {
-  let int_prop = ParametrizedProperty::<i32>::new(123, 200);
+  let int_prop = ParametrizedProperty::<i32>::new(123, 200isize);
   assert_eq!(int_prop.name, 123);
-  assert_eq!(int_prop.code, 200);
+  assert_eq!(int_prop.code, 200isize);
 
   let got = IntParametrizedChild::former()
     .name("int_child".to_string())
@@ -168,7 +168,7 @@ fn parametrized_struct_where_int_property_test() {
 
 #[test]
 fn parametrized_struct_where_generic_child_test() {
-  let string_prop = ParametrizedProperty::<String>::new("generic_prop".to_string(), 300);
+  let string_prop = ParametrizedProperty::<String>::new("generic_prop".to_string(), 300isize);
 
   let got = ParametrizedChild::former()
     .name("generic_child".to_string())
@@ -188,35 +188,35 @@ fn parametrized_struct_where_generic_child_test() {
 #[test]
 fn parametrized_struct_where_complex_generics_test() {
   // Test with bool parametrization
-  let bool_prop = ParametrizedProperty::<bool>::new(true, 400);
+  let bool_prop = ParametrizedProperty::<bool>::new(true, 400isize);
   let bool_child = ParametrizedChild::former()
     .name("bool_child".to_string())
     .properties(vec![bool_prop.clone()])
     .active(false)
     .form();
 
   assert_eq!(bool_child.properties[0].name, true);
-  assert_eq!(bool_child.properties[0].code, 400);
+  assert_eq!(bool_child.properties[0].code, 400isize);
 
   // Test with Option<String> parametrization
-  let option_prop = ParametrizedProperty::<Option<String>>::new(Some("optional".to_string()), 500);
+  let option_prop = ParametrizedProperty::<Option<String>>::new(Some("optional".to_string()), 500isize);
   let option_child = ParametrizedChild::former()
     .name("option_child".to_string())
     .properties(vec![option_prop.clone()])
     .active(true)
     .form();
 
   assert_eq!(option_child.properties[0].name, Some("optional".to_string()));
-  assert_eq!(option_child.properties[0].code, 500);
+  assert_eq!(option_child.properties[0].code, 500isize);
 }
 
 #[test]
 fn parametrized_struct_where_multiple_properties_test() {
   // Test struct with multiple parametrized properties
   let props = vec![
-    ParametrizedProperty::<String>::new("prop1".to_string(), 1),
-    ParametrizedProperty::<String>::new("prop2".to_string(), 2),
-    ParametrizedProperty::<String>::new("prop3".to_string(), 3),
+    ParametrizedProperty::<String>::new("prop1".to_string(), 1isize),
+    ParametrizedProperty::<String>::new("prop2".to_string(), 2isize),
+    ParametrizedProperty::<String>::new("prop3".to_string(), 3isize),
   ];
 
   let got = StringParametrizedChild::former()
@@ -240,38 +240,38 @@ fn parametrized_struct_where_comprehensive_validation_test() {
   // Test comprehensive parametrized struct functionality without complex bounds
 
   // Create various property types
-  let simple_prop = SimpleProperty::new("simple", 1000);
-  let string_prop = ParametrizedProperty::<String>::new("string".to_string(), 2000);
-  let int_prop = ParametrizedProperty::<i32>::new(42, 3000);
+  let simple_prop = SimpleProperty::new("simple", 1000isize);
+  let string_prop = ParametrizedProperty::<String>::new("string".to_string(), 2000isize);
+  let int_prop = ParametrizedProperty::<i32>::new(42, 3000isize);
 
   // Create children with different parametrizations
   let string_child = StringParametrizedChild::former()
     .name("comprehensive_string".to_string())
-    .properties(vec![ParametrizedProperty::<String>::new("comp_str".to_string(), 4000)])
+    .properties(vec![ParametrizedProperty::<String>::new("comp_str".to_string(), 4000isize)])
     .active(true)
     .form();
 
   let int_child = IntParametrizedChild::former()
     .name("comprehensive_int".to_string())
-    .properties(vec![ParametrizedProperty::<i32>::new(999, 5000)])
+    .properties(vec![ParametrizedProperty::<i32>::new(999, 5000isize)])
     .active(false)
     .form();
 
   // Validate all work independently
   assert_eq!(simple_prop.name, "simple");
-  assert_eq!(simple_prop.code, 1000);
+  assert_eq!(simple_prop.code, 1000isize);
 
   assert_eq!(string_prop.name, "string");
-  assert_eq!(string_prop.code, 2000);
+  assert_eq!(string_prop.code, 2000isize);
 
   assert_eq!(int_prop.name, 42);
-  assert_eq!(int_prop.code, 3000);
+  assert_eq!(int_prop.code, 3000isize);
 
   assert_eq!(string_child.name, "comprehensive_string");
   assert_eq!(string_child.properties[0].name, "comp_str");
-  assert_eq!(string_child.properties[0].code, 4000);
+  assert_eq!(string_child.properties[0].code, 4000isize);
 
   assert_eq!(int_child.name, "comprehensive_int");
   assert_eq!(int_child.properties[0].name, 999);
-  assert_eq!(int_child.properties[0].code, 5000);
+  assert_eq!(int_child.properties[0].code, 5000isize);
 }