fix(compiler): GEP byte offset handling and F32 float literals

- Add U8/I8 scalar type handling in Cranelift GEP for byte-level offsets
- Add float_literal() method to TypedASTBuilder (defaults to F32)
- Add translate_literal_with_type() for type-aware literal conversion
- Float literals now correctly use F32 for ML workloads

This fixes tensor array construction which was storing F64 values into
F32 slots, causing the tensor data to be corrupted.

Author: darmie

crates/compiler/src/cranelift_backend.rs

@@ -1162,8 +1162,15 @@ impl CraneliftBackend {
                                             warn!(" No struct layout found for GEP");
                                         }
                                     }
+                                    // For scalar types (U8, I8, etc.), treat as byte-level pointer arithmetic
+                                    // This is used when the SSA layer wants to do direct byte offset calculation
+                                    HirType::U8 | HirType::I8 => {
+                                        // Index is already a byte offset, just add it
+                                        current_ptr = builder.ins().iadd(current_ptr, index);
+                                        // Type stays the same for subsequent indices
+                                    }
                                     _ => {
-                                        warn!(" GEP on unsupported type");
+                                        warn!(" GEP on unsupported type: {:?}", current_type);
                                         break;
                                     }
                                 }

crates/compiler/src/ssa.rs

@@ -1330,8 +1330,8 @@ impl SsaBuilder {
                 if let TypedLiteral::String(s) = lit {
                     Ok(self.create_string_global(*s))
                 } else {
-                    let constant = self.translate_literal(lit);
                     let ty = self.convert_type(&expr.ty);
+                    let constant = self.translate_literal_with_type(lit, &ty);
                     Ok(self.create_value(ty, HirValueKind::Constant(constant)))
                 }
             }
@@ -3168,16 +3168,27 @@ impl SsaBuilder {
         }
     }
 
-    /// Translate literal to constant
+    /// Translate literal to constant (legacy - always uses default types)
     fn translate_literal(&self, lit: &zyntax_typed_ast::typed_ast::TypedLiteral) -> crate::hir::HirConstant {
+        self.translate_literal_with_type(lit, &HirType::I32)
+    }
+
+    /// Translate literal to constant with target type information
+    fn translate_literal_with_type(&self, lit: &zyntax_typed_ast::typed_ast::TypedLiteral, target_ty: &HirType) -> crate::hir::HirConstant {
         use zyntax_typed_ast::typed_ast::TypedLiteral;
         use crate::hir::HirConstant;
 
         match lit {
             TypedLiteral::Bool(b) => HirConstant::Bool(*b),
             // Use I32 for integers (TypedAST builder defaults to I32)
             TypedLiteral::Integer(i) => HirConstant::I32(*i as i32),
-            TypedLiteral::Float(f) => HirConstant::F64(*f),
+            // Float literals use the target type (F32 or F64)
+            TypedLiteral::Float(f) => {
+                match target_ty {
+                    HirType::F32 => HirConstant::F32(*f as f32),
+                    _ => HirConstant::F64(*f),
+                }
+            }
             TypedLiteral::String(s) => HirConstant::String(*s),
             TypedLiteral::Char(c) => HirConstant::I32(*c as i32),
             TypedLiteral::Unit => HirConstant::Struct(vec![]),

crates/typed_ast/src/typed_builder.rs

@@ -103,6 +103,24 @@ impl TypedASTBuilder {
         )
     }
 
+    /// Build float literal (defaults to F32 for ML-focused usage)
+    pub fn float_literal(&mut self, value: f64, span: Span) -> TypedNode<TypedExpression> {
+        typed_node(
+            TypedExpression::Literal(TypedLiteral::Float(value)),
+            Type::Primitive(PrimitiveType::F32),
+            span,
+        )
+    }
+
+    /// Build F64 float literal
+    pub fn float64_literal(&mut self, value: f64, span: Span) -> TypedNode<TypedExpression> {
+        typed_node(
+            TypedExpression::Literal(TypedLiteral::Float(value)),
+            Type::Primitive(PrimitiveType::F64),
+            span,
+        )
+    }
+
     /// Build string literal
     pub fn string_literal(&mut self, value: &str, span: Span) -> TypedNode<TypedExpression> {
         let interned = self.intern(value);

crates/zyn_peg/src/runtime.rs

@@ -1482,9 +1482,7 @@ impl AstHostFunctions for TypedAstBuilder {
 
     fn create_float_literal(&mut self, value: f64) -> NodeHandle {
         let span = self.default_span();
-        // TypedASTBuilder doesn't have float_literal, use string_literal workaround for now
-        // or we could add a float literal type
-        let expr = self.inner.int_literal(value as i128, span);
+        let expr = self.inner.float_literal(value, span);
         self.store_expr(expr)
     }