Merge pull request #2047 from harehare/feat/try-catch-error-binder

✨ feat(mq-lang): add error binder to try/catch (`catch(e):`)

Author: harehare

crates/mq-check/src/constraint.rs

@@ -211,8 +211,24 @@ pub(super) fn generate_symbol_constraints(
 
         // Parameters and pattern variables get fresh type variables
         SymbolKind::Parameter | SymbolKind::PatternVariable { .. } => {
-            let ty_var = ctx.fresh_var();
-            ctx.set_symbol_type(symbol_id, Type::Var(ty_var));
+            // `catch(e):` always binds `e` to `{message: string}` (see `Evaluator::eval_try`).
+            let is_catch_error_binder = matches!(kind, SymbolKind::Parameter)
+                && hir
+                    .symbol(symbol_id)
+                    .and_then(|s| s.parent)
+                    .and_then(|parent_id| hir.symbol(parent_id))
+                    .is_some_and(|parent| matches!(parent.kind, SymbolKind::Catch));
+
+            if is_catch_error_binder {
+                let ty = Type::record(
+                    std::collections::BTreeMap::from([("message".to_string(), Type::String)]),
+                    Type::RowEmpty,
+                );
+                ctx.set_symbol_type(symbol_id, ty);
+            } else {
+                let ty_var = ctx.fresh_var();
+                ctx.set_symbol_type(symbol_id, Type::Var(ty_var));
+            }
         }
 
         // Variables get fresh type variables, constrained to their initializer
@@ -1856,15 +1872,25 @@ pub(super) fn generate_symbol_constraints(
                     // Different concrete types: use Union type to represent both possibilities
                     let union_ty = Type::union(vec![resolved_try, resolved_catch]);
                     ctx.set_symbol_type(symbol_id, union_ty);
-                } else {
-                    // Same type or at least one is a type variable: unify them
+                } else if both_concrete {
+                    // Same concrete type: unify them directly.
                     ctx.add_constraint(Constraint::Equal(
                         try_ty.clone(),
                         catch_ty,
                         range,
                         ConstraintOrigin::General,
                     ));
                     ctx.set_symbol_type(symbol_id, try_ty);
+                } else {
+                    // A branch type is still pending deferred resolution — decide later.
+                    let ty_var = ctx.fresh_var();
+                    ctx.set_symbol_type(symbol_id, Type::Var(ty_var));
+                    ctx.add_deferred_try_catch(infer::DeferredTryCatch {
+                        symbol_id,
+                        try_ty,
+                        catch_ty,
+                        range,
+                    });
                 }
             } else if !children.is_empty() {
                 let try_ty = ctx.get_or_create_symbol_type(children[0]);

crates/mq-check/src/deferred.rs

@@ -395,6 +395,50 @@ fn check_union_members(
     }
 }
 
+/// Resolves deferred try/catch branch-type merges, after other deferred passes
+/// (record/tuple access, overloads, ...) have settled the branch types.
+pub(crate) fn resolve_deferred_try_catches(ctx: &mut InferenceContext) -> bool {
+    let entries = ctx.take_deferred_try_catches();
+    if entries.is_empty() {
+        return false;
+    }
+
+    for entry in entries {
+        let Some(result_ty) = ctx.get_symbol_type(entry.symbol_id).cloned() else {
+            continue;
+        };
+        let resolved_try = ctx.resolve_type(&entry.try_ty);
+        let resolved_catch = ctx.resolve_type(&entry.catch_ty);
+        let both_concrete = !resolved_try.is_var() && !resolved_catch.is_var();
+        let same_discriminant =
+            both_concrete && std::mem::discriminant(&resolved_try) == std::mem::discriminant(&resolved_catch);
+
+        let merged_ty = if both_concrete && !same_discriminant {
+            types::Type::union(vec![resolved_try, resolved_catch])
+        } else {
+            ctx.add_constraint(Constraint::Equal(
+                entry.try_ty.clone(),
+                entry.catch_ty,
+                entry.range,
+                ConstraintOrigin::General,
+            ));
+            entry.try_ty
+        };
+        ctx.add_constraint(Constraint::Equal(
+            result_ty,
+            merged_ty,
+            entry.range,
+            ConstraintOrigin::General,
+        ));
+
+        // Solve immediately so an outer try/catch that depends on this result
+        // (nested `try: (try: ... catch: ...) catch: ...`) sees it resolved.
+        unify::solve_constraints(ctx);
+    }
+
+    true
+}
+
 /// Resolves deferred overloads after the first round of unification.
 ///
 /// Binary/unary operators whose operands were type variables during constraint

crates/mq-check/src/infer.rs

@@ -138,6 +138,22 @@ pub struct DeferredTupleAccess {
     pub range: Option<mq_lang::Range>,
 }
 
+/// A deferred try/catch branch-type merge for post-unification resolution.
+///
+/// A branch's type may depend on another deferred pass (e.g. record field
+/// access), so deciding Union-vs-Equal must wait until that pass has run.
+#[derive(Debug, Clone)]
+pub struct DeferredTryCatch {
+    /// The `Try` symbol whose type is being resolved
+    pub symbol_id: SymbolId,
+    /// The try body's type
+    pub try_ty: Type,
+    /// The catch body's type
+    pub catch_ty: Type,
+    /// Source range for error reporting
+    pub range: Option<mq_lang::Range>,
+}
+
 /// A single variable type narrowing entry.
 ///
 /// Represents a narrowing of a variable's type within a specific branch,
@@ -211,6 +227,8 @@ pub struct InferenceContext {
     deferred_tuple_accesses: Vec<DeferredTupleAccess>,
     /// Deferred bracket accesses on function call return values (e.g. `f(x)["key"]`)
     deferred_call_return_accesses: Vec<DeferredCallReturnAccess>,
+    /// Deferred try/catch branch-type merges for post-unification resolution
+    deferred_try_catches: Vec<DeferredTryCatch>,
     /// Type narrowings collected from type predicate conditions in if/elif expressions
     type_narrowings: Vec<TypeNarrowing>,
     /// Cross-arm narrowings collected from match expressions
@@ -242,6 +260,7 @@ impl InferenceContext {
             deferred_selector_accesses: Vec::new(),
             deferred_tuple_accesses: Vec::new(),
             deferred_call_return_accesses: Vec::new(),
+            deferred_try_catches: Vec::new(),
             type_narrowings: Vec::new(),
             cross_arm_narrowings: Vec::new(),
             strict_array,
@@ -361,6 +380,16 @@ impl InferenceContext {
         std::mem::take(&mut self.deferred_call_return_accesses)
     }
 
+    /// Adds a deferred try/catch branch-type merge
+    pub fn add_deferred_try_catch(&mut self, entry: DeferredTryCatch) {
+        self.deferred_try_catches.push(entry);
+    }
+
+    /// Takes all deferred try/catch entries (consumes them)
+    pub fn take_deferred_try_catches(&mut self) -> Vec<DeferredTryCatch> {
+        std::mem::take(&mut self.deferred_try_catches)
+    }
+
     /// Adds a type narrowing collected from a type predicate condition
     pub fn add_type_narrowing(&mut self, narrowing: TypeNarrowing) {
         self.type_narrowings.push(narrowing);

crates/mq-check/src/lib.rs

@@ -352,6 +352,14 @@ impl TypeChecker {
             unify::solve_constraints(&mut ctx);
         }
 
+        // Resolve deferred try/catch branch-type merges, then retry accesses/operators
+        // that depend on a `let v = try: ... catch: ...` variable's now-final type.
+        deferred::resolve_deferred_try_catches(&mut ctx);
+        if deferred::resolve_deferred_tuple_accesses(&mut ctx) {
+            unify::solve_constraints(&mut ctx);
+        }
+        deferred::resolve_deferred_overloads(&mut ctx);
+
         // Check operators inside user-defined function bodies against call-site types.
         // Uses local substitution (original params → call-site args) without modifying
         // global state, so multiple call sites don't interfere.

crates/mq-check/tests/integration_test.rs

@@ -527,6 +527,19 @@ fn test_try_catch() {
     );
 }
 
+#[test]
+fn test_try_catch_error_binder() {
+    assert!(check_types(r#"try: 42 / 0 catch(e): e["message"];"#).is_empty());
+}
+
+#[test]
+fn test_try_catch_error_binder_undefined_field() {
+    assert!(
+        !check_types(r#"try: 42 / 0 catch(e): e["not_a_field"];"#).is_empty(),
+        "accessing a field the error binder doesn't have should be a type error"
+    );
+}
+
 // Polymorphic Function Type Checking
 
 #[rstest]

crates/mq-formatter/src/formatter.rs

@@ -1061,12 +1061,24 @@ impl Formatter {
         self.append_indent(indent_level);
         self.output.push_str(&node.to_string());
 
-        if let Some(colon) = node.children.first() {
+        // Optional error binder: `catch(e):`. Render the `(`, ident, `)` as-is
+        // before the colon-or-do separator handled below.
+        let colon_index = match Self::find_token_position(node, |kind| matches!(kind, mq_lang::TokenKind::RParen)) {
+            Some(rparen_index) => {
+                node.children.iter().take(rparen_index + 1).for_each(|child| {
+                    self.format_node(mq_lang::Shared::clone(child), 0);
+                });
+                rparen_index + 1
+            }
+            None => 0,
+        };
+
+        if let Some(colon) = node.children.get(colon_index) {
             self.output.push_str(&colon.to_string());
             self.append_space();
         }
 
-        for child in node.children.iter().skip(1) {
+        for child in node.children.iter().skip(colon_index + 1) {
             let child_indent = if child.has_new_line() {
                 indent_level + 1
             } else {
@@ -2275,6 +2287,25 @@ catch:
 "
     )]
     #[case::try_catch_oneline("try: process() catch: handle_error()", "try: process() catch: handle_error()")]
+    #[case::try_catch_with_binder(
+        "try: process() catch(e): handle_error(e)",
+        "try: process() catch(e): handle_error(e)"
+    )]
+    #[case::try_catch_with_binder_extra_spaces(
+        "try: process() catch( e ): handle_error(e)",
+        "try: process() catch(e): handle_error(e)"
+    )]
+    #[case::try_catch_with_binder_multiline(
+        r#"try:
+  process()
+catch(e):
+  handle_error(e)"#,
+        "try:
+  process()
+catch(e):
+  handle_error(e)
+"
+    )]
     #[case::try_catch_with_finally(
         r#"try:
   process()

crates/mq-hir/src/hir.rs

@@ -400,6 +400,8 @@ def foo(): 1", vec![" test".to_owned(), " test".to_owned(), "".to_owned()], vec!
     #[case::block("do \"hello\" end", "hello", SymbolKind::String)]
     #[case::try_("try: 1 catch: 2", "try", SymbolKind::Try)]
     #[case::catch_("try: 1 catch: 2", "catch", SymbolKind::Catch)]
+    #[case::catch_with_binder("try: 1 catch(e): e", "catch", SymbolKind::Catch)]
+    #[case::catch_error_binder_param("try: 1 catch(e): e", "e", SymbolKind::Parameter)]
     #[case::symbol_ident(":foo", "foo", SymbolKind::Symbol)]
     #[case::symbol_string(":\"hello\"", "hello", SymbolKind::Symbol)]
     #[case::pattern_match("match (v): | [1,2,3]: 1 end", "match", SymbolKind::Match)]
@@ -597,6 +599,68 @@ end"#;
         assert!(hir.errors().is_empty(), "Should have no unresolved symbols");
     }
 
+    #[test]
+    fn test_catch_error_binder_resolution() {
+        let mut hir = Hir::default();
+        hir.builtin.disabled = true;
+
+        let code = "try: 1 catch(e): e";
+        hir.add_code(None, code);
+
+        let binder_symbol = hir
+            .symbols()
+            .find(|(_, s)| s.kind == SymbolKind::Parameter && s.value.as_deref() == Some("e"));
+        assert!(binder_symbol.is_some(), "catch(e) should declare e as a Parameter");
+
+        let ref_symbol = hir
+            .symbols()
+            .find(|(_, s)| s.kind == SymbolKind::Ref && s.value.as_deref() == Some("e"));
+        assert!(ref_symbol.is_some(), "Should have a Ref symbol for e in the catch body");
+
+        let (ref_id, _) = ref_symbol.unwrap();
+        let resolved = hir.resolve_reference_symbol(ref_id);
+
+        assert_eq!(
+            resolved,
+            Some(binder_symbol.unwrap().0),
+            "e in the catch body should resolve to the catch(e) binder"
+        );
+        assert!(hir.errors().is_empty(), "Should have no unresolved symbols");
+    }
+
+    #[test]
+    fn test_catch_error_binder_shadows_outer_variable() {
+        let mut hir = Hir::default();
+        hir.builtin.disabled = true;
+
+        let code = "let e = \"hello\" | try: 1 catch(e): e";
+        hir.add_code(None, code);
+
+        let outer_e = hir
+            .symbols()
+            .find(|(_, s)| s.kind == SymbolKind::Variable && s.value.as_deref() == Some("e"))
+            .unwrap()
+            .0;
+        let binder_e = hir
+            .symbols()
+            .find(|(_, s)| s.kind == SymbolKind::Parameter && s.value.as_deref() == Some("e"))
+            .unwrap()
+            .0;
+
+        let ref_symbol = hir
+            .symbols()
+            .find(|(_, s)| s.kind == SymbolKind::Ref && s.value.as_deref() == Some("e"));
+        let (ref_id, _) = ref_symbol.unwrap();
+        let resolved = hir.resolve_reference_symbol(ref_id);
+
+        assert_eq!(
+            resolved,
+            Some(binder_e),
+            "e inside the catch body should resolve to the catch(e) binder, not the outer `let e`"
+        );
+        assert_ne!(resolved, Some(outer_e));
+    }
+
     #[test]
     fn test_match_expression_basic() {
         let mut hir = Hir::default();