lowering: add implicit numeric casts and type-aware cast ops

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -5566,7 +5566,9 @@ impl CraneliftBackend {
                         result
                     }
                     crate::hir::CastOp::Trunc => builder.ins().ireduce(target_ty, val),
+                    crate::hir::CastOp::FpToUi => builder.ins().fcvt_to_uint(target_ty, val),
                     crate::hir::CastOp::FpToSi => builder.ins().fcvt_to_sint(target_ty, val),
+                    crate::hir::CastOp::UiToFp => builder.ins().fcvt_from_uint(target_ty, val),
                     crate::hir::CastOp::SiToFp => builder.ins().fcvt_from_sint(target_ty, val),
                     crate::hir::CastOp::FpExt => builder.ins().fpromote(target_ty, val),
                     crate::hir::CastOp::FpTrunc => builder.ins().fdemote(target_ty, val),

crates/compiler/src/lowering.rs

@@ -4276,8 +4276,81 @@ impl LoweringContext {
         None
     }
 
+    fn can_implicitly_convert_numeric(
+        from: zyntax_typed_ast::PrimitiveType,
+        to: zyntax_typed_ast::PrimitiveType,
+    ) -> bool {
+        use zyntax_typed_ast::PrimitiveType::*;
+
+        if from == to {
+            return true;
+        }
+
+        match (from, to) {
+            // Widening signed integer conversions
+            (I8, I16 | I32 | I64 | I128) => true,
+            (I16, I32 | I64 | I128) => true,
+            (I32, I64 | I128) => true,
+            (I64, I128) => true,
+
+            // Widening unsigned integer conversions
+            (U8, U16 | U32 | U64 | U128) => true,
+            (U16, U32 | U64 | U128) => true,
+            (U32, U64 | U128) => true,
+            (U64, U128) => true,
+
+            // Float widening
+            (F32, F64) => true,
+
+            // Integer to float promotions
+            (I8 | I16 | I32, F32 | F64) => true,
+            (I64, F64) => true,
+            (U8 | U16 | U32, F32 | F64) => true,
+            (U64, F64) => true,
+
+            // Platform-sized integers (conservative defaults)
+            (ISize, I64 | I128 | F64) => true,
+            (USize, U64 | U128 | F64) => true,
+
+            _ => false,
+        }
+    }
+
+    fn try_implicit_numeric_conversion(
+        &self,
+        expr: zyntax_typed_ast::TypedNode<zyntax_typed_ast::TypedExpression>,
+        expected_type: &Type,
+    ) -> Option<zyntax_typed_ast::TypedNode<zyntax_typed_ast::TypedExpression>> {
+        use zyntax_typed_ast::{typed_ast::typed_node, TypedCast, TypedExpression};
+
+        let source_prim = match expr.ty {
+            Type::Primitive(p) if p.is_numeric() => p,
+            _ => return None,
+        };
+
+        let target_prim = match expected_type {
+            Type::Primitive(p) if p.is_numeric() => *p,
+            _ => return None,
+        };
+
+        if !Self::can_implicitly_convert_numeric(source_prim, target_prim) {
+            return None;
+        }
+
+        let span = expr.span;
+        Some(typed_node(
+            TypedExpression::Cast(TypedCast {
+                expr: Box::new(expr),
+                target_type: expected_type.clone(),
+            }),
+            expected_type.clone(),
+            span,
+        ))
+    }
+
     /// Try to insert an implicit From conversion if types don't match
-    /// Returns a new expression wrapped in Type::from() if conversion is available
+    /// Returns a new expression wrapped in either an implicit numeric cast
+    /// or Type::from() call when available.
     fn try_implicit_from_conversion(
         &self,
         expr: zyntax_typed_ast::TypedNode<zyntax_typed_ast::TypedExpression>,
@@ -4297,6 +4370,11 @@ impl LoweringContext {
             return None;
         }
 
+        // Prefer direct numeric casts for primitive numeric conversions.
+        if let Some(cast_expr) = self.try_implicit_numeric_conversion(expr.clone(), expected_type) {
+            return Some(cast_expr);
+        }
+
         // Check if there's a From<expr.ty> impl for expected_type
         if let Some(from_func) = self.find_from_impl(&expr.ty, expected_type) {
             eprintln!(

crates/compiler/src/ssa.rs

@@ -1531,6 +1531,84 @@ impl SsaBuilder {
         self.translate_expression(block_id, &lowered_expr)
     }
 
+    fn int_type_width_and_sign(ty: &HirType) -> Option<(u8, bool)> {
+        match ty {
+            HirType::I8 => Some((8, true)),
+            HirType::I16 => Some((16, true)),
+            HirType::I32 => Some((32, true)),
+            HirType::I64 => Some((64, true)),
+            HirType::I128 => Some((128, true)),
+            HirType::U8 => Some((8, false)),
+            HirType::U16 => Some((16, false)),
+            HirType::U32 => Some((32, false)),
+            HirType::U64 => Some((64, false)),
+            HirType::U128 => Some((128, false)),
+            _ => None,
+        }
+    }
+
+    fn float_type_width(ty: &HirType) -> Option<u8> {
+        match ty {
+            HirType::F32 => Some(32),
+            HirType::F64 => Some(64),
+            _ => None,
+        }
+    }
+
+    fn select_cast_op(&self, source_ty: &HirType, target_ty: &HirType) -> CastOp {
+        use CastOp::*;
+
+        if source_ty == target_ty {
+            return Bitcast;
+        }
+
+        if let (Some((src_bits, src_signed)), Some((dst_bits, _dst_signed))) = (
+            Self::int_type_width_and_sign(source_ty),
+            Self::int_type_width_and_sign(target_ty),
+        ) {
+            if src_bits > dst_bits {
+                return Trunc;
+            }
+            if src_bits < dst_bits {
+                return if src_signed { SExt } else { ZExt };
+            }
+            return Bitcast;
+        }
+
+        if let (Some(src_bits), Some(dst_bits)) = (
+            Self::float_type_width(source_ty),
+            Self::float_type_width(target_ty),
+        ) {
+            if src_bits < dst_bits {
+                return FpExt;
+            }
+            if src_bits > dst_bits {
+                return FpTrunc;
+            }
+            return Bitcast;
+        }
+
+        if let (Some((_src_bits, src_signed)), Some(_dst_float_bits)) = (
+            Self::int_type_width_and_sign(source_ty),
+            Self::float_type_width(target_ty),
+        ) {
+            return if src_signed { SiToFp } else { UiToFp };
+        }
+
+        if let (Some(_src_float_bits), Some((_dst_bits, dst_signed))) = (
+            Self::float_type_width(source_ty),
+            Self::int_type_width_and_sign(target_ty),
+        ) {
+            return if dst_signed { FpToSi } else { FpToUi };
+        }
+
+        match (source_ty, target_ty) {
+            (HirType::Ptr(_), HirType::I64 | HirType::U64) => PtrToInt,
+            (HirType::I64 | HirType::U64, HirType::Ptr(_)) => IntToPtr,
+            _ => Bitcast,
+        }
+    }
+
     /// Translate expression to SSA value
     fn translate_expression(
         &mut self,
@@ -2535,17 +2613,10 @@ impl SsaBuilder {
 
             TypedExpression::Cast(cast) => {
                 let operand_val = self.translate_expression(block_id, &cast.expr)?;
+                let source_ty = self.convert_type(&cast.expr.ty);
                 let target_ty = self.convert_type(&cast.target_type);
                 let result = self.create_value(target_ty.clone(), HirValueKind::Instruction);
-
-                // NOTE: Proper cast operation selection requires type information.
-                // Should determine: IntToInt, IntToFloat, FloatToInt, FloatToFloat, Bitcast, etc.
-                // Needs source type width, target type width, signedness information.
-                //
-                // WORKAROUND: Always uses Bitcast (works for pointer casts and same-size conversions)
-                // FUTURE (v2.0): Add type-aware cast selection logic
-                // Estimated effort: 4-5 hours (needs type width/signedness utilities)
-                let cast_op = CastOp::Bitcast;
+                let cast_op = self.select_cast_op(&source_ty, &target_ty);
 
                 self.add_instruction(
                     block_id,

crates/zynml/tests/e2e_tests.rs

@@ -3639,6 +3639,62 @@ mod execution {
         );
     }
 
+    #[test]
+    fn test_execute_implicit_numeric_casts_in_assignments() {
+        let Some(mut zynml) = create_runtime_with_plugins() else {
+            println!("Skipping: plugins not available");
+            return;
+        };
+
+        let source = r#"
+            fn numeric_assignment_casts() {
+                let a: i64 = 41
+                let b: f64 = a
+                let c: i16 = 7
+                let d: i64 = c
+                let e: f64 = c
+            }
+        "#;
+
+        let functions = zynml
+            .load_source(source)
+            .expect("numeric assignment casts should compile");
+        assert!(
+            functions.iter().any(|f| f == "numeric_assignment_casts"),
+            "numeric_assignment_casts should be exported"
+        );
+    }
+
+    #[test]
+    fn test_execute_implicit_numeric_casts_in_call_args() {
+        let Some(mut zynml) = create_runtime_with_plugins() else {
+            println!("Skipping: plugins not available");
+            return;
+        };
+
+        let source = r#"
+            fn takes_i64(x: i64) {
+                let _copy = x
+            }
+
+            fn callsite() {
+                takes_i64(5)
+            }
+        "#;
+
+        let functions = zynml
+            .load_source(source)
+            .expect("numeric call-arg casts should compile");
+        assert!(
+            functions.iter().any(|f| f == "takes_i64"),
+            "takes_i64 should be exported"
+        );
+        assert!(
+            functions.iter().any(|f| f == "callsite"),
+            "callsite should be exported"
+        );
+    }
+
     // Regression coverage for the full hello example (prelude + tensor + dynamic println).
     // Keep panic isolation via catch_unwind so runtime regressions produce actionable test output.
     #[test]