feat: close ZynML stdlib coverage gaps (RC1-RC6)

Fix 6 root causes blocking ZynML stdlib features, bringing test
pass rate from ~60% to 14/15 (93%).

- Fix method return type resolution for extern types (lowering + SSA)
  by matching Type::Extern and Type::Unresolved impl blocks alongside
  Type::Named, and checking inherent methods on type definitions
- Fix f64 binary ops by storing function parameter types in
  var_typed_ast_types for proper float detection in resolve_actual_type
- Add float-aware Add/Sub/Mul in cranelift backend as defensive fallback
- Fix unary operator parsing: split unary_prefix_expr grammar rule to
  properly emit TypedExpression::Unary nodes instead of silently
  discarding the operator
- Add unary trait dispatch (Neg/Not) in SSA builder, following the
  binary operator dispatch pattern for extern types like Tensor
- Propagate Unary/Binary expression types from operands in the Grammar2
  interpreter instead of defaulting to Unit
- Implement tensor_eye in ZRTL plugin and register $Tensor$eye symbol
- Add tensor_eye builtin mapping in ml.zyn

Author: darmie

.env.markflow

@@ -18,6 +18,13 @@ MARKFLOW_TEXT_SECONDARY=#555566
 MARKFLOW_TEXT_MUTED=#888899
 MARKFLOW_BORDER=rgba(0,0,0,0.08)
 MARKFLOW_CODE_BG=#1a1a2e
+MARKFLOW_CODE_INLINE_BG=rgba(0,0,0,0.06)
+MARKFLOW_CODE_INLINE_COLOR=#8b3dff
+MARKFLOW_BG_HOVER=rgba(0,0,0,0.04)
+MARKFLOW_ACCENT_GLOW=rgba(26,26,26,0.06)
+MARKFLOW_HEADER_BG=rgba(234,234,242,0.85)
+MARKFLOW_FOOTER_BG=rgba(234,234,242,0.9)
+MARKFLOW_BORDER_ACTIVE=rgba(0,0,0,0.15)
 
 MARKFLOW_SOCIAL_GITHUB=https://github.com/darmie/zyntax
 

crates/compiler/src/cranelift_backend.rs

@@ -1239,9 +1239,27 @@ impl CraneliftBackend {
                             });
 
                             let value = match op {
-                                BinaryOp::Add => builder.ins().iadd(lhs, rhs),
-                                BinaryOp::Sub => builder.ins().isub(lhs, rhs),
-                                BinaryOp::Mul => builder.ins().imul(lhs, rhs),
+                                BinaryOp::Add => {
+                                    if ty.is_float() {
+                                        builder.ins().fadd(lhs, rhs)
+                                    } else {
+                                        builder.ins().iadd(lhs, rhs)
+                                    }
+                                }
+                                BinaryOp::Sub => {
+                                    if ty.is_float() {
+                                        builder.ins().fsub(lhs, rhs)
+                                    } else {
+                                        builder.ins().isub(lhs, rhs)
+                                    }
+                                }
+                                BinaryOp::Mul => {
+                                    if ty.is_float() {
+                                        builder.ins().fmul(lhs, rhs)
+                                    } else {
+                                        builder.ins().imul(lhs, rhs)
+                                    }
+                                }
                                 BinaryOp::Div => {
                                     if ty.is_float() {
                                         builder.ins().fdiv(lhs, rhs)
@@ -5814,7 +5832,7 @@ impl CraneliftBackend {
                             sig.params
                                 .push(cranelift_codegen::ir::AbiParam::new(arg_ty));
                         }
-                        // For now, assume void return unless we have result
+                        // For now, assume i64 return unless we have no result
                         if result.is_some() {
                             sig.returns
                                 .push(cranelift_codegen::ir::AbiParam::new(types::I64));

crates/compiler/src/lowering.rs

@@ -1180,26 +1180,78 @@ impl LoweringContext {
                         ..
                     } = &receiver_type
                     {
+                        // Also get the type name for matching extern impls
+                        let receiver_type_name = self.type_registry
+                            .get_type_by_id(*receiver_type_id)
+                            .map(|td| td.name);
                         // Look up the trait implementation
                         for (_trait_id, impls) in self.type_registry.iter_implementations() {
                             for impl_def in impls {
-                                if let Type::Named {
-                                    id: impl_type_id, ..
-                                } = &impl_def.for_type
-                                {
-                                    if *impl_type_id == *receiver_type_id {
-                                        // Find the method in this impl
-                                        for method in &impl_def.methods {
-                                            if method.signature.name == method_call.method {
-                                                // Update the expression type
-                                                expr.ty = method.signature.return_type.clone();
-                                                break;
-                                            }
+                                let impl_matches = match &impl_def.for_type {
+                                    Type::Named { id: impl_type_id, .. } => {
+                                        *impl_type_id == *receiver_type_id
+                                    }
+                                    Type::Extern { name, .. } => {
+                                        receiver_type_name.map_or(false, |n| n == *name)
+                                    }
+                                    Type::Unresolved(name) => {
+                                        receiver_type_name.map_or(false, |n| n == *name)
+                                    }
+                                    _ => false,
+                                };
+                                if impl_matches {
+                                    // Find the method in this impl
+                                    for method in &impl_def.methods {
+                                        if method.signature.name == method_call.method {
+                                            expr.ty = method.signature.return_type.clone();
+                                            break;
                                         }
                                     }
                                 }
                             }
                         }
+                        // Also check inherent methods on the type definition (for extern struct methods)
+                        if matches!(expr.ty, Type::Any | Type::Unknown) {
+                            if let Some(type_def) = self.type_registry.get_type_by_id(*receiver_type_id) {
+                                for method in &type_def.methods {
+                                    if method.name == method_call.method {
+                                        expr.ty = method.return_type.clone();
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    } else if let Type::Extern { name: extern_name, .. } = &receiver_type {
+                        // Look up methods in impl blocks for extern types (e.g., Tensor)
+                        // This enables chained method calls like t.reshape([2,3]).transpose()
+                        for (_trait_id, impls) in self.type_registry.iter_implementations() {
+                            for impl_def in impls {
+                                let impl_for_this_extern = match &impl_def.for_type {
+                                    Type::Extern { name, .. } => name == extern_name,
+                                    Type::Unresolved(name) => name == extern_name,
+                                    _ => false,
+                                };
+                                if impl_for_this_extern {
+                                    for method in &impl_def.methods {
+                                        if method.signature.name == method_call.method {
+                                            expr.ty = method.signature.return_type.clone();
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // Also check inherent methods on the type definition
+                        if matches!(expr.ty, Type::Any | Type::Unknown) {
+                            if let Some(type_def) = self.type_registry.get_type_by_name(*extern_name) {
+                                for method in &type_def.methods {
+                                    if method.name == method_call.method {
+                                        expr.ty = method.return_type.clone();
+                                        break;
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }

crates/compiler/src/ssa.rs

@@ -522,6 +522,10 @@ impl SsaBuilder {
             // Store parameter type for SSA variable tracking
             self.var_types.insert(param.name, param.ty.clone());
 
+            // Also store typed AST type for binary op float detection
+            let typed_ast_type = self.hir_type_to_typed_ast_type(&param.ty);
+            self.var_typed_ast_types.insert(param.name, typed_ast_type);
+
             eprintln!(
                 "[PARAM DEBUG] Inserted into var_types: var_types['{}'] = {:?}",
                 param.name.resolve_global().unwrap_or_default(),
@@ -1406,10 +1410,26 @@ impl SsaBuilder {
                     let hir_type = self.convert_type(&let_stmt.ty);
                     self.var_types.insert(let_stmt.name, hir_type.clone());
 
-                    // For TypedAST type, use initializer's type if variable type is Any
+                    // For TypedAST type, use initializer's type if variable type is Any/Unknown
                     // This works around the issue where type inference doesn't update the AST
-                    let typed_ast_type = if matches!(let_stmt.ty, Type::Any) {
-                        value.ty.clone()
+                    let typed_ast_type = if matches!(let_stmt.ty, Type::Any | Type::Unknown) {
+                        // For unary expressions, the node type may also be Unknown;
+                        // in that case, look through to the operand's type
+                        let init_ty = &value.ty;
+                        if matches!(init_ty, Type::Any | Type::Unknown) {
+                            if let TypedExpression::Unary(unary) = &value.node {
+                                let operand_ty = self.resolve_actual_type(&unary.operand.node, &unary.operand.ty);
+                                if !matches!(operand_ty, Type::Any | Type::Unknown) {
+                                    operand_ty
+                                } else {
+                                    init_ty.clone()
+                                }
+                            } else {
+                                init_ty.clone()
+                            }
+                        } else {
+                            init_ty.clone()
+                        }
                     } else {
                         let_stmt.ty.clone()
                     };
@@ -2628,8 +2648,32 @@ impl SsaBuilder {
             TypedExpression::Unary(unary) => {
                 let op = &unary.op;
                 let operand = &unary.operand;
+
+                // Resolve actual operand type for trait dispatch
+                let operand_actual_ty = self.resolve_actual_type(&operand.node, &operand.ty);
+
+                // Try trait dispatch for non-primitive types (e.g., -tensor → $Tensor$neg)
+                let mut operand_with_type = operand.clone();
+                operand_with_type.ty = operand_actual_ty;
+
+                if let Some(trait_call) = self.try_unary_operator_trait_dispatch(
+                    block_id,
+                    op,
+                    &operand_with_type,
+                    &expr.ty,
+                )? {
+                    return Ok(trait_call);
+                }
+
+                // Regular unary operations for primitive types
                 let operand_val = self.translate_expression(block_id, operand)?;
-                let result_type = self.convert_type(&expr.ty);
+                // For unary ops, result type = operand type (e.g., -int → int)
+                // Use operand type when expression type is Unknown/Any
+                let result_type = if matches!(expr.ty, Type::Unknown | Type::Any) {
+                    self.convert_type(&operand_with_type.ty)
+                } else {
+                    self.convert_type(&expr.ty)
+                };
 
                 let hir_op = self.convert_unary_op(op);
                 let result = self.create_value(result_type.clone(), HirValueKind::Instruction);
@@ -3674,20 +3718,32 @@ impl SsaBuilder {
                     } else if let Type::Named { id, .. } = &receiver_type {
                         // Fall back to looking up in trait implementations for named types
                         let receiver_type_id = *id;
+                        // Also get the type name for matching extern impls
+                        let receiver_type_name = self.type_registry
+                            .get_type_by_id(receiver_type_id)
+                            .map(|td| td.name);
                         let mut method_return_type = None;
                         for (_trait_id, impls) in self.type_registry.iter_implementations() {
                             for impl_def in impls {
-                                if let Type::Named {
-                                    id: impl_type_id, ..
-                                } = &impl_def.for_type
-                                {
-                                    if *impl_type_id == receiver_type_id {
-                                        for method in &impl_def.methods {
-                                            if method.signature.name == method_call.method {
-                                                method_return_type =
-                                                    Some(method.signature.return_type.clone());
-                                                break;
-                                            }
+                                let impl_matches = match &impl_def.for_type {
+                                    Type::Named { id: impl_type_id, .. } => {
+                                        *impl_type_id == receiver_type_id
+                                    }
+                                    Type::Extern { name, .. } => {
+                                        // Extern type impls match by name
+                                        receiver_type_name.map_or(false, |n| n == *name)
+                                    }
+                                    Type::Unresolved(name) => {
+                                        receiver_type_name.map_or(false, |n| n == *name)
+                                    }
+                                    _ => false,
+                                };
+                                if impl_matches {
+                                    for method in &impl_def.methods {
+                                        if method.signature.name == method_call.method {
+                                            method_return_type =
+                                                Some(method.signature.return_type.clone());
+                                            break;
                                         }
                                     }
                                 }
@@ -5543,6 +5599,115 @@ impl SsaBuilder {
         ))
     }
 
+    /// Try to dispatch a unary operator to a trait method call.
+    /// Returns Some(result_value) if the operator should be dispatched via trait,
+    /// or None if the regular unary instruction should be used.
+    fn try_unary_operator_trait_dispatch(
+        &mut self,
+        block_id: HirId,
+        op: &zyntax_typed_ast::typed_ast::UnaryOp,
+        operand: &zyntax_typed_ast::TypedNode<zyntax_typed_ast::typed_ast::TypedExpression>,
+        _result_ty: &Type,
+    ) -> CompilerResult<Option<HirId>> {
+        use zyntax_typed_ast::typed_ast::UnaryOp as FrontendOp;
+
+        // Only consider trait dispatch for non-primitive types
+        let operand_type = &operand.ty;
+        if !self.is_trait_dispatchable_type(operand_type) {
+            return Ok(None);
+        }
+
+        // Get the method and trait names for this operator
+        let (method_name, trait_name) = match op {
+            FrontendOp::Minus => ("neg", "Neg"),
+            FrontendOp::Not => ("not", "Not"),
+            _ => return Ok(None),
+        };
+
+        // Get the type name for constructing the method symbol
+        let type_name = self.get_type_symbol_prefix(operand_type);
+        if type_name.is_none() {
+            return Ok(None);
+        }
+        let type_name = type_name.unwrap();
+
+        // Build candidate names (same pattern as binary dispatch):
+        // 1) Type$method
+        // 2) Type$Trait$method
+        // 3) $Type$method (runtime symbol for extern-backed types)
+        let mut function_candidates = Vec::with_capacity(2);
+        let runtime_symbol = if let Some(stripped) = type_name.strip_prefix('$') {
+            function_candidates.push(format!("{}${}", stripped, method_name));
+            function_candidates.push(format!("{}${}${}", stripped, trait_name, method_name));
+            format!("{}${}", type_name, method_name)
+        } else {
+            function_candidates.push(format!("{}${}", type_name, method_name));
+            function_candidates.push(format!("{}${}${}", type_name, trait_name, method_name));
+            format!("${}${}", type_name, method_name)
+        };
+
+        let mut matched_function: Option<(HirId, String)> = None;
+        for candidate in &function_candidates {
+            let candidate_interned = InternedString::new_global(candidate);
+            if let Some(&func_id) = self.function_symbols.get(&candidate_interned) {
+                matched_function = Some((func_id, candidate.clone()));
+                break;
+            }
+        }
+
+        let callee = if let Some((func_id, matched_name)) = matched_function {
+            log::debug!(
+                "[SSA] Unary trait dispatch: using function '{}' for type {}",
+                matched_name,
+                type_name
+            );
+            crate::hir::HirCallable::Function(func_id)
+        } else if type_name.starts_with('$') {
+            log::debug!(
+                "[SSA] Unary trait dispatch: using runtime symbol '{}' for type {}",
+                runtime_symbol,
+                type_name
+            );
+            crate::hir::HirCallable::Symbol(runtime_symbol)
+        } else {
+            return Ok(None);
+        };
+
+        // Translate the operand
+        let operand_val = self.translate_expression(block_id, operand)?;
+
+        // Result type should be the same as the operand type (e.g., -Tensor = Tensor)
+        let hir_result_type = self.convert_type(operand_type);
+        log::debug!(
+            "[SSA] Unary trait dispatch result type: {:?} (from operand type: {:?})",
+            hir_result_type,
+            operand_type
+        );
+
+        // Create call instruction to the trait method
+        let result = if hir_result_type != HirType::Void {
+            Some(self.create_value(hir_result_type.clone(), HirValueKind::Instruction))
+        } else {
+            None
+        };
+
+        let inst = HirInstruction::Call {
+            result,
+            callee,
+            args: vec![operand_val],
+            type_args: vec![],
+            const_args: vec![],
+            is_tail: false,
+        };
+
+        self.add_instruction(block_id, inst);
+        self.add_use(operand_val, result.unwrap_or(operand_val));
+
+        Ok(Some(
+            result.unwrap_or_else(|| self.create_undef(HirType::Void)),
+        ))
+    }
+
     /// Resolve the actual type for an expression, looking up variable types if needed.
     /// This is needed because expression nodes may have type `Any` even when the
     /// variable has a more specific type recorded in var_typed_ast_types.

crates/zyn_peg/src/runtime2/interpreter.rs

@@ -827,6 +827,10 @@ impl<'g> GrammarInterpreter<'g> {
             TypedExpression::Compute(_) => Type::Any,
             // Struct literal gets its type from the struct name - use Unresolved for compiler to resolve
             TypedExpression::Struct(lit) => Type::Unresolved(lit.name),
+            // Unary operations (negation, not) have the same type as their operand
+            TypedExpression::Unary(unary) => unary.operand.ty.clone(),
+            // Binary operations have the same type as their left operand
+            TypedExpression::Binary(binary) => binary.left.ty.clone(),
             _ => Type::Primitive(PrimitiveType::Unit),
         };