Merge pull request #1373 from harehare/chore/mq-check-integration

Integrate mq-check crate and type checker options

Author: harehare

.vscode/launch.json

@@ -14,14 +14,14 @@
       ],
       "outFiles": ["${workspaceFolder}/editors/vscode/dist/**/*.js"],
       "env": {
-        "_MQ_DEBUG_BIN": "${workspaceFolder}/target/debug/mq"
+        "_MQ_DEBUG_BIN": "${workspaceFolder}/target/debug/mq-lsp"
       }
     },
     {
       "type": "lldb",
       "request": "launch",
       "name": "Rust Debug Launch",
-      "program": "${workspaceRoot}/target/debug/${workspaceRootFolderName}",
+      "program": "${workspaceRoot}/target/debug/mq-lsp",
       "args": [".h", "${workspaceRoot}/README.md"],
       "cwd": "${workspaceRoot}/target/debug/",
       "sourceLanguages": ["rust"]

Cargo.lock

@@ -20,6 +20,7 @@ resolver = "3"
 
 [workspace.dependencies]
 # Internal crates
+mq-check = {path = "crates/mq-check", version = "0.5.17"}
 mq-dap = {path = "crates/mq-dap", version = "0.5.17"}
 mq-formatter = {path = "crates/mq-formatter", version = "0.5.17"}
 mq-hir = {path = "crates/mq-hir", version = "0.5.17"}

Cargo.toml

@@ -79,12 +79,12 @@ fn register_arithmetic(ctx: &mut InferenceContext) {
     register_binary(ctx, "+", Type::String, Type::String, Type::String);
     register_binary(ctx, "add", Type::String, Type::String, Type::String);
 
-    // Addition: string + number -> string (coercion)
-    register_binary(ctx, "+", Type::String, Type::Number, Type::String);
-    register_binary(ctx, "add", Type::String, Type::Number, Type::String);
-
-    // Addition: [a] + [a] -> [a] (array concatenation)
     for name in ["+", "add"] {
+        // Addition: string + number -> string (coercion)
+        register_binary(ctx, name, Type::String, Type::Number, Type::String);
+        register_binary(ctx, name, Type::Number, Type::String, Type::String);
+
+        // Addition: [a] + [a] -> [a] (array concatenation)
         let a = ctx.fresh_var();
         register_binary(
             ctx,
@@ -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\"")] // Number + string coercion
+    #[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/src/builtin.rs

@@ -1,8 +1,8 @@
 //! Type inference context and engine.
 
-use crate::TypeError;
 use crate::constraint::Constraint;
 use crate::types::{Substitution, Type, TypeScheme, TypeVarContext, TypeVarId};
+use crate::{TypeEnv, TypeError};
 use mq_hir::SymbolId;
 use rustc_hash::FxHashMap;
 use smol_str::SmolStr;
@@ -511,8 +511,8 @@ impl InferenceContext {
     }
 
     /// Finalizes inference and returns symbol type schemes
-    pub fn finalize(self) -> FxHashMap<SymbolId, TypeScheme> {
-        let mut result = FxHashMap::default();
+    pub fn finalize(self) -> TypeEnv {
+        let mut result = TypeEnv::default();
 
         for (symbol, ty) in &self.symbol_types {
             let resolved = self.resolve_type(ty);

crates/mq-check/src/infer.rs

@@ -40,8 +40,43 @@ use types::TypeScheme;
 /// Result type for type checking operations
 pub type Result<T> = std::result::Result<T, TypeError>;
 
+/// Type environment mapping symbol IDs to their inferred type schemes
+#[derive(Debug, Clone, Default)]
+pub struct TypeEnv(FxHashMap<SymbolId, TypeScheme>);
+
+impl TypeEnv {
+    pub fn insert(&mut self, symbol_id: SymbolId, scheme: TypeScheme) {
+        self.0.insert(symbol_id, scheme);
+    }
+
+    pub fn get(&self, symbol_id: &SymbolId) -> Option<&TypeScheme> {
+        self.0.get(symbol_id)
+    }
+
+    pub fn get_all(&self) -> &FxHashMap<SymbolId, TypeScheme> {
+        &self.0
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl<'a> IntoIterator for &'a TypeEnv {
+    type Item = (&'a SymbolId, &'a TypeScheme);
+    type IntoIter = std::collections::hash_map::Iter<'a, SymbolId, TypeScheme>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
 /// Type checking errors
-#[derive(Debug, Error, Diagnostic)]
+#[derive(Debug, Error, Clone, Diagnostic)]
 #[allow(unused_assignments)]
 pub enum TypeError {
     #[error("Type mismatch: expected {expected}, found {found}")]
@@ -160,7 +195,7 @@ pub(crate) fn walk_ancestors(
 }
 
 /// Options for configuring the type checker behavior
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Copy, Default)]
 pub struct TypeCheckerOptions {
     /// When true, arrays must contain elements of a single type.
     /// Heterogeneous arrays like `[1, "hello"]` will produce a type error.
@@ -175,7 +210,7 @@ pub struct TypeCheckerOptions {
 /// Provides type inference and checking capabilities based on HIR information.
 pub struct TypeChecker {
     /// Symbol type mappings
-    symbol_types: FxHashMap<SymbolId, TypeScheme>,
+    symbol_types: TypeEnv,
     /// Type checker options
     options: TypeCheckerOptions,
 }
@@ -184,15 +219,15 @@ impl TypeChecker {
     /// Creates a new type checker with default options
     pub fn new() -> Self {
         Self {
-            symbol_types: FxHashMap::default(),
+            symbol_types: TypeEnv::default(),
             options: TypeCheckerOptions::default(),
         }
     }
 
     /// Creates a new type checker with the given options
     pub fn with_options(options: TypeCheckerOptions) -> Self {
         Self {
-            symbol_types: FxHashMap::default(),
+            symbol_types: TypeEnv::default(),
             options,
         }
     }
@@ -887,9 +922,14 @@ impl TypeChecker {
     }
 
     /// Gets all symbol types
-    pub fn symbol_types(&self) -> &FxHashMap<SymbolId, TypeScheme> {
+    pub fn symbol_types(&self) -> &TypeEnv {
         &self.symbol_types
     }
+
+    /// Gets the type scheme for a specific symbol.
+    pub fn symbol_type(&self, symbol_id: SymbolId) -> Option<&TypeScheme> {
+        self.symbol_types.get(&symbol_id)
+    }
 }
 
 impl Default for TypeChecker {

crates/mq-check/src/lib.rs

@@ -103,7 +103,7 @@ fn run() -> io::Result<()> {
             show_types: cli.show_types,
             label: label.as_deref(),
             no_builtins: cli.no_builtins,
-            type_checker_options: tc_options.clone(),
+            type_checker_options: tc_options,
         };
         let had_errors = check_file(&mut w, &code, source_url, &opts)?;
         if had_errors {
@@ -208,7 +208,7 @@ fn check_type(
     show_types: bool,
     options: &TypeCheckerOptions,
 ) -> io::Result<bool> {
-    let mut checker = TypeChecker::with_options(options.clone());
+    let mut checker = TypeChecker::with_options(*options);
     let mut errors = checker.check(hir);
 
     errors.sort_by_key(|a| a.location());

crates/mq-check/src/main.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/error_location_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/integration_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]