Complete Grammar2 semantic pass for imports, compute, and matmul dispatch

Author: darmie

crates/compiler/src/ssa.rs

@@ -1363,6 +1363,10 @@ impl SsaBuilder {
                 // Evaluate expression for side effects
                 self.translate_expression(block_id, expr)?;
             }
+            TypedStatement::Yield(expr) => {
+                // Yield behaves like an expression statement at the SSA level.
+                self.translate_expression(block_id, expr)?;
+            }
 
             TypedStatement::Match(match_stmt) => {
                 // Handle match statement: evaluate scrutinee
@@ -1655,6 +1659,14 @@ impl SsaBuilder {
                 }
                 eprintln!("[DEBUG SSA] No trait dispatch, using native binary op");
 
+                // `@` must dispatch through MatMul::matmul; do not silently alias to numeric `mul`.
+                if matches!(op, FrontendOp::MatMul) {
+                    return Err(crate::CompilerError::Analysis(format!(
+                        "matrix multiplication '@' requires MatMul::matmul implementation for lhs type {:?}",
+                        left_with_type.ty
+                    )));
+                }
+
                 // Regular binary operations for primitive types
                 let left_val = self.translate_expression(block_id, left)?;
                 let right_val = self.translate_expression(block_id, right)?;
@@ -1836,6 +1848,28 @@ impl SsaBuilder {
                 Ok(result_or_void)
             }
 
+            TypedExpression::Compute(compute) => {
+                // Lower compute expressions through the existing call pipeline for now.
+                // This preserves call-based execution while keeping typed compute structure.
+                let compute_name = InternedString::new_global("compute");
+                let lowered = zyntax_typed_ast::typed_ast::TypedCall {
+                    callee: Box::new(zyntax_typed_ast::typed_node(
+                        TypedExpression::Variable(compute_name),
+                        Type::Any,
+                        expr.span,
+                    )),
+                    positional_args: compute.args.clone(),
+                    named_args: vec![],
+                    type_args: vec![],
+                };
+                let lowered_expr = zyntax_typed_ast::typed_node(
+                    TypedExpression::Call(lowered),
+                    expr.ty.clone(),
+                    expr.span,
+                );
+                self.translate_expression(block_id, &lowered_expr)
+            }
+
             TypedExpression::Field(field_access) => {
                 let object = &field_access.object;
                 let field = &field_access.field;
@@ -4097,6 +4131,7 @@ impl SsaBuilder {
             FrontendOp::Add => HirOp::Add,
             FrontendOp::Sub => HirOp::Sub,
             FrontendOp::Mul => HirOp::Mul,
+            FrontendOp::MatMul => HirOp::Mul,
             FrontendOp::Div => HirOp::Div,
             FrontendOp::Rem => HirOp::Rem,
             FrontendOp::BitAnd => HirOp::And,
@@ -4150,6 +4185,7 @@ impl SsaBuilder {
             FrontendOp::Add => "add",
             FrontendOp::Sub => "sub",
             FrontendOp::Mul => "mul",
+            FrontendOp::MatMul => "matmul",
             FrontendOp::Div => "div",
             FrontendOp::Rem => "mod",
             FrontendOp::Eq => "eq",
@@ -6206,6 +6242,12 @@ impl SsaBuilder {
                     result_ty,
                 )?;
 
+                if matches!(bin.op, zyntax_typed_ast::typed_ast::BinaryOp::MatMul) {
+                    return Err(crate::CompilerError::Analysis(
+                        "matrix multiplication '@' requires trait dispatch and is not supported in lambda const lowering".to_string(),
+                    ));
+                }
+
                 let hir_op = self.convert_binary_op(&bin.op);
                 let result_id = HirId::new();
                 func.values.insert(

crates/typed_ast/src/lib.rs

@@ -156,6 +156,8 @@ pub use typed_ast::{
     TypedCast,
     // Class/Struct/Enum types
     TypedClass,
+    TypedComputeExpr,
+    TypedComputeModifier,
     TypedDeclaration,
     // Defer type
     TypedDefer,
@@ -191,6 +193,7 @@ pub use typed_ast::{
     TypedImportModifier,
     TypedIndex,
     TypedInterface,
+    TypedKernelAttr,
     // Lambda types
     TypedLambda,
     TypedLambdaBody,
@@ -209,6 +212,7 @@ pub use typed_ast::{
     TypedMethodCall,
     TypedMethodParam,
     TypedModule,
+    TypedNamedArg,
     TypedNode,
     // Additional types for parser generation
     TypedParameter,

crates/typed_ast/src/type_checker.rs

@@ -1096,6 +1096,13 @@ impl TypeChecker {
 
                 Ok(Type::Never)
             }
+            TypedStatement::Yield(expr_node) => {
+                // Yield is currently validated as an expression-producing statement.
+                // Context-specific validation (e.g., only within compute reductions)
+                // happens in lowering/runtime passes.
+                self.check_expression(&expr_node.node)?;
+                Ok(Type::Primitive(PrimitiveType::Unit))
+            }
             TypedStatement::If(if_stmt) => self.check_if_statement(if_stmt),
             TypedStatement::While(while_stmt) => {
                 self.check_while_statement(while_stmt)?;
@@ -1243,7 +1250,8 @@ impl TypeChecker {
             | TypedExpression::Range(_)
             | TypedExpression::Block(_)
             | TypedExpression::ListComprehension(_)
-            | TypedExpression::Slice(_) => {
+            | TypedExpression::Slice(_)
+            | TypedExpression::Compute(_) => {
                 // Placeholder for now
                 Ok(self.inference.fresh_type_var())
             }
@@ -1281,7 +1289,7 @@ impl TypeChecker {
         use BinaryOp::*;
         match bin.op {
             // Arithmetic operators
-            Add | Sub | Mul | Div | Rem => {
+            Add | Sub | Mul | MatMul | Div | Rem => {
                 self.inference.unify(left_ty.clone(), right_ty)?;
                 Ok(left_ty)
             }

crates/typed_ast/src/typed_ast.rs

@@ -430,6 +430,8 @@ pub enum TypedStatement {
     /// Let with pattern destructuring: let (x, y) = expr
     LetPattern(TypedLetPattern),
     Return(Option<Box<TypedNode<TypedExpression>>>),
+    /// Yield from compute/reduction contexts
+    Yield(Box<TypedNode<TypedExpression>>),
     If(TypedIf),
     While(TypedWhile),
     Block(TypedBlock),
@@ -524,6 +526,8 @@ pub enum TypedExpression {
     Slice(TypedSlice),
     /// Import modifier expression: import loader("path") as Type
     ImportModifier(TypedImportModifier),
+    /// Compute expression: compute(args) @modifier { ... }
+    Compute(TypedComputeExpr),
     /// Path expression: Type::method or module::function
     Path(TypedPath),
 }
@@ -565,6 +569,7 @@ pub enum BinaryOp {
     Add,
     Sub,
     Mul,
+    MatMul,
     Div,
     Rem,
     // Comparison
@@ -986,6 +991,41 @@ pub struct TypedPath {
     pub segments: Vec<InternedString>,
 }
 
+/// Compute expression: `compute(args...) @modifier { body }`
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TypedComputeExpr {
+    /// Positional compute inputs
+    pub args: Vec<TypedNode<TypedExpression>>,
+    /// Compute-level modifiers (e.g., @device("cpu"), @async)
+    #[serde(default)]
+    pub modifiers: Vec<TypedComputeModifier>,
+    /// Kernel-specific attributes (e.g., @kernel(matmul), @workgroup(16,16))
+    #[serde(default)]
+    pub kernel_attrs: Vec<TypedKernelAttr>,
+    /// Compute body block
+    pub body: TypedBlock,
+}
+
+/// Generic compute modifier
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TypedComputeModifier {
+    pub name: InternedString,
+    #[serde(default)]
+    pub positional_args: Vec<TypedNode<TypedExpression>>,
+    #[serde(default)]
+    pub named_args: Vec<TypedNamedArg>,
+}
+
+/// Kernel-specific attribute
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TypedKernelAttr {
+    pub name: InternedString,
+    #[serde(default)]
+    pub positional_args: Vec<TypedNode<TypedExpression>>,
+    #[serde(default)]
+    pub named_args: Vec<TypedNamedArg>,
+}
+
 /// Method call with enhanced argument support
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TypedMethodCall {