fix: resolve Type::Unresolved and Type::Any in struct initialization

- Add Type::Unresolved handler to ssa.rs convert_type() to look up
  types by name in TypeRegistry instead of defaulting to I64
- Add Type::Unresolved handler to lowering.rs convert_type() with
  proper Named type construction
- Add Type::Any handler in ssa.rs for future type inference support
- Fix TypedStatement::Let to use Type::Any when no type annotation
  is provided, allowing inference from initializer
- Register struct/class types in type registry before lowering in
  zyn_grammar.rs lower_to_hir() function
- Use program's type registry instead of creating empty one

This enables struct initialization with type inference:
  const p = Point{ .x = 10, .y = 20 };

The variable 'p' now correctly gets the Point struct type instead
of defaulting to I32.

Author: darmie

crates/compiler/src/lowering.rs

@@ -1264,12 +1264,23 @@ impl LoweringContext {
             }
 
             Type::Unresolved(name) => {
-                // Look up the type in TypeRegistry aliases
+                // Look up the type in TypeRegistry - first try aliases, then try named types
                 eprintln!("[DEBUG convert_type] Resolving unresolved type '{}'", name.resolve_global().unwrap_or_default());
                 if let Some(resolved_type) = self.type_registry.resolve_alias(*name) {
                     eprintln!("[DEBUG convert_type] Found alias for '{}': {:?}", name.resolve_global().unwrap_or_default(), resolved_type);
                     // Recursively convert the resolved type
                     self.convert_type(resolved_type)
+                } else if let Some(type_def) = self.type_registry.get_type_by_name(*name) {
+                    // Found a named type (struct, enum, etc.) - convert it as Named type
+                    eprintln!("[DEBUG convert_type] Found named type for '{}': {:?}", name.resolve_global().unwrap_or_default(), type_def.kind);
+                    let named_type = Type::Named {
+                        id: type_def.id,
+                        type_args: vec![],
+                        const_args: vec![],
+                        variance: vec![],
+                        nullability: zyntax_typed_ast::type_registry::NullabilityKind::NonNull,
+                    };
+                    self.convert_type(&named_type)
                 } else {
                     eprintln!("[WARN] Could not resolve type '{}', defaulting to I64", name.resolve_global().unwrap_or_default());
                     HirType::I64 // Fallback

crates/compiler/src/ssa.rs

@@ -3286,6 +3286,51 @@ impl SsaBuilder {
                     HirType::I64
                 }
             },
+            Type::Unresolved(name) => {
+                // Look up the type in TypeRegistry by name and convert as Named type
+                if let Some(type_def) = self.type_registry.get_type_by_name(*name) {
+                    use crate::hir::HirStructType;
+                    use zyntax_typed_ast::type_registry::TypeKind;
+
+                    eprintln!("[CONVERT TYPE SSA] Unresolved type '{}' → resolved to {:?}",
+                        name.resolve_global().unwrap_or_default(),
+                        type_def.kind);
+
+                    // Abstract types are zero-cost wrappers with struct layout
+                    if let TypeKind::Abstract { .. } = &type_def.kind {
+                        let hir_fields: Vec<HirType> = type_def.fields.iter()
+                            .map(|field| self.convert_type(&field.ty))
+                            .collect();
+
+                        return HirType::Struct(HirStructType {
+                            name: Some(type_def.name),
+                            fields: hir_fields,
+                            packed: false,
+                        });
+                    }
+
+                    // Regular types (structs, classes, enums) convert to struct types
+                    let hir_fields: Vec<HirType> = type_def.fields.iter()
+                        .map(|field| self.convert_type(&field.ty))
+                        .collect();
+
+                    HirType::Struct(HirStructType {
+                        name: Some(type_def.name),
+                        fields: hir_fields,
+                        packed: false,
+                    })
+                } else {
+                    eprintln!("[WARN] Unresolved type '{}' not found in registry, defaulting to I64",
+                        name.resolve_global().unwrap_or_default());
+                    HirType::I64
+                }
+            },
+            Type::Any => {
+                // Type::Any means "infer from context" - we need to check the initializer's type
+                // For now, default to I64 but this should be improved
+                eprintln!("[WARN] Type::Any encountered in convert_type, defaulting to I64");
+                HirType::I64
+            },
             _ => HirType::I64, // Default for complex types
         }
     }

crates/zyn_peg/src/runtime2/interpreter.rs

@@ -294,7 +294,8 @@ impl<'g> GrammarInterpreter<'g> {
                 let initializer = self.get_field_optional_expr("initializer", fields, state)?;
                 let is_mutable = self.get_field_as_bool("is_mutable", fields, state).unwrap_or(false);
 
-                let ty = type_annotation.unwrap_or(Type::Primitive(PrimitiveType::I32));
+                // Use Type::Any when no type annotation is provided - let the compiler infer from initializer
+                let ty = type_annotation.unwrap_or(Type::Any);
                 let mutability = if is_mutable { Mutability::Mutable } else { Mutability::Immutable };
 
                 TypedStatement::Let(TypedLet {
@@ -537,6 +538,8 @@ impl<'g> GrammarInterpreter<'g> {
             // Use Type::Any to signal that lowering should infer the type
             TypedExpression::Call(_) => Type::Any,
             TypedExpression::Variable(_) => Type::Any,
+            // Struct literal gets its type from the struct name - use Unresolved for compiler to resolve
+            TypedExpression::Struct(lit) => Type::Unresolved(lit.name),
             _ => Type::Primitive(PrimitiveType::Unit),
         };
 

crates/zyntax_cli/src/formats/zyn_grammar.rs

@@ -396,9 +396,65 @@ fn lower_to_hir(
     mut program: TypedProgram,
     verbose: bool,
 ) -> Result<HirModule, Box<dyn std::error::Error>> {
+    use zyntax_typed_ast::{TypedDeclaration, type_registry::*};
+
+    // Register struct/class types in the type registry before lowering
+    // This is needed because the Grammar2 parser creates TypedDeclaration::Class
+    // but doesn't register them in the type registry
+    for decl_node in &program.declarations {
+        if let TypedDeclaration::Class(class) = &decl_node.node {
+            // Check if type is already registered
+            if program.type_registry.get_type_by_name(class.name).is_some() {
+                if verbose {
+                    eprintln!("[DEBUG] Type '{}' already registered, skipping",
+                        class.name.resolve_global().unwrap_or_default());
+                }
+                continue;
+            }
+
+            // Register the struct type
+            let type_id = TypeId::next();
+            let fields: Vec<FieldDef> = class.fields.iter().map(|f| {
+                FieldDef {
+                    name: f.name,
+                    ty: f.ty.clone(),
+                    visibility: f.visibility,
+                    mutability: f.mutability,
+                    is_static: f.is_static,
+                    is_synthetic: false,
+                    span: f.span,
+                    getter: None,
+                    setter: None,
+                }
+            }).collect();
+
+            let type_def = TypeDefinition {
+                id: type_id,
+                name: class.name,
+                kind: TypeKind::Struct {
+                    fields: fields.clone(),
+                    is_tuple: false,
+                },
+                type_params: vec![],
+                constraints: vec![],
+                fields,
+                methods: vec![],
+                constructors: vec![],
+                metadata: Default::default(),
+                span: class.span,
+            };
+            program.type_registry.register_type(type_def);
+            if verbose {
+                eprintln!("[DEBUG] Registered struct type '{}' with TypeId {:?}",
+                    class.name.resolve_global().unwrap_or_default(), type_id);
+            }
+        }
+    }
+
     let arena = AstArena::new();
     let module_name = InternedString::new_global("main");
-    let type_registry = Arc::new(TypeRegistry::new());
+    // Use the program's type registry which now has registered types
+    let type_registry = Arc::new(program.type_registry.clone());
 
     let mut lowering_ctx = LoweringContext::new(
         module_name,