implement typed rethrows for higher-order functions

baml_language/crates/baml_builtins2/baml_std/testing/registry.baml

@@ -4,13 +4,13 @@
 
 class TestRegistration {
   name string
-  body () -> null
+  body () -> null throws unknown
   runner TestRunner?
 }
 
 class TestSetRegistration {
   name string
-  collector (TestCollector) -> null
+  collector (TestCollector) -> null throws unknown
   runner TestSetRunner?
 }
 

baml_language/crates/baml_compiler2_ast/src/ast.rs

@@ -97,10 +97,11 @@ pub enum TypeExpr {
         value: baml_base::Literal,
         attrs: Vec<RawAttribute>,
     },
-    /// Function type: (params) -> return
+    /// Function type: (params) -> return [throws E]
     Function {
         params: Vec<FunctionTypeParam>,
         ret: Box<TypeExpr>,
+        throws: Option<Box<TypeExpr>>,
         attrs: Vec<RawAttribute>,
     },
     /// The `unknown` keyword type

baml_language/crates/baml_compiler2_ast/src/lib.rs

@@ -178,7 +178,12 @@ mod tests {
                 value: value.clone(),
                 attrs: strip_attrs(attrs),
             },
-            TypeExpr::Function { params, ret, attrs } => TypeExpr::Function {
+            TypeExpr::Function {
+                params,
+                ret,
+                throws,
+                attrs,
+            } => TypeExpr::Function {
                 params: params
                     .iter()
                     .map(|p| crate::ast::FunctionTypeParam {
@@ -187,6 +192,7 @@ mod tests {
                     })
                     .collect(),
                 ret: Box::new(strip_spans(ret)),
+                throws: throws.as_ref().map(|t| Box::new(strip_spans(t))),
                 attrs: strip_attrs(attrs),
             },
             TypeExpr::Media { kind, attrs } => TypeExpr::Media {

baml_language/crates/baml_compiler2_ast/src/lower_type_expr.rs

@@ -164,9 +164,16 @@ fn lower_base_terminal(type_expr: &CstTypeExpr) -> TypeExpr {
             .function_return_type()
             .map(|t| lower_type_expr_inner(&t, false))
             .unwrap_or(TypeExpr::Unknown { attrs: vec![] });
+        let throws = type_expr.function_throws_type().map(|throws_clause| {
+            let throws_type = throws_clause
+                .type_expr()
+                .expect("THROWS_CLAUSE should have a type");
+            Box::new(lower_type_expr_inner(&throws_type, false))
+        });
         return TypeExpr::Function {
             params,
             ret: Box::new(ret),
+            throws,
             attrs: vec![],
         };
     }

baml_language/crates/baml_compiler2_mir/src/lower.rs

@@ -164,13 +164,22 @@ pub fn convert_tir2_ty(ty: &Tir2Ty, resolved: &ResolvedAliases) -> Ty {
             attr: attr.clone(),
         },
 
-        // Functions — drop param names
-        Tir2Ty::Function { params, ret, attr } => Ty::Function {
+        // Functions — drop param names; map Never throws to None
+        Tir2Ty::Function {
+            params,
+            ret,
+            throws,
+            attr,
+        } => Ty::Function {
             params: params
                 .iter()
                 .map(|(_, t)| convert_tir2_ty(t, resolved))
                 .collect(),
             ret: Box::new(convert_tir2_ty(ret, resolved)),
+            throws: match throws.as_ref() {
+                Tir2Ty::Never { .. } => None,
+                t => Some(Box::new(convert_tir2_ty(t, resolved))),
+            },
             attr: attr.clone(),
         },