feat: Add struct instantiation syntax to zig.zyn grammar

- Add struct_init rule for `Point{ .x = 10, .y = 20 }` syntax
- Add struct_init_fields and struct_init_field rules
- Add store_struct_field_init and get_struct_field_init to AstHostFunctions
- Add struct_field_inits storage to TypedAstBuilder
- Implement struct_init and struct_field_init handlers in define_node

The parsing and TypedAST generation work correctly. Full type inference
for struct variables requires lowering layer changes.

Author: darmie

crates/zyn_peg/grammars/zig.zyn

@@ -481,11 +481,31 @@ call_args = { expr ~ ("," ~ expr)* }
   }
 
 // Atom: the base of postfix expressions
-atom = { try_expr | array_literal | bool_literal | string_literal | integer_literal | identifier_expr | paren_expr }
+atom = { try_expr | struct_init | array_literal | bool_literal | string_literal | integer_literal | identifier_expr | paren_expr }
   -> TypedExpression {
       "get_child": { "index": 0 }
   }
 
+// Struct instantiation: Point{ .x = 10, .y = 20 }
+struct_init = { identifier ~ "{" ~ struct_init_fields? ~ "}" }
+  -> TypedExpression {
+      "commands": [
+          { "define": "struct_init", "args": { "type_name": "$1", "fields": "$2" } }
+      ]
+  }
+
+struct_init_fields = { struct_init_field ~ ("," ~ struct_init_field)* ~ ","? }
+  -> List {
+      "get_all_children": true
+  }
+
+struct_init_field = { "." ~ identifier ~ "=" ~ expr }
+  -> TypedExpression {
+      "commands": [
+          { "define": "struct_field_init", "args": { "name": "$1", "value": "$2" } }
+      ]
+  }
+
 // Try expression: try expr
 try_expr = { "try" ~ primary }
   -> TypedExpression {

crates/zyn_peg/src/runtime.rs

@@ -279,6 +279,12 @@ pub trait AstHostFunctions {
     /// Create a struct literal expression
     fn create_struct_literal(&mut self, name: &str, fields: Vec<(String, NodeHandle)>) -> NodeHandle;
 
+    /// Store a struct field initialization (for later lookup by struct_init)
+    fn store_struct_field_init(&mut self, name: &str, value: NodeHandle) -> NodeHandle;
+
+    /// Get a stored struct field initialization
+    fn get_struct_field_init(&self, handle: NodeHandle) -> Option<(String, NodeHandle)>;
+
     /// Create a cast expression
     fn create_cast(&mut self, expr: NodeHandle, target_type: NodeHandle) -> NodeHandle;
 
@@ -840,6 +846,8 @@ pub struct TypedAstBuilder {
     fields: HashMap<NodeHandle, TypedField>,
     /// Stored variant nodes by handle
     variants: HashMap<NodeHandle, TypedVariant>,
+    /// Stored struct field initializers (name, value) by handle
+    struct_field_inits: HashMap<NodeHandle, (String, NodeHandle)>,
     /// Program declaration handles (in order)
     program_decls: Vec<NodeHandle>,
 }
@@ -861,6 +869,7 @@ impl TypedAstBuilder {
             declarations: HashMap::new(),
             fields: HashMap::new(),
             variants: HashMap::new(),
+            struct_field_inits: HashMap::new(),
             program_decls: Vec::new(),
         }
     }
@@ -1536,6 +1545,16 @@ impl AstHostFunctions for TypedAstBuilder {
         self.store_expr(expr)
     }
 
+    fn store_struct_field_init(&mut self, name: &str, value: NodeHandle) -> NodeHandle {
+        let handle = self.alloc_handle();
+        self.struct_field_inits.insert(handle, (name.to_string(), value));
+        handle
+    }
+
+    fn get_struct_field_init(&self, handle: NodeHandle) -> Option<(String, NodeHandle)> {
+        self.struct_field_inits.get(&handle).cloned()
+    }
+
     fn create_cast(&mut self, expr_handle: NodeHandle, _target_type: NodeHandle) -> NodeHandle {
         let span = self.default_span();
 
@@ -2225,6 +2244,47 @@ impl<'a, H: AstHostFunctions> CommandInterpreter<'a, H> {
                 Ok(RuntimeValue::Node(handle))
             }
 
+            // Struct instantiation: Point{ .x = 10, .y = 20 }
+            "struct_init" => {
+                let type_name = match args.get("type_name") {
+                    Some(RuntimeValue::String(s)) => s.clone(),
+                    _ => "AnonymousStruct".to_string(),
+                };
+                // Fields come as a list of struct_field_init results
+                // Each struct_field_init stores (name, value) in host's struct_init_fields map
+                let fields: Vec<(String, NodeHandle)> = match args.get("fields") {
+                    Some(RuntimeValue::List(list)) => {
+                        list.iter()
+                            .filter_map(|v| match v {
+                                RuntimeValue::Node(h) => {
+                                    // Look up the field init data from host
+                                    self.host.get_struct_field_init(*h)
+                                }
+                                _ => None,
+                            })
+                            .collect()
+                    }
+                    _ => vec![],
+                };
+                let handle = self.host.create_struct_literal(&type_name, fields);
+                Ok(RuntimeValue::Node(handle))
+            }
+
+            // Struct field initialization: .x = 10
+            "struct_field_init" => {
+                let name = match args.get("name") {
+                    Some(RuntimeValue::String(s)) => s.clone(),
+                    _ => "field".to_string(),
+                };
+                let value = match args.get("value") {
+                    Some(RuntimeValue::Node(h)) => *h,
+                    _ => return Err(crate::error::ZynPegError::CodeGenError("struct_field_init: missing value".into())),
+                };
+                // Store field init and return a handle for later lookup
+                let handle = self.host.store_struct_field_init(&name, value);
+                Ok(RuntimeValue::Node(handle))
+            }
+
             "cast" => {
                 let expr = match args.get("expr") {
                     Some(RuntimeValue::Node(h)) => *h,