✨ test: update arithmetic operator tests and error handling for mixed types

Author: harehare

crates/mq-check/src/builtin.rs

@@ -1034,26 +1034,21 @@ mod tests {
     }
 
     #[rstest]
-    #[case::add_numbers("1 + 2", true)]
-    #[case::add_strings("\"hello\" + \"world\"", true)]
-    #[case::add_string_number("\"value: \" + 42", true)] // String + number coercion
-    #[case::add_arrays("[1, 2] + [3, 4]", true)] // Array concatenation
-    #[case::add_mixed("1 + \"world\"", false)] // Should fail: type mismatch
-    #[case::sub("10 - 5", true)]
-    #[case::mul("3 * 4", true)]
-    #[case::mul_array_repeat("[1, 2] * 3", true)] // Array repetition
-    #[case::div("10 / 2", true)]
-    #[case::mod_op("10 % 3", true)]
-    #[case::pow("2 ^ 8", true)]
-    fn test_arithmetic_operators(#[case] code: &str, #[case] should_succeed: bool) {
+    #[case::add_numbers("1 + 2")]
+    #[case::add_number_string("1 + \"string\"")]
+    #[case::add_strings("\"hello\" + \"world\"")]
+    #[case::add_string_number("\"value: \" + 42")] // String + number coercion
+    #[case::add_arrays("[1, 2] + [3, 4]")] // Array concatenation
+    #[case::add_mixed("1 + \"world\"")] // Should fail: type mismatch
+    #[case::sub("10 - 5")]
+    #[case::mul("3 * 4")]
+    #[case::mul_array_repeat("[1, 2] * 3")] // Array repetition
+    #[case::div("10 / 2")]
+    #[case::mod_op("10 % 3")]
+    #[case::pow("2 ^ 8")]
+    fn test_arithmetic_operators(#[case] code: &str) {
         let result = check_types(code);
-        assert_eq!(
-            result.is_empty(),
-            should_succeed,
-            "Code: {}\nResult: {:?}",
-            code,
-            result
-        );
+        assert!(result.is_empty(), "Code: {}\nResult: {:?}", code, result);
     }
 
     #[rstest]
@@ -1408,7 +1403,6 @@ mod tests {
 
     // Type Error Cases
     #[rstest]
-    #[case::add_number_string("1 + \"string\"", false)] // number + string is invalid
     #[case::add_bool_number("true + 1", false)] // bool + number is invalid
     #[case::add_bool_string("true + \"s\"", false)] // bool + string is invalid
     #[case::sub_strings("\"a\" - \"b\"", false)] // strings cannot be subtracted

crates/mq-check/tests/error_location_test.rs

@@ -39,37 +39,3 @@ fn test_homogeneous_array_no_error() {
     let errors = check_types(code);
     assert!(errors.is_empty(), "Homogeneous array should have no errors");
 }
-
-#[test]
-fn test_binary_op_type_error_location() {
-    let code = r#"1 + "hello""#;
-    let errors = check_types(code);
-
-    assert!(!errors.is_empty(), "Expected type error for number + string");
-}
-
-#[test]
-fn test_error_message_readability() {
-    // Test that error messages are human-readable
-    let code = r#"1 + "hello""#;
-    let errors = check_types(code);
-
-    assert!(!errors.is_empty(), "Expected type error");
-
-    let error_msg = format!("{}", errors[0]);
-    // The error message should be informative
-    assert!(
-        error_msg.contains("mismatch") || error_msg.contains("type") || error_msg.contains("unify"),
-        "Error message should mention type mismatch: {}",
-        error_msg
-    );
-}
-
-#[test]
-fn test_multiple_errors_show_locations() {
-    // Code with type error in binary operation
-    let code = r#"1 + "two""#;
-    let errors = check_types(code);
-
-    assert!(!errors.is_empty(), "Expected at least one type error");
-}

crates/mq-check/tests/integration_test.rs

@@ -333,7 +333,7 @@ fn test_try_catch() {
 #[rstest]
 #[case::add_strings(r#"def add(x, y): x + y; | add("hello", "world")"#, true)]
 #[case::add_numbers("def add(x, y): x + y; | add(1, 2)", true)]
-#[case::add_mixed_types(r#"def add(x, y): x + y; | add(1, "hello")"#, false)]
+#[case::add_mixed_types(r#"def add(x, y): x + y; | add(1, "hello")"#, true)]
 #[case::add_mixed_types_reversed(r#"def add(x, y): x + y; | add("hello", 1)"#, true)] // string+any->string overload matches
 #[case::string_concat_in_fn(r#"def greet(name): "hello " + name; | greet("world")"#, true)]
 #[case::unary_negation("-42", true)]
@@ -415,8 +415,8 @@ fn test_macro_with_multiple_params() {
 // User-Defined Function Type Checking
 
 #[rstest]
-#[case::arg_type_mismatch(r#"def add(x, y): x + y; | add(1, "hello")"#, false)]
-#[case::return_type_propagation(r#"def get_num(): 42; | get_num() + "hello""#, false)]
+#[case::arg_type_mismatch(r#"def add(x, y): x + y; | add(1, "hello")"#, true)]
+#[case::return_type_propagation(r#"def get_num(): 42; | get_num() + "hello""#, true)]
 #[case::chained_calls(r#"def double(x): x + x; | def negate(x): 0 - x; | double(negate(1))"#, true)]
 #[case::string_plus_number(r#"def greet(): "hello"; | greet() + 1"#, true)]
 #[case::string_minus_number(r#"def greet(): "hello"; | greet() - 1"#, false)]
@@ -447,7 +447,7 @@ fn test_user_function_type_checking(#[case] code: &str, #[case] should_succeed:
 #[case::number_mul_string(r#"3 * "x""#, false, "number * string")]
 #[case::string_minus_number(r#""abc" - 1"#, false, "string - number")]
 #[case::string_div_number(r#""abc" / 2"#, false, "string / number")]
-#[case::number_add_string(r#"1 + "world""#, false, "number + string")]
+#[case::number_add_string(r#"1 + "world""#, true, "number + string")]
 #[case::string_mul_string(r#""a" * "b""#, false, "string * string")]
 #[case::string_div_string(r#""a" / "b""#, false, "string / string")]
 #[case::string_minus_string(r#""a" - "b""#, false, "string - string")]
@@ -524,7 +524,7 @@ fn test_equality_op_type_errors(#[case] code: &str, #[case] should_succeed: bool
 #[case::let_num_minus_string(r#"let x = 1 | x - "str""#, false, "let number binding minus string")]
 #[case::let_num_mul_string(r#"let x = 1 | x * "str""#, false, "let number binding times string")]
 #[case::let_num_div_string(r#"let x = 1 | x / "str""#, false, "let number binding div string")]
-#[case::let_num_plus_string(r#"let x = 1 | x + "str""#, false, "let number binding plus string")]
+#[case::let_num_plus_string(r#"let x = 1 | x + "str""#, true, "let number binding plus string")]
 #[case::let_string_minus_num(r#"let x = "hello" | x - 1"#, false, "let string binding minus number")]
 #[case::let_string_div_num(r#"let x = "hello" | x / 2"#, false, "let string binding div number")]
 #[case::let_string_mul_string(r#"let x = "hello" | x * "world""#, false, "let string binding times string")]

crates/mq-check/tests/type_errors_test.rs

@@ -22,9 +22,9 @@ fn check_types(code: &str) -> Vec<TypeError> {
 
 #[test]
 fn test_binary_op_type_mismatch() {
-    let result = check_types(r#"1 + "string""#);
+    let result = check_types(r#"1 + true"#);
     println!("Binary op type mismatch: {:?}", result);
-    assert!(!result.is_empty(), "Expected type error for number + string");
+    assert!(!result.is_empty(), "Expected type error for number + boolean");
 }
 
 #[test]