fix: enable ZynML runtime execution with multi-param functions

Key fixes for ZynML runtime execution:

1. Integer/Float Literal Types (interpreter.rs)
   - Changed default type for integer literals from I32 to I64
   - Changed default type for float literals from F32 to F64
   - Fixes type mismatch in functions returning i64

2. Parameter List Parsing (ml.zyn)
   - Fixed fn_params to collect ALL parameters using prepend_list
   - Previously only returned last parameter, breaking multi-arg calls
   - Also fixed: trait_params, type_params, fn_type_params, lambda_params

3. Lenient Type Checking (type_checker.rs)
   - Unknown variables (external functions) return fresh type var
   - Allows gradual typing for ZRTL builtin calls

4. Lenient Trait Registration (lib.rs)
   - Skip missing traits with warning instead of error
   - Enables compilation with partial trait resolution

5. Builtin Alias Creation (grammar.rs)
   - Create both alias extern (println) AND symbol extern ($IO$println)
   - Fixes "function not found" for builtin calls

Working features:
- println/print string output
- Multi-argument function calls
- Integer arithmetic (+, *, -, /)
- Conditional statements (if)
- User-defined functions with return values

Author: darmie

crates/compiler/src/lib.rs

@@ -319,11 +319,17 @@ pub fn register_impl_blocks(program: &mut zyntax_typed_ast::TypedProgram) -> Res
                 continue;
             }
 
-            // Find the trait by name
-            let trait_def = program.type_registry.get_trait_by_name(impl_block.trait_name)
-                .ok_or_else(|| {
-                    CompilerError::Analysis(format!("Trait {:?} not found in registry", impl_block.trait_name))
-                })?;
+            // Find the trait by name - be lenient if trait not found
+            let trait_def = match program.type_registry.get_trait_by_name(impl_block.trait_name) {
+                Some(t) => t,
+                None => {
+                    // Try to resolve trait name for better warning message
+                    let trait_name_str = impl_block.trait_name.resolve_global().unwrap_or_else(|| format!("{:?}", impl_block.trait_name));
+                    log::warn!("[REGISTER_IMPL] Trait '{}' not found in registry, skipping impl block", trait_name_str);
+                    eprintln!("[REGISTER_IMPL] WARNING: Trait '{}' not found, skipping impl block", trait_name_str);
+                    continue;
+                }
+            };
             let trait_id = trait_def.id;
             eprintln!("[REGISTER_IMPL] Trait ID: {:?}", trait_id);
 

crates/compiler/src/lowering.rs

@@ -1173,8 +1173,14 @@ impl LoweringContext {
 
         eprintln!("[CONVERT_SIG] Return type: TypedAST = {:?}", func.return_type);
         // Keep abstract types as nominal for method dispatch
-        let returns = vec![self.convert_type(&func.return_type)];
-        eprintln!("[CONVERT_SIG] Return type: HIR = {:?}", returns[0]);
+        // For void/unit functions, use empty returns vec (not vec![Void])
+        let hir_return_type = self.convert_type(&func.return_type);
+        let returns = if matches!(hir_return_type, HirType::Void) {
+            vec![] // Empty for void functions
+        } else {
+            vec![hir_return_type]
+        };
+        eprintln!("[CONVERT_SIG] Return type: HIR = {:?}", returns);
 
         // Convert type params from TypedFunction to HirTypeParam
         let hir_type_params: Vec<crate::hir::HirTypeParam> = func.type_params.iter().map(|tp| {

crates/compiler/src/ssa.rs

@@ -634,19 +634,33 @@ impl SsaBuilder {
                         }
                     }
 
+                    // Check if the function returns void - if so, ignore the expression value
+                    let is_void_return = matches!(
+                        &self.original_return_type,
+                        Some(Type::Primitive(zyntax_typed_ast::PrimitiveType::Unit)) | None
+                    );
+
                     // Check if the expression set a continuation block (for control flow expressions)
                     if let Some(continuation) = self.continuation_block.take() {
                         // Control flow expression - set Return on continuation block, not entry block
                         let cont_block = self.function.blocks.get_mut(&continuation)
                             .ok_or_else(|| crate::CompilerError::Analysis("Continuation block not found".into()))?;
-                        cont_block.terminator = HirTerminator::Return { values: vec![value_id] };
+                        cont_block.terminator = if is_void_return {
+                            HirTerminator::Return { values: vec![] }
+                        } else {
+                            HirTerminator::Return { values: vec![value_id] }
+                        };
 
                         // Entry block already has correct terminator (Branch/CondBranch), so return None
                         // to signal that we shouldn't overwrite it
                         return Ok(());
                     } else {
                         // Regular expression - return normally from entry block
-                        HirTerminator::Return { values: vec![value_id] }
+                        if is_void_return {
+                            HirTerminator::Return { values: vec![] }
+                        } else {
+                            HirTerminator::Return { values: vec![value_id] }
+                        }
                     }
                 } else {
                     HirTerminator::Return { values: vec![] }

crates/typed_ast/src/lib.rs

@@ -128,8 +128,8 @@ pub use typed_ast::{
     TypedMethodCall, TypedMethod, TypedMethodParam,
     // Range type
     TypedRange,
-    // List comprehension, slice, and import modifier types
-    TypedListComprehension, TypedSlice, TypedImportModifier,
+    // List comprehension, slice, import modifier, and path types
+    TypedListComprehension, TypedSlice, TypedImportModifier, TypedPath,
     // Struct type
     TypedStructLiteral, TypedFieldInit,
     // Pattern types

crates/typed_ast/src/type_checker.rs

@@ -1175,7 +1175,15 @@ impl TypeChecker {
                 if let Some((ty, _mutability)) = self.lookup_local(*name) {
                     Ok(ty.clone())
                 } else {
-                    Err(TypeError::UndefinedVariable(*name))
+                    // In lenient mode, unknown variables (likely external functions)
+                    // get a fresh type variable instead of an error.
+                    // This supports gradual typing where external symbols may not be
+                    // fully typed. The actual resolution happens at codegen time.
+                    if !self.options.no_implicit_any {
+                        Ok(self.inference.fresh_type_var())
+                    } else {
+                        Err(TypeError::UndefinedVariable(*name))
+                    }
                 }
             }
 
@@ -1213,6 +1221,10 @@ impl TypeChecker {
                 // The type is resolved to the target_type (e.g., Image, AudioBuffer)
                 Ok(Type::Unresolved(import.target_type))
             }
+            TypedExpression::Path(_) => {
+                // Path expressions need type resolution at a later stage
+                Ok(self.inference.fresh_type_var())
+            }
         }
     }
 
@@ -1357,13 +1369,36 @@ impl TypeChecker {
                 has_named_params,
                 has_default_params,
                 ..
-            } => (
+            } => Some((
                 params.clone(),
                 return_type.as_ref().clone(),
                 *has_named_params,
                 *has_default_params,
-            ),
+            )),
+            // In lenient mode, unknown types (type variables, Any, Unknown) are allowed
+            // for function calls. We just check argument expressions and return a fresh type var.
+            Type::TypeVar(_) | Type::Any | Type::Unknown => {
+                // Check argument expressions for side effects and type consistency
+                for arg in &call.positional_args {
+                    self.check_expression(&arg.node)?;
+                }
+                for arg in &call.named_args {
+                    self.check_expression(&arg.value.node)?;
+                }
+                // Return fresh type variable since we don't know the return type
+                return Ok(self.inference.fresh_type_var());
+            }
             _ => {
+                if !self.options.no_implicit_any {
+                    // Lenient mode: allow unknown call types
+                    for arg in &call.positional_args {
+                        self.check_expression(&arg.node)?;
+                    }
+                    for arg in &call.named_args {
+                        self.check_expression(&arg.value.node)?;
+                    }
+                    return Ok(self.inference.fresh_type_var());
+                }
                 return Err(TypeError::TypeMismatch {
                     expected: Type::Function {
                         params: vec![],
@@ -1380,6 +1415,12 @@ impl TypeChecker {
             }
         };
 
+        // If we don't have function type info, early return already happened above
+        let func_type = match func_type {
+            Some(ft) => ft,
+            None => return Ok(self.inference.fresh_type_var()),
+        };
+
         let (expected_params, return_type, has_named_params, has_default_params) = func_type;
 
         // Validate argument counts and types

crates/typed_ast/src/typed_ast.rs

@@ -524,6 +524,8 @@ pub enum TypedExpression {
     Slice(TypedSlice),
     /// Import modifier expression: import loader("path") as Type
     ImportModifier(TypedImportModifier),
+    /// Path expression: Type::method or module::function
+    Path(TypedPath),
 }
 
 impl Default for TypedExpression {
@@ -935,6 +937,17 @@ pub struct TypedImportModifier {
     pub target_type: InternedString,
 }
 
+/// Path expression: Type::method or module::function
+///
+/// Used for associated functions (static methods) and qualified paths.
+///
+/// Example: `Tensor::zeros`, `std::Option::Some`
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TypedPath {
+    /// Path segments (e.g., ["Tensor", "zeros"] for Tensor::zeros)
+    pub segments: Vec<InternedString>,
+}
+
 /// Method call with enhanced argument support
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TypedMethodCall {