kain/
parser.rs

1//! KAIN Parser - Python-style indentation with Rust semantics
2
3use crate::lexer::{Lexer, Token, TokenKind};
4use crate::ast::*;
5use crate::span::Span;
6use crate::effects::Effect;
7use crate::error::{KainError, KainResult};
8
9pub struct Parser<'a> {
10    tokens: &'a [Token],
11    pos: usize,
12}
13
14impl<'a> Parser<'a> {
15    pub fn new(tokens: &'a [Token]) -> Self {
16        Self { tokens, pos: 0 }
17    }
18
19    pub fn parse(&mut self) -> KainResult<Program> {
20        let mut items = Vec::new();
21        let mut top_level_stmts = Vec::new();
22        let start = self.current_span();
23        
24        while !self.at_end() {
25            self.skip_newlines();
26            if self.at_end() { break; }
27            
28            match self.peek_kind() {
29                TokenKind::Pub | 
30                TokenKind::At |  
31                TokenKind::Fn | 
32                TokenKind::AsyncKw |
33                TokenKind::Component | 
34                TokenKind::Shader | 
35                TokenKind::Struct | 
36                TokenKind::Enum | 
37                TokenKind::Actor | 
38                TokenKind::Const | 
39                TokenKind::Comptime |
40                TokenKind::Macro |
41                TokenKind::Use |
42                TokenKind::Impl |
43                TokenKind::Test => {
44                    items.push(self.parse_item()?);
45                }
46                _ => {
47                    top_level_stmts.push(self.parse_stmt()?);
48                }
49            }
50        }
51        
52        if !top_level_stmts.is_empty() {
53            let main_fn = Item::Function(Function {
54                name: "main".to_string(),
55                generics: vec![],
56                params: vec![],
57                return_type: None,
58                effects: vec![],
59                body: Block { stmts: top_level_stmts, span: start.merge(self.current_span()) },
60                visibility: Visibility::Public,
61                attributes: vec![],
62                span: start.merge(self.current_span()),
63            });
64            items.push(main_fn);
65        }
66        
67        let end = self.current_span();
68        Ok(Program { items, span: start.merge(end) })
69    }
70
71    fn parse_item(&mut self) -> KainResult<Item> {
72        // Collect any @attr decorators first
73        let attributes = self.parse_attributes()?;
74        let vis = self.parse_visibility();
75        
76        match self.peek_kind() {
77            TokenKind::Fn => self.parse_function_with_attrs(vis, attributes),
78            TokenKind::AsyncKw => self.parse_async_function(vis),
79            TokenKind::Component => self.parse_component_with_attrs(vis, attributes),
80            TokenKind::Shader => self.parse_shader(),
81            TokenKind::Struct => self.parse_struct(vis),
82            TokenKind::Enum => self.parse_enum(vis),
83            TokenKind::Actor => self.parse_actor(),
84            TokenKind::Const => self.parse_const(vis),
85            TokenKind::Comptime => self.parse_comptime_block(),
86            TokenKind::Macro => self.parse_macro(),
87            TokenKind::Test => self.parse_test(),
88            TokenKind::Use => self.parse_use(),
89            TokenKind::Impl => self.parse_impl(),
90            _ => Err(KainError::parser("Expected item", self.current_span())),
91        }
92    }
93
94    // Parse @wasm, @js, @inline etc decorators
95    fn parse_attributes(&mut self) -> KainResult<Vec<Attribute>> {
96        let mut attrs = Vec::new();
97        while self.check(TokenKind::At) {
98            let start = self.current_span();
99            self.advance(); // consume @
100            let name = self.parse_ident()?;
101            
102            // Optional args: @attr(arg1, arg2)
103            let args = if self.check(TokenKind::LParen) {
104                self.advance();
105                let mut arg_list = Vec::new();
106                while !self.check(TokenKind::RParen) && !self.at_end() {
107                    arg_list.push(self.parse_expr()?);
108                    if !self.check(TokenKind::RParen) {
109                        self.expect(TokenKind::Comma)?;
110                    }
111                }
112                self.expect(TokenKind::RParen)?;
113                arg_list
114            } else {
115                vec![]
116            };
117            
118            attrs.push(Attribute { name, args, span: start.merge(self.current_span()) });
119            self.skip_newlines();
120        }
121        Ok(attrs)
122    }
123
124    fn parse_impl(&mut self) -> KainResult<Item> {
125        let start = self.current_span();
126        self.expect(TokenKind::Impl)?;
127        
128        // Parse impl-level generics: impl<T>
129        let generics = self.parse_generics()?;
130        
131        // Parse target type: Option<T>
132        // Note: Currently assumes "impl Type". To support "impl Trait for Type", we'd check for 'for'.
133        let target_type = self.parse_type()?;
134        
135        self.expect(TokenKind::Colon)?;
136        self.skip_newlines();
137        self.expect(TokenKind::Indent)?;
138        
139        let mut methods = Vec::new();
140        
141        while !self.check(TokenKind::Dedent) && !self.at_end() {
142            self.skip_newlines();
143            if self.check(TokenKind::Dedent) { break; }
144            
145            let vis = self.parse_visibility();
146            if self.check(TokenKind::Fn) {
147                if let Item::Function(f) = self.parse_function(vis)? {
148                    methods.push(f);
149                }
150            } else {
151                return Err(KainError::parser("Expected fn in impl block", self.current_span()));
152            }
153            self.skip_newlines();
154        }
155        
156        if self.check(TokenKind::Dedent) {
157            self.advance();
158        }
159        
160        Ok(Item::Impl(Impl {
161            generics,
162            trait_name: None,
163            target_type,
164            methods,
165            span: start.merge(self.current_span()),
166        }))
167    }
168
169    fn parse_use(&mut self) -> KainResult<Item> {
170        let start = self.current_span();
171        self.expect(TokenKind::Use)?;
172        
173        let mut path = Vec::new();
174        path.push(self.parse_ident()?);
175        
176        // Parse path: use foo::bar::baz OR use foo/bar/baz
177        while self.check(TokenKind::ColonColon) || self.check(TokenKind::Slash) {
178            self.advance();
179            
180            // Check for glob: use foo::*
181            if self.check(TokenKind::Star) {
182                self.advance();
183                return Ok(Item::Use(Use { 
184                    path, 
185                    alias: None, 
186                    glob: true, 
187                    span: start.merge(self.current_span()) 
188                }));
189            }
190            
191            path.push(self.parse_ident()?);
192        }
193        
194        // Check for alias: use foo::bar as baz
195        let alias = if self.check(TokenKind::As) {
196            self.advance();
197            Some(self.parse_ident()?)
198        } else {
199            None
200        };
201        
202        Ok(Item::Use(Use { 
203            path, 
204            alias, 
205            glob: false, 
206            span: start.merge(self.current_span()) 
207        }))
208    }
209
210    fn parse_test(&mut self) -> KainResult<Item> {
211        let start = self.current_span();
212        self.expect(TokenKind::Test)?;
213        // Tests can have a string name or identifier
214        let name = if let TokenKind::String(s) = self.peek_kind() {
215            self.advance();
216            s
217        } else {
218            self.parse_ident()?
219        };
220        
221        self.expect(TokenKind::Colon)?;
222        let body = self.parse_block()?;
223        Ok(Item::Test(TestDef { name, body, span: start.merge(self.current_span()) }))
224    }
225
226    fn parse_macro(&mut self) -> KainResult<Item> {
227        let start = self.current_span();
228        self.expect(TokenKind::Macro)?;
229        let name = self.parse_ident()?;
230        self.expect(TokenKind::Not)?; // macro name!
231        self.expect(TokenKind::LParen)?;
232        
233        let mut params = Vec::new();
234        while !self.check(TokenKind::RParen) {
235            let p_name = self.parse_ident()?;
236            self.expect(TokenKind::Colon)?;
237            let kind_name = self.parse_ident()?;
238            let kind = match kind_name.as_str() {
239                "expr" => MacroParamKind::Expr,
240                "type" => MacroParamKind::Type,
241                "ident" => MacroParamKind::Ident,
242                "block" => MacroParamKind::Block,
243                "token" => MacroParamKind::Token,
244                _ => return Err(KainError::parser("Unknown macro param kind", self.current_span())),
245            };
246            params.push(MacroParam { name: p_name, kind, span: self.current_span() });
247            
248            if !self.check(TokenKind::RParen) {
249                self.expect(TokenKind::Comma)?;
250            }
251        }
252        self.expect(TokenKind::RParen)?;
253        self.expect(TokenKind::Colon)?;
254        
255        let body = self.parse_block()?;
256        
257        Ok(Item::Macro(MacroDef {
258            name,
259            params,
260            body: MacroBody::Block(body),
261            span: start.merge(self.current_span()),
262        }))
263    }
264
265    fn parse_function(&mut self, vis: Visibility) -> KainResult<Item> {
266        let start = self.current_span();
267        self.expect(TokenKind::Fn)?;
268        let name = self.parse_ident()?;
269        
270        // Parse generics: <T, U: Bound>
271        let generics = self.parse_generics()?;
272        
273        self.expect(TokenKind::LParen)?;
274        let params = self.parse_params()?;
275        self.expect(TokenKind::RParen)?;
276        
277        let return_type = if self.check(TokenKind::Arrow) {
278            self.advance();
279            Some(self.parse_type()?)
280        } else { None };
281        
282        let effects = self.parse_effects()?;
283        self.expect(TokenKind::Colon)?;
284        let body = self.parse_block()?;
285        let body_span = body.span;
286        
287        Ok(Item::Function(Function {
288            name, generics, params, return_type, effects, body, visibility: vis,
289            attributes: vec![],
290            span: start.merge(body_span),
291        }))
292    }
293
294    // Wrapper to parse function with pre-collected attributes
295    fn parse_function_with_attrs(&mut self, vis: Visibility, attrs: Vec<Attribute>) -> KainResult<Item> {
296        let start = self.current_span();
297        self.expect(TokenKind::Fn)?;
298        let name = self.parse_ident()?;
299        let generics = self.parse_generics()?;
300        self.expect(TokenKind::LParen)?;
301        let params = self.parse_params()?;
302        self.expect(TokenKind::RParen)?;
303        let return_type = if self.check(TokenKind::Arrow) {
304            self.advance();
305            Some(self.parse_type()?)
306        } else { None };
307        let effects = self.parse_effects()?;
308        self.expect(TokenKind::Colon)?;
309        let body = self.parse_block()?;
310        let body_span = body.span;
311        Ok(Item::Function(Function {
312            name, generics, params, return_type, effects, body, visibility: vis,
313            attributes: attrs,
314            span: start.merge(body_span),
315        }))
316    }
317
318    fn parse_async_function(&mut self, vis: Visibility) -> KainResult<Item> {
319        let start = self.current_span();
320        self.expect(TokenKind::AsyncKw)?; // consume 'async'
321        self.expect(TokenKind::Fn)?;     // consume 'fn'
322        let name = self.parse_ident()?;
323        
324        // Parse generics: <T, U: Bound>
325        let generics = self.parse_generics()?;
326        
327        self.expect(TokenKind::LParen)?;
328        let params = self.parse_params()?;
329        self.expect(TokenKind::RParen)?;
330        
331        let return_type = if self.check(TokenKind::Arrow) {
332            self.advance();
333            Some(self.parse_type()?)
334        } else { None };
335        
336        // Parse other effects, then add Async
337        let mut effects = self.parse_effects()?;
338        effects.push(crate::effects::Effect::Async);
339        
340        self.expect(TokenKind::Colon)?;
341        let body = self.parse_block()?;
342        let body_span = body.span;
343        
344        Ok(Item::Function(Function {
345            name, generics, params, return_type, effects, body, visibility: vis,
346            attributes: vec![],
347            span: start.merge(body_span),
348        }))
349    }
350    fn parse_component(&mut self, vis: Visibility) -> KainResult<Item> {
351        let start = self.current_span();
352        self.expect(TokenKind::Component)?;
353        let name = self.parse_ident()?;
354        self.expect(TokenKind::LParen)?;
355        let props = self.parse_params()?;
356        self.expect(TokenKind::RParen)?;
357        let effects = self.parse_effects()?;
358        self.expect(TokenKind::Colon)?;
359        
360        self.skip_newlines();
361        self.expect(TokenKind::Indent)?;
362        
363        let mut state = Vec::new();
364        let mut methods = Vec::new();
365        let mut body = None;
366        
367        // Parse component body items
368        while !self.check(TokenKind::Dedent) && !self.at_end() {
369            self.skip_newlines();
370            if self.check(TokenKind::Dedent) { break; }
371            
372            if self.check(TokenKind::Fn) {
373                // Parse method
374                if let Item::Function(f) = self.parse_function(Visibility::Private)? {
375                    methods.push(f);
376                }
377            } else if let TokenKind::Ident(ref s) = self.peek_kind() {
378                if s == "state" {
379                    self.advance();
380                    let name = self.parse_ident()?;
381                    self.expect(TokenKind::Colon)?;
382                    let ty = self.parse_type()?;
383                    self.expect(TokenKind::Eq)?;
384                    let initial = self.parse_expr()?;
385                    state.push(StateDecl { name, ty, initial, weak: false, span: self.current_span() });
386                } else if s == "weak" {
387                     self.advance();
388                     if self.check(TokenKind::Ident("state".to_string())) { // Check specifically for state
389                         // "weak state name: Type = ..."
390                         self.advance();
391                         let name = self.parse_ident()?;
392                         self.expect(TokenKind::Colon)?;
393                         let ty = self.parse_type()?;
394                         self.expect(TokenKind::Eq)?;
395                         let initial = self.parse_expr()?;
396                         state.push(StateDecl { name, ty, initial, weak: true, span: self.current_span() });
397                     } else {
398                         return Err(KainError::parser("Expected 'state' after 'weak' in component", self.current_span()));
399                     }
400                } else if s == "render" {
401                     self.advance();
402                     if self.check(TokenKind::LBrace) {
403                         // render { jsx }
404                         self.advance();
405                         self.skip_newlines();
406                         body = Some(self.parse_jsx_element()?);
407                         self.skip_newlines();
408                         self.expect(TokenKind::RBrace)?;
409                     } else if self.check(TokenKind::Colon) {
410                         // render:
411                         //    jsx
412                         self.advance();
413                         self.skip_newlines();
414                         self.expect(TokenKind::Indent)?;
415                         self.skip_newlines();
416                         body = Some(self.parse_jsx_element()?);
417                         self.skip_newlines();
418                         self.expect(TokenKind::Dedent)?;
419                     } else {
420                         // render <jsx>
421                         body = Some(self.parse_jsx_element()?);
422                     }
423                } else {
424                    return Err(KainError::parser(format!("Unexpected identifier in component: {}", s), self.current_span()));
425                }
426            } else if self.check(TokenKind::Lt) {
427                // Direct JSX element (implicit render)
428                body = Some(self.parse_jsx_element()?);
429            } else {
430                return Err(KainError::parser(format!("Unexpected token in component: {:?}", self.peek_kind()), self.current_span()));
431            }
432            self.skip_newlines();
433        }
434        
435        if self.check(TokenKind::Dedent) { self.advance(); }
436        
437        let body = body.ok_or_else(|| KainError::parser("Component must have a render body (JSX element)", self.current_span()))?;
438        
439        Ok(Item::Component(Component {
440            name, props, state, methods, effects, body, visibility: vis,
441            attributes: vec![],
442            span: start.merge(self.current_span()),
443        }))
444    }
445
446    // Wrapper to parse component with pre-collected attributes  
447    fn parse_component_with_attrs(&mut self, vis: Visibility, attrs: Vec<Attribute>) -> KainResult<Item> {
448        let start = self.current_span();
449        self.expect(TokenKind::Component)?;
450        let name = self.parse_ident()?;
451        self.expect(TokenKind::LParen)?;
452        let props = self.parse_params()?;
453        self.expect(TokenKind::RParen)?;
454        let effects = self.parse_effects()?;
455        self.expect(TokenKind::Colon)?;
456        self.skip_newlines();
457        self.expect(TokenKind::Indent)?;
458        
459        let mut state = Vec::new();
460        let mut methods = Vec::new();
461        let mut body = None;
462        
463        while !self.check(TokenKind::Dedent) && !self.at_end() {
464            self.skip_newlines();
465            if self.check(TokenKind::Dedent) { break; }
466            
467            if self.check(TokenKind::Fn) {
468                if let Item::Function(f) = self.parse_function(Visibility::Private)? {
469                    methods.push(f);
470                }
471            } else if let TokenKind::Ident(ref s) = self.peek_kind() {
472                if s == "state" {
473                    self.advance();
474                    let name = self.parse_ident()?;
475                    self.expect(TokenKind::Colon)?;
476                    let ty = self.parse_type()?;
477                    self.expect(TokenKind::Eq)?;
478                    let initial = self.parse_expr()?;
479                    state.push(StateDecl { name, ty, initial, weak: false, span: self.current_span() });
480                } else if s == "render" {
481                    self.advance();
482                    if self.check(TokenKind::Colon) {
483                        self.advance();
484                        self.skip_newlines();
485                        self.expect(TokenKind::Indent)?;
486                        self.skip_newlines();
487                        body = Some(self.parse_jsx_element()?);
488                        self.skip_newlines();
489                        self.expect(TokenKind::Dedent)?;
490                    } else {
491                        body = Some(self.parse_jsx_element()?);
492                    }
493                } else {
494                    return Err(KainError::parser(format!("Unexpected identifier in component: {}", s), self.current_span()));
495                }
496            } else if self.check(TokenKind::Lt) {
497                body = Some(self.parse_jsx_element()?);
498            } else {
499                return Err(KainError::parser(format!("Unexpected token in component: {:?}", self.peek_kind()), self.current_span()));
500            }
501            self.skip_newlines();
502        }
503        
504        if self.check(TokenKind::Dedent) { self.advance(); }
505        let body = body.ok_or_else(|| KainError::parser("Component must have a render body", self.current_span()))?;
506        
507        Ok(Item::Component(Component {
508            name, props, state, methods, effects, body, visibility: vis,
509            attributes: attrs,
510            span: start.merge(self.current_span()),
511        }))
512    }
513
514    fn parse_shader(&mut self) -> KainResult<Item> {
515        let start = self.current_span();
516        self.expect(TokenKind::Shader)?;
517        
518        let stage = if self.check(TokenKind::Vertex) {
519            self.advance(); ShaderStage::Vertex
520        } else if self.check(TokenKind::Fragment) {
521            self.advance(); ShaderStage::Fragment
522        } else if let TokenKind::Ident(ref s) = self.peek_kind() {
523            if s == "compute" {
524                self.advance(); ShaderStage::Compute
525            } else {
526                ShaderStage::Fragment // Default
527            }
528        } else {
529            ShaderStage::Fragment // Default
530        };
531
532        let name = self.parse_ident()?;
533        self.expect(TokenKind::LParen)?;
534        let inputs = self.parse_params()?;
535        self.expect(TokenKind::RParen)?;
536        self.expect(TokenKind::Arrow)?;
537        let outputs = self.parse_type()?;
538        self.expect(TokenKind::Colon)?;
539        
540        // Manual block parsing to support uniforms
541        self.skip_newlines();
542        let block_start = self.current_span();
543        self.expect(TokenKind::Indent)?;
544
545        let mut uniforms = Vec::new();
546        let mut stmts = Vec::new();
547
548        while !self.check(TokenKind::Dedent) && !self.at_end() {
549            self.skip_newlines();
550            if self.check(TokenKind::Dedent) { break; }
551
552            // Check for "uniform" identifier
553            let is_uniform = if let TokenKind::Ident(ref s) = self.peek_kind() {
554                s == "uniform"
555            } else {
556                false
557            };
558
559            if is_uniform {
560                self.advance(); // consume "uniform"
561                let u_name = self.parse_ident()?;
562                self.expect(TokenKind::Colon)?;
563                let u_ty = self.parse_type()?;
564                self.expect(TokenKind::At)?;
565                
566                // Parse integer binding
567                let binding = if let TokenKind::Int(n) = self.peek_kind() {
568                    self.advance();
569                    n as u32
570                } else {
571                    return Err(KainError::parser("Expected integer binding", self.current_span()));
572                };
573
574                uniforms.push(Uniform { name: u_name, ty: u_ty, binding, span: self.current_span() });
575            } else {
576                stmts.push(self.parse_stmt()?);
577            }
578            self.skip_newlines();
579        }
580
581        if self.check(TokenKind::Dedent) { self.advance(); }
582        let body = Block { stmts, span: block_start.merge(self.current_span()) };
583        let body_span = body.span;
584        
585        Ok(Item::Shader(Shader {
586            name, stage, inputs, outputs, uniforms, body,
587            span: start.merge(body_span),
588        }))
589    }
590
591    fn parse_struct(&mut self, vis: Visibility) -> KainResult<Item> {
592        let start = self.current_span();
593        self.expect(TokenKind::Struct)?;
594        let name = self.parse_ident()?;
595        
596        // Parse generics: struct Box<T>:
597        let generics = self.parse_generics()?;
598        
599        self.expect(TokenKind::Colon)?;
600        self.skip_newlines();
601        self.expect(TokenKind::Indent)?;
602        
603        let mut fields = Vec::new();
604        while !self.check(TokenKind::Dedent) && !self.at_end() {
605            self.skip_newlines();
606            if self.check(TokenKind::Dedent) { break; }
607            
608            // Check for weak
609            let weak = if let TokenKind::Ident(s) = self.peek_kind() {
610                if s == "weak" {
611                    self.advance();
612                    true
613                } else { false }
614            } else { false };
615            
616            let fname = self.parse_ident()?;
617            self.expect(TokenKind::Colon)?;
618            let ty = self.parse_type()?;
619            fields.push(Field { name: fname, ty, visibility: Visibility::Public, default: None, weak, span: self.current_span() });
620            self.skip_newlines();
621        }
622        if self.check(TokenKind::Dedent) { self.advance(); }
623        
624        Ok(Item::Struct(Struct { name, generics, fields, visibility: vis, span: start.merge(self.current_span()) }))
625    }
626
627    fn parse_enum(&mut self, vis: Visibility) -> KainResult<Item> {
628        let start = self.current_span();
629        self.expect(TokenKind::Enum)?;
630        let name = self.parse_ident()?;
631        
632        // Parse generics: enum Option<T>:
633        let generics = self.parse_generics()?;
634        
635        self.expect(TokenKind::Colon)?;
636        self.skip_newlines();
637        self.expect(TokenKind::Indent)?;
638        
639        let mut variants = Vec::new();
640        while !self.check(TokenKind::Dedent) && !self.at_end() {
641            self.skip_newlines();
642            if self.check(TokenKind::Dedent) { break; }
643            let start_span = self.current_span();
644            let vname = self.parse_ident()?;
645            
646            let fields = if self.check(TokenKind::LParen) {
647                self.advance(); // consume (
648                let mut types = Vec::new();
649                while !self.check(TokenKind::RParen) && !self.at_end() {
650                    types.push(self.parse_type()?);
651                    if !self.check(TokenKind::RParen) {
652                        self.expect(TokenKind::Comma)?;
653                    }
654                }
655                self.expect(TokenKind::RParen)?;
656                VariantFields::Tuple(types)
657            } else if self.check(TokenKind::LBrace) {
658                self.advance(); // consume {
659                self.skip_newlines();
660                let indented = if self.check(TokenKind::Indent) { self.advance(); true } else { false };
661                
662                let mut fields = Vec::new();
663                while !self.check(TokenKind::RBrace) && !self.at_end() {
664                    if indented && self.check(TokenKind::Dedent) { break; }
665                    if !indented && self.check(TokenKind::RBrace) { break; }
666                    
667                    self.skip_newlines();
668                    if self.check(TokenKind::RBrace) || (indented && self.check(TokenKind::Dedent)) { break; }
669                    
670                    let fname = self.parse_ident()?;
671                    self.expect(TokenKind::Colon)?;
672                    let ty = self.parse_type()?;
673                    
674                    fields.push(Field { 
675                        name: fname, 
676                        ty, 
677                        visibility: Visibility::Public, 
678                        default: None, 
679                        weak: false, 
680                        span: self.current_span() 
681                    });
682                    
683                    if !self.check(TokenKind::RBrace) {
684                         if self.check(TokenKind::Comma) { self.advance(); }
685                    }
686                    self.skip_newlines();
687                }
688                
689                if indented { self.expect(TokenKind::Dedent)?; }
690                self.expect(TokenKind::RBrace)?;
691                VariantFields::Struct(fields)
692            } else {
693                VariantFields::Unit
694            };
695            
696            // If the next token is a newline/dedent, previous token end is the end of the variant
697            // For now, using current_span (next token) is consistent with previous code's behavior for Unit variants
698            // but for Tuple/Struct it's better to span the whole thing.
699            // Let's use start_span (ident) merged with current_span (after fields).
700            let span = if matches!(fields, VariantFields::Unit) {
701                 // If Unit, current_span is the one after ident. 
702                 // If we used start_span, it would be the ident.
703                 // Let's just use start_span for Unit to correct the "bug" of using next token.
704                 // But wait, start_span is the Ident span.
705                 start_span
706            } else {
707                 // For fields, we consumed ) or }. current_span is the one after that.
708                 // We want to merge start_span with the end of the fields.
709                 // But current_span() points to the *next* token.
710                 // We can use start_span for the start.
711                 // For the end, it's a bit tricky without keeping track of the last consumed token.
712                 // We'll just use start_span.merge(self.current_span()) which covers [Ident ... NextToken].
713                 // That's acceptable.
714                 start_span.merge(self.current_span())
715            };
716
717            variants.push(Variant { name: vname, fields, span });
718            self.skip_newlines();
719        }
720        if self.check(TokenKind::Dedent) { self.advance(); }
721        
722        Ok(Item::Enum(Enum { name, generics, variants, visibility: vis, span: start.merge(self.current_span()) }))
723    }
724
725    fn parse_actor(&mut self) -> KainResult<Item> {
726        let start = self.current_span();
727        self.expect(TokenKind::Actor)?;
728        let name = self.parse_ident()?;
729        self.expect(TokenKind::Colon)?;
730        
731        self.skip_newlines();
732        self.expect(TokenKind::Indent)?;
733        
734        let mut state = Vec::new();
735        let mut handlers = Vec::new();
736        
737        while !self.check(TokenKind::Dedent) && !self.at_end() {
738            self.skip_newlines();
739            if self.check(TokenKind::Dedent) { break; }
740            
741            // Check for "state" or "on"
742            if let TokenKind::Ident(s) = self.peek_kind() {
743                if s == "state" {
744                    self.advance();
745                    let name = self.parse_ident()?;
746                    self.expect(TokenKind::Colon)?;
747                    let ty = self.parse_type()?;
748                    self.expect(TokenKind::Eq)?;
749                    let initial = self.parse_expr()?;
750                    state.push(StateDecl { name, ty, initial, weak: false, span: self.current_span() });
751                } else if s == "weak" {
752                    self.advance();
753                    if self.check(TokenKind::Ident("state".to_string())) {
754                        self.advance();
755                        let name = self.parse_ident()?;
756                        self.expect(TokenKind::Colon)?;
757                        let ty = self.parse_type()?;
758                        self.expect(TokenKind::Eq)?;
759                        let initial = self.parse_expr()?;
760                        state.push(StateDecl { name, ty, initial, weak: true, span: self.current_span() });
761                    } else {
762                         return Err(KainError::parser("Expected 'state' after 'weak' in actor", self.current_span()));
763                    }
764                } else if s == "on" {
765                    self.advance();
766                    let message_type = self.parse_ident()?;
767                    self.expect(TokenKind::LParen)?;
768                    let params = self.parse_params()?;
769                    self.expect(TokenKind::RParen)?;
770                    self.expect(TokenKind::Colon)?;
771                    let body = self.parse_block()?;
772                    handlers.push(MessageHandler { message_type, params, body, span: self.current_span() });
773                } else {
774                     return Err(KainError::parser(format!("Unexpected item in actor: {}", s), self.current_span()));
775                }
776            } else {
777                 return Err(KainError::parser("Expected 'state' or 'on' in actor definition", self.current_span()));
778            }
779            
780            self.skip_newlines();
781        }
782        if self.check(TokenKind::Dedent) { self.advance(); }
783        
784        let span = start.merge(self.current_span());
785        Ok(Item::Actor(Actor { name, state, handlers, span }))
786    }
787
788    fn parse_const(&mut self, vis: Visibility) -> KainResult<Item> {
789        let start = self.current_span();
790        self.expect(TokenKind::Const)?;
791        let name = self.parse_ident()?;
792        self.expect(TokenKind::Colon)?;
793        let ty = self.parse_type()?;
794        self.expect(TokenKind::Eq)?;
795        let value = self.parse_expr()?;
796        Ok(Item::Const(Const { name, ty, value, visibility: vis, span: start.merge(self.current_span()) }))
797    }
798
799    fn parse_comptime_block(&mut self) -> KainResult<Item> {
800        let start = self.current_span();
801        self.expect(TokenKind::Comptime)?;
802        self.expect(TokenKind::Colon)?;
803        let body = self.parse_block()?;
804        Ok(Item::Comptime(ComptimeBlock { body, span: start.merge(self.current_span()) }))
805    }
806
807    fn parse_params(&mut self) -> KainResult<Vec<Param>> {
808        let mut params = Vec::new();
809        self.skip_newlines();
810        while !self.check(TokenKind::RParen) && !self.at_end() {
811            let mutable = if self.check(TokenKind::Mut) {
812                self.advance();
813                true
814            } else {
815                false
816            };
817
818            let name = self.parse_ident()?;
819            let ty = if self.check(TokenKind::Colon) {
820                self.advance();
821                self.parse_type()?
822            } else {
823                Type::Infer(self.current_span())
824            };
825            params.push(Param { name, ty, mutable, default: None, span: self.current_span() });
826            
827            self.skip_newlines();
828            if !self.check(TokenKind::RParen) { 
829                self.expect(TokenKind::Comma)?; 
830                self.skip_newlines();
831            }
832        }
833        Ok(params)
834    }
835
836    /// Parse generic type parameters: <T, U: Bound, V>
837    fn parse_generics(&mut self) -> KainResult<Vec<Generic>> {
838        let mut generics = Vec::new();
839        
840        // Check for opening <
841        if !self.check(TokenKind::Lt) {
842            return Ok(generics);
843        }
844        self.advance(); // consume <
845        
846        while !self.check(TokenKind::Gt) && !self.at_end() {
847            let start = self.current_span();
848            let name = self.parse_ident()?;
849            
850            // Parse optional bounds: T: Bound1 + Bound2
851            let mut bounds = Vec::new();
852            if self.check(TokenKind::Colon) {
853                self.advance(); // consume :
854                loop {
855                    let bound_name = self.parse_ident()?;
856                    bounds.push(TypeBound { trait_name: bound_name, span: self.current_span() });
857                    if !self.check(TokenKind::Plus) { break; }
858                    self.advance(); // consume +
859                }
860            }
861            
862            generics.push(Generic { name, bounds, span: start.merge(self.current_span()) });
863            
864            if !self.check(TokenKind::Gt) {
865                self.expect(TokenKind::Comma)?;
866            }
867        }
868        
869        self.expect(TokenKind::Gt)?; // consume >
870        Ok(generics)
871    }
872
873    fn parse_effects(&mut self) -> KainResult<Vec<Effect>> {
874        let mut effects = Vec::new();
875        if self.check(TokenKind::With) {
876            self.advance();
877            loop {
878                // Effects are keywords, not identifiers
879                let effect = match self.peek_kind() {
880                    TokenKind::Pure => { self.advance(); Some(Effect::Pure) }
881                    TokenKind::Io => { self.advance(); Some(Effect::IO) }
882                    TokenKind::Async => { self.advance(); Some(Effect::Async) }
883                    TokenKind::Gpu => { self.advance(); Some(Effect::GPU) }
884                    TokenKind::Reactive => { self.advance(); Some(Effect::Reactive) }
885                    TokenKind::Unsafe => { self.advance(); Some(Effect::Unsafe) }
886                    TokenKind::Ident(ref s) => {
887                        let e = Effect::from_str(s);
888                        self.advance();
889                        e
890                    }
891                    _ => None,
892                };
893                if let Some(e) = effect {
894                    effects.push(e);
895                }
896                if !self.check(TokenKind::Comma) { break; }
897                self.advance();
898            }
899        }
900        Ok(effects)
901    }
902
903    fn parse_type(&mut self) -> KainResult<Type> {
904        let span = self.current_span();
905        
906        // Handle tuple types: (A, B) or unit type: ()
907        if self.check(TokenKind::LParen) {
908            self.advance(); // consume (
909            
910            // Check for unit type ()
911            if self.check(TokenKind::RParen) {
912                self.advance(); // consume )
913                return Ok(Type::Unit(span.merge(self.current_span())));
914            }
915            
916            // Parse tuple elements
917            let mut elements = Vec::new();
918            elements.push(self.parse_type()?);
919            
920            while self.check(TokenKind::Comma) {
921                self.advance(); // consume ,
922                if self.check(TokenKind::RParen) { break; } // trailing comma
923                elements.push(self.parse_type()?);
924            }
925            
926            self.expect(TokenKind::RParen)?;
927            return Ok(Type::Tuple(elements, span.merge(self.current_span())));
928        }
929        
930        // Handle impl Trait: impl Future, impl Iterator<Item = T>
931        if self.check(TokenKind::Impl) {
932            self.advance(); // consume impl
933            let trait_name = self.parse_ident()?;
934            
935            // Parse generic arguments if present
936            let mut generics = Vec::new();
937            if self.check(TokenKind::Lt) {
938                self.advance(); // consume <
939                while !self.check(TokenKind::Gt) && !self.at_end() {
940                    generics.push(self.parse_type()?);
941                    if !self.check(TokenKind::Gt) {
942                        self.expect(TokenKind::Comma)?;
943                    }
944                }
945                self.expect(TokenKind::Gt)?;
946            }
947            
948            return Ok(Type::Impl {
949                trait_name,
950                generics,
951                span: span.merge(self.current_span()),
952            });
953        }
954        
955        // Handle function types: fn(T, U) -> R
956        if self.check(TokenKind::Fn) {
957            self.advance(); // consume fn
958            self.expect(TokenKind::LParen)?;
959            
960            // Parse parameter types
961            let mut params = Vec::new();
962            while !self.check(TokenKind::RParen) && !self.at_end() {
963                params.push(self.parse_type()?);
964                if !self.check(TokenKind::RParen) {
965                    self.expect(TokenKind::Comma)?;
966                }
967            }
968            self.expect(TokenKind::RParen)?;
969            
970            // Parse return type (optional)
971            let return_type = if self.check(TokenKind::Arrow) {
972                self.advance(); // consume ->
973                Box::new(self.parse_type()?)
974            } else {
975                Box::new(Type::Unit(span))
976            };
977            
978            return Ok(Type::Function {
979                params,
980                return_type,
981                effects: vec![],
982                span: span.merge(self.current_span()),
983            });
984        }
985        
986        let mut name = self.parse_ident()?;
987        
988        // Support Module::Type syntax
989        while self.check(TokenKind::ColonColon) {
990            self.advance(); // consume ::
991            let part = self.parse_ident()?;
992            name.push_str("::");
993            name.push_str(&part);
994        }
995        
996        // Parse generic type arguments: Type<T, U>
997        let mut type_args = Vec::new();
998        if self.check(TokenKind::Lt) {
999            self.advance(); // consume <
1000            while !self.check(TokenKind::Gt) && !self.at_end() {
1001                type_args.push(self.parse_type()?);
1002                if !self.check(TokenKind::Gt) {
1003                    self.expect(TokenKind::Comma)?;
1004                }
1005            }
1006            self.expect(TokenKind::Gt)?; // consume >
1007        }
1008        
1009        Ok(Type::Named { name, generics: type_args, span })
1010    }
1011
1012    fn parse_block(&mut self) -> KainResult<Block> {
1013        self.skip_newlines();
1014        let start = self.current_span();
1015        self.expect(TokenKind::Indent)?;
1016        
1017        let mut stmts = Vec::new();
1018        while !self.check(TokenKind::Dedent) && !self.at_end() {
1019            self.skip_newlines();
1020            if self.check(TokenKind::Dedent) { break; }
1021            stmts.push(self.parse_stmt()?);
1022            self.skip_newlines();
1023        }
1024        if self.check(TokenKind::Dedent) { self.advance(); }
1025        
1026        Ok(Block { stmts, span: start.merge(self.current_span()) })
1027    }
1028
1029    fn parse_stmt(&mut self) -> KainResult<Stmt> {
1030        match self.peek_kind() {
1031            TokenKind::Let => self.parse_let(),
1032            TokenKind::Var => self.parse_var(),
1033            TokenKind::Return => self.parse_return(),
1034            TokenKind::For => self.parse_for(),
1035            TokenKind::While => self.parse_while(),
1036            TokenKind::Loop => self.parse_loop(),
1037            TokenKind::Break => self.parse_break(),
1038            TokenKind::Continue => self.parse_continue(),
1039            _ => Ok(Stmt::Expr(self.parse_expr()?)),
1040        }
1041    }
1042
1043    fn parse_let(&mut self) -> KainResult<Stmt> {
1044        let start = self.current_span();
1045        self.expect(TokenKind::Let)?;
1046        let pattern = self.parse_pattern()?;
1047        let ty = if self.check(TokenKind::Colon) { self.advance(); Some(self.parse_type()?) } else { None };
1048        self.expect(TokenKind::Eq)?;
1049        let value = Some(self.parse_expr()?);
1050        Ok(Stmt::Let { pattern, ty, value, span: start.merge(self.current_span()) })
1051    }
1052
1053    fn parse_var(&mut self) -> KainResult<Stmt> {
1054        let start = self.current_span();
1055        self.expect(TokenKind::Var)?;
1056        let name = self.parse_ident()?;
1057        let ty = if self.check(TokenKind::Colon) { self.advance(); Some(self.parse_type()?) } else { None };
1058        self.expect(TokenKind::Eq)?;
1059        let value = Some(self.parse_expr()?);
1060        // var x = val is effectively let mut x = val
1061        let pattern = Pattern::Binding { name, mutable: true, span: start };
1062        Ok(Stmt::Let { pattern, ty, value, span: start.merge(self.current_span()) })
1063    }
1064
1065    fn parse_return(&mut self) -> KainResult<Stmt> {
1066        let start = self.current_span();
1067        self.expect(TokenKind::Return)?;
1068        let value = if !self.check_line_end() { Some(self.parse_expr()?) } else { None };
1069        Ok(Stmt::Return(value, start.merge(self.current_span())))
1070    }
1071
1072    fn parse_for(&mut self) -> KainResult<Stmt> {
1073        let start = self.current_span();
1074        self.expect(TokenKind::For)?;
1075        let name = self.parse_ident()?;
1076        self.expect(TokenKind::In)?;
1077        let iter = self.parse_expr()?;
1078        self.expect(TokenKind::Colon)?;
1079        let body = self.parse_block()?;
1080        Ok(Stmt::For { binding: Pattern::Binding { name, mutable: false, span: start }, iter, body, span: start.merge(self.current_span()) })
1081    }
1082
1083    fn parse_while(&mut self) -> KainResult<Stmt> {
1084        let start = self.current_span();
1085        self.expect(TokenKind::While)?;
1086        let condition = self.parse_expr()?;
1087        self.expect(TokenKind::Colon)?;
1088        let body = self.parse_block()?;
1089        Ok(Stmt::While { condition, body, span: start.merge(self.current_span()) })
1090    }
1091
1092    fn parse_loop(&mut self) -> KainResult<Stmt> {
1093        let start = self.current_span();
1094        self.expect(TokenKind::Loop)?;
1095        self.expect(TokenKind::Colon)?;
1096        let body = self.parse_block()?;
1097        Ok(Stmt::Loop { body, span: start.merge(self.current_span()) })
1098    }
1099
1100    fn parse_break(&mut self) -> KainResult<Stmt> {
1101        let start = self.current_span();
1102        self.expect(TokenKind::Break)?;
1103        // Optional value: break expr
1104        let value = if !self.check_line_end() && !self.check(TokenKind::Dedent) {
1105            Some(self.parse_expr()?)
1106        } else {
1107            None
1108        };
1109        Ok(Stmt::Break(value, start.merge(self.current_span())))
1110    }
1111
1112    fn parse_continue(&mut self) -> KainResult<Stmt> {
1113        let start = self.current_span();
1114        self.expect(TokenKind::Continue)?;
1115        Ok(Stmt::Continue(start.merge(self.current_span())))
1116    }
1117    fn parse_expr(&mut self) -> KainResult<Expr> { self.parse_assignment() }
1118
1119    fn parse_assignment(&mut self) -> KainResult<Expr> {
1120        let expr = self.parse_binary(0)?;
1121        
1122        if self.check(TokenKind::Eq) {
1123            self.advance();
1124            let value = self.parse_assignment()?;
1125            let span = expr.span().merge(value.span());
1126            Ok(Expr::Assign { target: Box::new(expr), value: Box::new(value), span })
1127        } else {
1128            Ok(expr)
1129        }
1130    }
1131
1132    fn parse_binary(&mut self, min_prec: u8) -> KainResult<Expr> {
1133        let mut left = self.parse_unary()?;
1134        
1135        while let Some((op, prec)) = self.get_binary_op() {
1136            if prec < min_prec { break; }
1137            self.advance();
1138            let right = self.parse_binary(prec + 1)?;
1139            let span = left.span().merge(right.span());
1140            left = Expr::Binary { left: Box::new(left), op, right: Box::new(right), span };
1141        }
1142        Ok(left)
1143    }
1144
1145    fn parse_unary(&mut self) -> KainResult<Expr> {
1146        match self.peek_kind() {
1147            TokenKind::Minus => { let s = self.current_span(); self.advance(); Ok(Expr::Unary { op: UnaryOp::Neg, operand: Box::new(self.parse_unary()?), span: s }) }
1148            TokenKind::Not => { let s = self.current_span(); self.advance(); Ok(Expr::Unary { op: UnaryOp::Not, operand: Box::new(self.parse_unary()?), span: s }) }
1149            TokenKind::Await => {
1150                let start = self.current_span();
1151                self.advance();
1152                let expr = self.parse_unary()?; // Right-associative: await await x
1153                Ok(Expr::Await(Box::new(expr), start.merge(self.current_span())))
1154            }
1155            TokenKind::Send => {
1156                let start = self.current_span();
1157                self.advance();
1158                let expr = self.parse_postfix()?;
1159                
1160                if let Expr::Call { callee, args, span } = expr {
1161                    if let Expr::Field { object, field, span: _ } = *callee {
1162                        let mut data = Vec::new();
1163                        for arg in args {
1164                            if let Some(name) = arg.name {
1165                                data.push((name, arg.value));
1166                            } else {
1167                                return Err(KainError::parser("Send requires named arguments", arg.span));
1168                            }
1169                        }
1170                        Ok(Expr::SendMsg { target: object, message: field, data, span: start.merge(span) })
1171                    } else {
1172                        Err(KainError::parser("Expected method call after send (e.g., actor.message())", span))
1173                    }
1174                } else {
1175                    Err(KainError::parser("Expected message call after send", expr.span()))
1176                }
1177            }
1178            _ => self.parse_postfix(),
1179        }
1180    }
1181
1182    fn parse_postfix(&mut self) -> KainResult<Expr> {
1183        let mut expr = self.parse_primary()?;
1184        loop {
1185            match self.peek_kind() {
1186                TokenKind::LParen => { 
1187                    self.advance(); 
1188                    let args = self.parse_call_args()?; 
1189                    self.expect(TokenKind::RParen)?; 
1190                    let s = expr.span().merge(self.current_span()); 
1191                    
1192                    if let Expr::Field { object, field, span: _ } = expr {
1193                        expr = Expr::MethodCall { receiver: object, method: field, args, span: s };
1194                    } else {
1195                        expr = Expr::Call { callee: Box::new(expr), args, span: s }; 
1196                    }
1197                }
1198                TokenKind::Dot => { self.advance(); let field = self.parse_ident()?; let s = expr.span().merge(self.current_span()); expr = Expr::Field { object: Box::new(expr), field, span: s }; }
1199            TokenKind::As => {
1200                self.advance();
1201                let target = self.parse_type()?;
1202                let s = expr.span().merge(self.current_span());
1203                expr = Expr::Cast { value: Box::new(expr), target, span: s };
1204            }
1205            TokenKind::LBracket => { self.advance(); let idx = self.parse_expr()?; self.expect(TokenKind::RBracket)?; let s = expr.span().merge(self.current_span()); expr = Expr::Index { object: Box::new(expr), index: Box::new(idx), span: s }; }
1206            TokenKind::Question => { self.advance(); let s = expr.span().merge(self.current_span()); expr = Expr::Try(Box::new(expr), s); }
1207            TokenKind::Not => {
1208                // Macro invocation: ident!(args)
1209                if let Expr::Ident(name, _) = &expr {
1210                    self.advance(); // consume '!'
1211                    self.expect(TokenKind::LParen)?;
1212                    let args = if !self.check(TokenKind::RParen) {
1213                        let mut args = Vec::new();
1214                        args.push(self.parse_expr()?);
1215                        while self.check(TokenKind::Comma) {
1216                            self.advance();
1217                            if self.check(TokenKind::RParen) { break; }
1218                            args.push(self.parse_expr()?);
1219                        }
1220                        args
1221                    } else {
1222                        Vec::new()
1223                    };
1224                    self.expect(TokenKind::RParen)?;
1225                    let s = expr.span().merge(self.current_span());
1226                    expr = Expr::MacroCall { name: name.clone(), args, span: s };
1227                } else {
1228                     // Maybe unary not? But we are in postfix. Unary not is handled in parse_unary.
1229                     // Postfix ! usually means macro or maybe future features (like factorial?).
1230                     // For now, only support macros on identifiers.
1231                     return Err(KainError::parser("Macro invocation only allowed on identifiers", self.current_span()));
1232                }
1233            }
1234            _ => break,
1235            }
1236        }
1237        Ok(expr)
1238    }
1239
1240    fn parse_primary(&mut self) -> KainResult<Expr> {
1241        let span = self.current_span();
1242        match self.peek_kind() {
1243            TokenKind::Int(n) => { self.advance(); Ok(Expr::Int(n, span)) }
1244            TokenKind::Float(n) => { self.advance(); Ok(Expr::Float(n, span)) }
1245            TokenKind::String(ref s) => { let s = s.clone(); self.advance(); Ok(Expr::String(s, span)) }
1246            TokenKind::FString(ref s) => {
1247                let s = s.clone();
1248                self.advance();
1249                let mut parts = Vec::new();
1250                let mut last_idx = 0;
1251                let mut chars = s.char_indices().peekable();
1252                
1253                while let Some((idx, c)) = chars.next() {
1254                    if c == '{' {
1255                        if idx > last_idx {
1256                            parts.push(Expr::String(s[last_idx..idx].to_string(), span));
1257                        }
1258                        
1259                        let expr_start = idx + 1;
1260                        let mut depth = 1;
1261                        let mut expr_end = expr_start;
1262                        
1263                        while let Some((i, c2)) = chars.next() {
1264                            if c2 == '{' { depth += 1; }
1265                            else if c2 == '}' {
1266                                depth -= 1;
1267                                if depth == 0 {
1268                                    expr_end = i;
1269                                    break;
1270                                }
1271                            }
1272                        }
1273                        
1274                        if depth == 0 {
1275                            let expr_str = &s[expr_start..expr_end];
1276                            let tokens = Lexer::new(expr_str).tokenize()?;
1277                            let mut parser = Parser::new(&tokens);
1278                            let expr = parser.parse_expr()?;
1279                            parts.push(expr);
1280                            last_idx = expr_end + 1;
1281                        } else {
1282                             return Err(KainError::parser("Unclosed '{' in f-string", span));
1283                        }
1284                    }
1285                }
1286                
1287                if last_idx < s.len() {
1288                    parts.push(Expr::String(s[last_idx..].to_string(), span));
1289                }
1290                
1291                Ok(Expr::FString(parts, span))
1292            }
1293            TokenKind::True => { self.advance(); Ok(Expr::Bool(true, span)) }
1294            TokenKind::False => { self.advance(); Ok(Expr::Bool(false, span)) }
1295            TokenKind::None => { self.advance(); Ok(Expr::None(span)) }
1296            TokenKind::Ident(ref s) => { 
1297                let name = s.clone(); 
1298                self.advance();
1299
1300                if self.check(TokenKind::ColonColon) {
1301                    self.advance();
1302                    let variant = self.parse_ident()?;
1303
1304                    let fields = if self.check(TokenKind::LParen) {
1305                        self.advance();
1306                        self.skip_newlines();
1307                        let mut items = Vec::new();
1308                        if !self.check(TokenKind::RParen) {
1309                            items.push(self.parse_expr()?);
1310                            while self.check(TokenKind::Comma) {
1311                                self.advance();
1312                                if self.check(TokenKind::RParen) {
1313                                    break;
1314                                }
1315                                items.push(self.parse_expr()?);
1316                            }
1317                        }
1318                        self.expect(TokenKind::RParen)?;
1319                        if items.is_empty() {
1320                            EnumVariantFields::Unit
1321                        } else {
1322                            EnumVariantFields::Tuple(items)
1323                        }
1324                    } else if self.check(TokenKind::LBrace) {
1325                        self.advance();
1326                        let mut fields = Vec::new();
1327
1328                        self.skip_newlines();
1329                        let indented = if self.check(TokenKind::Indent) {
1330                            self.advance();
1331                            true
1332                        } else {
1333                            false
1334                        };
1335
1336                        while !self.check(TokenKind::RBrace) && !self.at_end() {
1337                            if indented && self.check(TokenKind::Dedent) {
1338                                break;
1339                            }
1340
1341                            let field_name = self.parse_ident()?;
1342                            self.expect(TokenKind::Colon)?;
1343                            let field_value = self.parse_expr()?;
1344                            fields.push((field_name, field_value));
1345
1346                            if !self.check(TokenKind::RBrace) && (!indented || !self.check(TokenKind::Dedent)) {
1347                                if self.check(TokenKind::Comma) {
1348                                    self.advance();
1349                                }
1350                            }
1351                            self.skip_newlines();
1352                        }
1353
1354                        if indented {
1355                            self.expect(TokenKind::Dedent)?;
1356                        }
1357                        self.expect(TokenKind::RBrace)?;
1358                        EnumVariantFields::Struct(fields)
1359                    } else {
1360                        EnumVariantFields::Unit
1361                    };
1362
1363                    return Ok(Expr::EnumVariant {
1364                        enum_name: name,
1365                        variant,
1366                        fields,
1367                        span: span.merge(self.current_span()),
1368                    });
1369                }
1370                
1371                // Check if this is a struct literal: Name { field: value, ... }
1372                if self.check(TokenKind::LBrace) {
1373                    self.advance(); // consume {
1374                    let mut fields = Vec::new();
1375                    
1376                    self.skip_newlines();
1377                    let indented = if self.check(TokenKind::Indent) {
1378                        self.advance();
1379                        true
1380                    } else {
1381                        false
1382                    };
1383                    
1384                    while !self.check(TokenKind::RBrace) && !self.at_end() {
1385                        if indented && self.check(TokenKind::Dedent) {
1386                            break;
1387                        }
1388                        
1389                        let field_name = self.parse_ident()?;
1390                        self.expect(TokenKind::Colon)?;
1391                        let field_value = self.parse_expr()?;
1392                        fields.push((field_name, field_value));
1393                        
1394                        // Optional comma if not closing
1395                        if !self.check(TokenKind::RBrace) && (!indented || !self.check(TokenKind::Dedent)) {
1396                            if self.check(TokenKind::Comma) {
1397                                self.advance();
1398                            }
1399                        }
1400                        self.skip_newlines();
1401                    }
1402                    
1403                    if indented {
1404                        self.expect(TokenKind::Dedent)?;
1405                    }
1406                    self.expect(TokenKind::RBrace)?;
1407                    
1408                    Ok(Expr::Struct { 
1409                        name, 
1410                        fields, 
1411                        span: span.merge(self.current_span()) 
1412                    })
1413                } else {
1414                    Ok(Expr::Ident(name, span))
1415                }
1416            }
1417            TokenKind::SelfLower => { 
1418                self.advance(); 
1419                Ok(Expr::Ident("self".to_string(), span)) 
1420            }
1421            TokenKind::SelfUpper => { 
1422                self.advance(); 
1423                Ok(Expr::Ident("Self".to_string(), span)) 
1424            }
1425            TokenKind::LParen => { 
1426                self.advance(); 
1427                if self.check(TokenKind::RParen) {
1428                    self.advance();
1429                    Ok(Expr::Tuple(vec![], span.merge(self.current_span())))
1430                } else {
1431                    let first = self.parse_expr()?;
1432                    if self.check(TokenKind::Comma) {
1433                        self.advance();
1434                        let mut items = vec![first];
1435                        while !self.check(TokenKind::RParen) {
1436                            items.push(self.parse_expr()?);
1437                            if !self.check(TokenKind::RParen) { self.expect(TokenKind::Comma)?; }
1438                        }
1439                        self.expect(TokenKind::RParen)?;
1440                        Ok(Expr::Tuple(items, span.merge(self.current_span())))
1441                    } else {
1442                        self.expect(TokenKind::RParen)?;
1443                        Ok(Expr::Paren(Box::new(first), span.merge(self.current_span())))
1444                    }
1445                }
1446            }
1447            TokenKind::LBracket => { 
1448                self.advance();
1449                self.skip_newlines();
1450                
1451                // Check for indent (multi-line array)
1452                let indented = if self.check(TokenKind::Indent) {
1453                    self.advance();
1454                    true
1455                } else {
1456                    false
1457                };
1458                
1459                let mut items = vec![];
1460                while !self.check(TokenKind::RBracket) && !self.at_end() {
1461                    if indented && self.check(TokenKind::Dedent) {
1462                        break;
1463                    }
1464                    self.skip_newlines();
1465                    if self.check(TokenKind::RBracket) {
1466                        break;
1467                    }
1468                    items.push(self.parse_expr()?);
1469                    self.skip_newlines();
1470                    if !self.check(TokenKind::RBracket) && !self.check(TokenKind::Dedent) { 
1471                        if self.check(TokenKind::Comma) {
1472                            self.advance();
1473                            self.skip_newlines();
1474                        }
1475                    }
1476                }
1477                
1478                if indented {
1479                    if self.check(TokenKind::Dedent) {
1480                        self.advance();
1481                    }
1482                }
1483                self.skip_newlines();
1484                self.expect(TokenKind::RBracket)?; 
1485                Ok(Expr::Array(items, span)) 
1486            }
1487            TokenKind::Comptime => {
1488                self.advance();
1489                self.expect(TokenKind::Colon)?;
1490                let body = self.parse_block()?;
1491                Ok(Expr::Comptime(Box::new(Expr::Block(body, span)), span))
1492            }
1493            TokenKind::Pipe => {
1494                self.advance();
1495                let mut params = Vec::new();
1496                while !self.check(TokenKind::Pipe) {
1497                    let name = self.parse_ident()?;
1498                    params.push(Param {
1499                        name,
1500                        ty: Type::Infer(span),
1501                        mutable: false,
1502                        default: None,
1503                        span,
1504                    });
1505                    if !self.check(TokenKind::Pipe) { self.expect(TokenKind::Comma)?; }
1506                }
1507                self.expect(TokenKind::Pipe)?;
1508                let body = self.parse_expr()?;
1509                Ok(Expr::Lambda { params, return_type: None, body: Box::new(body), span: span.merge(self.current_span()) })
1510            }
1511            TokenKind::Match => self.parse_match(),
1512            TokenKind::Spawn => {
1513                self.advance();
1514                let actor = self.parse_ident()?;
1515                self.expect(TokenKind::LParen)?;
1516                let args = self.parse_call_args()?;
1517                self.expect(TokenKind::RParen)?;
1518                
1519                let mut init = Vec::new();
1520                for arg in args {
1521                    if let Some(name) = arg.name {
1522                        init.push((name, arg.value));
1523                    } else {
1524                         return Err(KainError::parser("Spawn requires named arguments", arg.span));
1525                    }
1526                }
1527                Ok(Expr::Spawn { actor, init, span: span.merge(self.current_span()) })
1528            }
1529            TokenKind::Return => {
1530                let start = self.current_span();
1531                self.advance();
1532                let value = if !self.check_line_end() 
1533                    && !self.check(TokenKind::Comma) 
1534                    && !self.check(TokenKind::RParen) 
1535                    && !self.check(TokenKind::RBrace) 
1536                    && !self.check(TokenKind::RBracket) 
1537                {
1538                    Some(Box::new(self.parse_expr()?))
1539                } else {
1540                    None
1541                };
1542                Ok(Expr::Return(value, start.merge(self.current_span())))
1543            }
1544            TokenKind::If => self.parse_if(),
1545            TokenKind::Lt => {
1546                let jsx = self.parse_jsx_element()?;
1547                Ok(Expr::JSX(jsx, span.merge(self.current_span())))
1548            }
1549            // Lambda with fn syntax: fn(x: Int) -> Int: return x * 2
1550            // or fn(x: Int): return x * 2
1551            TokenKind::Fn => {
1552                self.advance(); // consume fn
1553                self.expect(TokenKind::LParen)?;
1554                
1555                // Parse parameters with types
1556                let mut params = Vec::new();
1557                while !self.check(TokenKind::RParen) && !self.at_end() {
1558                    let p_span = self.current_span();
1559                    let name = self.parse_ident()?;
1560                    
1561                    // Parse type annotation
1562                    let ty = if self.check(TokenKind::Colon) {
1563                        self.advance();
1564                        self.parse_type()?
1565                    } else {
1566                        Type::Infer(p_span)
1567                    };
1568                    
1569                    params.push(Param {
1570                        name,
1571                        ty,
1572                        mutable: false,
1573                        default: None,
1574                        span: p_span,
1575                    });
1576                    
1577                    if !self.check(TokenKind::RParen) {
1578                        self.expect(TokenKind::Comma)?;
1579                    }
1580                }
1581                self.expect(TokenKind::RParen)?;
1582                
1583                // Parse optional return type
1584                let return_type = if self.check(TokenKind::Arrow) {
1585                    self.advance();
1586                    Some(self.parse_type()?)
1587                } else {
1588                    None
1589                };
1590                
1591                self.expect(TokenKind::Colon)?;
1592                
1593                // Parse body - can be a single expression or a block
1594                let body = if self.check(TokenKind::Return) {
1595                    // Single return statement: fn(x): return x * 2
1596                    self.advance();
1597                    self.parse_expr()?
1598                } else if self.check(TokenKind::Indent) || self.check_newline() {
1599                    // Block body (multi-line lambda)
1600                    self.skip_newlines();
1601                    let block = self.parse_block()?;
1602                    Expr::Block(block, span)
1603                } else {
1604                    // Single expression: fn(x): x * 2
1605                    self.parse_expr()?
1606                };
1607                
1608                Ok(Expr::Lambda { 
1609                    params, 
1610                    return_type, 
1611                    body: Box::new(body), 
1612                    span: span.merge(self.current_span()) 
1613                })
1614            }
1615            // Control flow as expressions (for use in match arms, etc.)
1616            TokenKind::Continue => {
1617                self.advance();
1618                // Continue as an expression wraps in a block that continues
1619                Ok(Expr::Continue(span))
1620            }
1621            TokenKind::Break => {
1622                self.advance();
1623                // Optional break value
1624                let value = if !self.check_line_end() && !self.check(TokenKind::Dedent) 
1625                    && !self.check(TokenKind::Comma) && !self.check(TokenKind::RParen) {
1626                    Some(Box::new(self.parse_expr()?))
1627                } else {
1628                    None
1629                };
1630                Ok(Expr::Break(value, span))
1631            }
1632            _ => Err(KainError::parser(format!("Unexpected token: {:?}", self.peek_kind()), span)),
1633        }
1634    }
1635
1636    fn parse_match(&mut self) -> KainResult<Expr> {
1637        let start = self.current_span();
1638        self.expect(TokenKind::Match)?;
1639        let scrutinee = Box::new(self.parse_expr()?);
1640        self.expect(TokenKind::Colon)?;
1641        self.skip_newlines();
1642        self.expect(TokenKind::Indent)?;
1643        let mut arms = Vec::new();
1644        while !self.check(TokenKind::Dedent) && !self.at_end() {
1645            self.skip_newlines();
1646            if self.check(TokenKind::Dedent) { break; }
1647            let arm_start = self.current_span();
1648            let pattern = self.parse_pattern()?;
1649            self.expect(TokenKind::FatArrow)?;
1650            
1651            // Parse arm body - check if it starts with newline (multi-line body)
1652            let body = if matches!(self.peek_kind(), TokenKind::Newline(_)) {
1653                // Multi-line match arm body
1654                self.skip_newlines();
1655                
1656                if self.check(TokenKind::Indent) {
1657                    // It's an indented block - parse statements until dedent
1658                    self.advance(); // consume Indent
1659                    let mut stmts = Vec::new();
1660                    
1661                    while !self.check(TokenKind::Dedent) && !self.at_end() {
1662                        self.skip_newlines();
1663                        if self.check(TokenKind::Dedent) { break; }
1664                        stmts.push(self.parse_stmt()?);
1665                        self.skip_newlines();
1666                    }
1667                    
1668                    if self.check(TokenKind::Dedent) { 
1669                        self.advance(); // consume Dedent for arm body
1670                    }
1671                    
1672                    // Convert stmts to expression
1673                    if stmts.len() == 1 {
1674                        if let Stmt::Expr(e) = &stmts[0] {
1675                            e.clone()
1676                        } else if let Stmt::Return(Some(ref e), _) = &stmts[0] {
1677                            e.clone()
1678                        } else {
1679                            let block = Block { stmts, span: arm_start.merge(self.current_span()) };
1680                            Expr::Block(block, arm_start.merge(self.current_span()))
1681                        }
1682                    } else {
1683                        let block = Block { stmts, span: arm_start.merge(self.current_span()) };
1684                        Expr::Block(block, arm_start.merge(self.current_span()))
1685                    }
1686                } else {
1687                    // Just an expression on the next line (no indent)
1688                    self.parse_expr()?
1689                }
1690            } else {
1691                // Inline expression (same line as =>)
1692                self.parse_expr()?
1693            };
1694            
1695            arms.push(MatchArm { pattern, guard: None, body, span: self.current_span() });
1696            self.skip_newlines();
1697        }
1698        if self.check(TokenKind::Dedent) { self.advance(); }
1699        Ok(Expr::Match { scrutinee, arms, span: start.merge(self.current_span()) })
1700    }
1701
1702    fn parse_if(&mut self) -> KainResult<Expr> {
1703        let start = self.current_span();
1704        self.expect(TokenKind::If)?;
1705        let condition = Box::new(self.parse_expr()?);
1706        self.expect(TokenKind::Colon)?;
1707        
1708        // Check if this is an inline if (no newline/indent) or block if
1709        let is_block = matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Indent);
1710        let then_branch = if is_block {
1711            self.parse_block()?
1712        } else {
1713            // Inline if: parse single statement
1714            let stmt = self.parse_stmt()?;
1715            Block { stmts: vec![stmt], span: start.merge(self.current_span()) }
1716        };
1717        
1718        let else_branch = if self.check(TokenKind::Else) {
1719            self.advance();
1720            
1721            // Check for 'else if' (elif pattern) - no colon between else and if
1722            if self.check(TokenKind::If) {
1723                // Parse the 'if' expression
1724                let elif_expr = self.parse_if()?;
1725                
1726                // Extract the condition, then_branch, and else_branch from the If expression
1727                if let Expr::If { condition, then_branch, else_branch: nested_else, .. } = elif_expr {
1728                    Some(Box::new(ElseBranch::ElseIf(condition, then_branch, nested_else)))
1729                } else {
1730                    // Shouldn't happen, but fallback
1731                    return Err(KainError::parser("Expected if expression after else", self.current_span()));
1732                }
1733            } else {
1734                self.expect(TokenKind::Colon)?;
1735                let is_block = matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Indent);
1736                if is_block {
1737                    Some(Box::new(ElseBranch::Else(self.parse_block()?)))
1738                } else {
1739                    let stmt = self.parse_stmt()?;
1740                    Some(Box::new(ElseBranch::Else(Block { stmts: vec![stmt], span: start.merge(self.current_span()) })))
1741                }
1742            }
1743        } else { None };
1744        Ok(Expr::If { condition, then_branch, else_branch, span: start.merge(self.current_span()) })
1745    }
1746
1747    fn parse_pattern(&mut self) -> KainResult<Pattern> {
1748        let span = self.current_span();
1749        match self.peek_kind() {
1750            TokenKind::Ident(ref s) if s == "_" => { self.advance(); Ok(Pattern::Wildcard(span)) }
1751            TokenKind::Ident(ref s) => { 
1752                let name = s.clone(); 
1753                self.advance(); 
1754                
1755                if self.check(TokenKind::ColonColon) {
1756                    self.advance(); // consume ::
1757                    let variant = self.parse_ident()?;
1758                    
1759                    let fields = if self.check(TokenKind::LParen) {
1760                        self.advance();
1761                        let mut patterns = Vec::new();
1762                        while !self.check(TokenKind::RParen) {
1763                            patterns.push(self.parse_pattern()?);
1764                            if !self.check(TokenKind::RParen) {
1765                                self.expect(TokenKind::Comma)?;
1766                            }
1767                        }
1768                        self.expect(TokenKind::RParen)?;
1769                        VariantPatternFields::Tuple(patterns)
1770                    } else if self.check(TokenKind::LBrace) {
1771                        self.advance();
1772                        let mut fields = Vec::new();
1773                        while !self.check(TokenKind::RBrace) {
1774                            let fname = self.parse_ident()?;
1775                            self.expect(TokenKind::Colon)?;
1776                            let pat = self.parse_pattern()?;
1777                            fields.push((fname, pat));
1778                            if !self.check(TokenKind::RBrace) {
1779                                self.expect(TokenKind::Comma)?;
1780                            }
1781                        }
1782                        self.expect(TokenKind::RBrace)?;
1783                        VariantPatternFields::Struct(fields)
1784                    } else {
1785                        VariantPatternFields::Unit
1786                    };
1787                    
1788                    Ok(Pattern::Variant {
1789                        enum_name: Some(name),
1790                        variant,
1791                        fields,
1792                        span: span.merge(self.current_span()),
1793                    })
1794                } else if self.check(TokenKind::LParen) {
1795                    // Unqualified variant pattern: Variant(args) without EnumName::
1796                    // Common in Python-style pattern matching
1797                    self.advance(); // consume (
1798                    let mut patterns = Vec::new();
1799                    while !self.check(TokenKind::RParen) {
1800                        patterns.push(self.parse_pattern()?);
1801                        if !self.check(TokenKind::RParen) {
1802                            self.expect(TokenKind::Comma)?;
1803                        }
1804                    }
1805                    self.expect(TokenKind::RParen)?;
1806                    
1807                    Ok(Pattern::Variant {
1808                        enum_name: None, // Unqualified - will be resolved at type-check time
1809                        variant: name,
1810                        fields: VariantPatternFields::Tuple(patterns),
1811                        span: span.merge(self.current_span()),
1812                    })
1813                } else {
1814                    Ok(Pattern::Binding { name, mutable: false, span }) 
1815                }
1816            }
1817            TokenKind::Mut => {
1818                self.advance();
1819                let name = self.parse_ident()?;
1820                Ok(Pattern::Binding { name, mutable: true, span: span.merge(self.current_span()) })
1821            }
1822            TokenKind::Int(n) => { self.advance(); Ok(Pattern::Literal(Expr::Int(n, span))) }
1823            TokenKind::String(ref s) => { 
1824                let string_val = s.clone();
1825                self.advance(); 
1826                Ok(Pattern::Literal(Expr::String(string_val, span))) 
1827            }
1828            TokenKind::True => { self.advance(); Ok(Pattern::Literal(Expr::Bool(true, span))) }
1829            TokenKind::False => { self.advance(); Ok(Pattern::Literal(Expr::Bool(false, span))) }
1830            TokenKind::LParen => {
1831                self.advance();
1832                let mut patterns = Vec::new();
1833                while !self.check(TokenKind::RParen) {
1834                    patterns.push(self.parse_pattern()?);
1835                    if !self.check(TokenKind::RParen) { self.expect(TokenKind::Comma)?; }
1836                }
1837                self.expect(TokenKind::RParen)?;
1838                Ok(Pattern::Tuple(patterns, span.merge(self.current_span())))
1839            }
1840            TokenKind::LBracket => {
1841                self.advance();
1842                let mut patterns = Vec::new();
1843                while !self.check(TokenKind::RBracket) {
1844                    patterns.push(self.parse_pattern()?);
1845                    if !self.check(TokenKind::RBracket) { self.expect(TokenKind::Comma)?; }
1846                }
1847                self.expect(TokenKind::RBracket)?;
1848                Ok(Pattern::Slice { patterns, rest: None, span: span.merge(self.current_span()) })
1849            }
1850            _ => Err(KainError::parser("Expected pattern", span)),
1851        }
1852    }
1853
1854    #[allow(dead_code)]
1855    fn parse_jsx(&mut self) -> KainResult<JSXNode> {
1856        self.skip_newlines();
1857        self.expect(TokenKind::Indent)?;
1858        self.skip_newlines();
1859        let result = self.parse_jsx_element()?;
1860        self.skip_newlines();
1861        if self.check(TokenKind::Dedent) { self.advance(); }
1862        Ok(result)
1863    }
1864
1865    fn parse_jsx_element(&mut self) -> KainResult<JSXNode> {
1866        let start = self.current_span();
1867        self.expect(TokenKind::Lt)?;
1868        let tag = self.parse_ident()?;
1869        let mut attrs = Vec::new();
1870        while !self.check(TokenKind::Gt) && !self.check(TokenKind::Slash) {
1871            let name = self.parse_ident()?;
1872            self.expect(TokenKind::Eq)?;
1873            let value = if self.check(TokenKind::LBrace) {
1874                self.advance();
1875                let e = self.parse_expr()?;
1876                self.expect(TokenKind::RBrace)?;
1877                JSXAttrValue::Expr(e)
1878            } else if let TokenKind::String(s) = self.peek_kind() {
1879                self.advance();
1880                JSXAttrValue::String(s)
1881            } else {
1882                return Err(KainError::parser("Expected attribute value", self.current_span()));
1883            };
1884            attrs.push(JSXAttribute { name, value, span: self.current_span() });
1885        }
1886        
1887        if self.check(TokenKind::Slash) {
1888            self.advance();
1889            self.expect(TokenKind::Gt)?;
1890            return Ok(JSXNode::Element { tag, attributes: attrs, children: vec![], span: start.merge(self.current_span()) });
1891        }
1892        
1893        self.expect(TokenKind::Gt)?;
1894        
1895        let mut children = Vec::new();
1896        // Track the end of the previous token to detect gaps (whitespace)
1897        let mut last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1898        let mut text_buffer = String::new();
1899        let mut text_start = self.current_span();
1900
1901        while !self.check(TokenKind::LtSlash) && !self.at_end() {
1902            let current_span = self.current_span();
1903            
1904            // Check for gap (whitespace)
1905            if current_span.start > last_end {
1906                // If we have text in buffer, append space. If buffer empty, maybe leading space?
1907                // For simplicity, just append space if buffer not empty, or if we want to preserve spacing.
1908                // But JSX usually collapses whitespace.
1909                // However, "Count is: {count}" needs space.
1910                // Let's unconditionally add space if gap detected, but handle collapse later?
1911                // No, let's just add space.
1912                if !text_buffer.is_empty() {
1913                    text_buffer.push(' ');
1914                }
1915            }
1916
1917            if self.check(TokenKind::LBrace) {
1918                if !text_buffer.is_empty() {
1919                    children.push(JSXNode::Text(text_buffer.clone(), text_start.merge(Span::new(last_end, last_end))));
1920                    text_buffer.clear();
1921                }
1922
1923                self.advance();
1924                let expr = self.parse_expr()?;
1925                self.expect(TokenKind::RBrace)?;
1926                children.push(JSXNode::Expression(Box::new(expr)));
1927                
1928                last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1929                text_start = self.current_span(); // Reset text start for next text run
1930            } else if self.check(TokenKind::Lt) {
1931                 if !text_buffer.is_empty() {
1932                    children.push(JSXNode::Text(text_buffer.clone(), text_start.merge(Span::new(last_end, last_end))));
1933                    text_buffer.clear();
1934                }
1935
1936                 children.push(self.parse_jsx_element()?);
1937                 
1938                 last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1939                 text_start = self.current_span();
1940            } else {
1941                 let mut consumed_text = None;
1942                 match self.peek_kind() {
1943                     TokenKind::String(s) => consumed_text = Some(s),
1944                     TokenKind::Ident(s) => consumed_text = Some(s),
1945                     TokenKind::Int(n) => consumed_text = Some(n.to_string()),
1946                     TokenKind::Newline(_) | TokenKind::Indent | TokenKind::Dedent => {
1947                         // Treat newline/indent as whitespace
1948                         if !text_buffer.is_empty() && !text_buffer.ends_with(' ') {
1949                             text_buffer.push(' ');
1950                         }
1951                         self.advance();
1952                     }
1953                     TokenKind::Colon => consumed_text = Some(":".to_string()),
1954                     TokenKind::Comma => consumed_text = Some(",".to_string()),
1955                     TokenKind::Dot => consumed_text = Some(".".to_string()),
1956                     TokenKind::Question => consumed_text = Some("?".to_string()),
1957                     TokenKind::Not => consumed_text = Some("!".to_string()),
1958                     TokenKind::Minus => consumed_text = Some("-".to_string()),
1959                     TokenKind::Eq => consumed_text = Some("=".to_string()),
1960                     TokenKind::Plus => consumed_text = Some("+".to_string()),
1961                     TokenKind::Star => consumed_text = Some("*".to_string()),
1962                     TokenKind::Slash => consumed_text = Some("/".to_string()),
1963                     TokenKind::Percent => consumed_text = Some("%".to_string()),
1964                     TokenKind::Amp => consumed_text = Some("&".to_string()),
1965                     TokenKind::Pipe => consumed_text = Some("|".to_string()),
1966                     TokenKind::At => consumed_text = Some("@".to_string()),
1967                     TokenKind::Tilde => consumed_text = Some("~".to_string()),
1968                     TokenKind::Caret => consumed_text = Some("^".to_string()),
1969                     TokenKind::LParen => consumed_text = Some("(".to_string()),
1970                     TokenKind::RParen => consumed_text = Some(")".to_string()),
1971                     TokenKind::LBracket => consumed_text = Some("[".to_string()),
1972                     TokenKind::RBracket => consumed_text = Some("]".to_string()),
1973                     TokenKind::Arrow => consumed_text = Some("->".to_string()),
1974                     TokenKind::FatArrow => consumed_text = Some("=>".to_string()),
1975                     TokenKind::ColonColon => consumed_text = Some("::".to_string()),
1976                     TokenKind::And => consumed_text = Some("and".to_string()),
1977                     TokenKind::Or => consumed_text = Some("or".to_string()),
1978                     // Keywords that can appear as text in JSX
1979                     TokenKind::Gpu => consumed_text = Some("GPU".to_string()),
1980                     TokenKind::Io => consumed_text = Some("IO".to_string()),
1981                     TokenKind::Fn => consumed_text = Some("fn".to_string()),
1982                     TokenKind::Let => consumed_text = Some("let".to_string()),
1983                     TokenKind::Mut => consumed_text = Some("mut".to_string()),
1984                     TokenKind::Var => consumed_text = Some("var".to_string()),
1985                     TokenKind::Const => consumed_text = Some("const".to_string()),
1986                     TokenKind::If => consumed_text = Some("if".to_string()),
1987                     TokenKind::Else => consumed_text = Some("else".to_string()),
1988                     TokenKind::Match => consumed_text = Some("match".to_string()),
1989                     TokenKind::For => consumed_text = Some("for".to_string()),
1990                     TokenKind::While => consumed_text = Some("while".to_string()),
1991                     TokenKind::Loop => consumed_text = Some("loop".to_string()),
1992                     TokenKind::Break => consumed_text = Some("break".to_string()),
1993                     TokenKind::Continue => consumed_text = Some("continue".to_string()),
1994                     TokenKind::Return => consumed_text = Some("return".to_string()),
1995                     TokenKind::Await => consumed_text = Some("await".to_string()),
1996                     TokenKind::In => consumed_text = Some("in".to_string()),
1997                     TokenKind::With => consumed_text = Some("with".to_string()),
1998                     TokenKind::As => consumed_text = Some("as".to_string()),
1999                     TokenKind::TypeKw => consumed_text = Some("type".to_string()),
2000                     TokenKind::Struct => consumed_text = Some("struct".to_string()),
2001                     TokenKind::Enum => consumed_text = Some("enum".to_string()),
2002                     TokenKind::Trait => consumed_text = Some("trait".to_string()),
2003                     TokenKind::Impl => consumed_text = Some("impl".to_string()),
2004                     TokenKind::Pub => consumed_text = Some("pub".to_string()),
2005                     TokenKind::Mod => consumed_text = Some("mod".to_string()),
2006                     TokenKind::Use => consumed_text = Some("use".to_string()),
2007                     TokenKind::True => consumed_text = Some("true".to_string()),
2008                     TokenKind::False => consumed_text = Some("false".to_string()),
2009                     TokenKind::Pure => consumed_text = Some("Pure".to_string()),
2010                     TokenKind::Async => consumed_text = Some("Async".to_string()),
2011                     TokenKind::Component => consumed_text = Some("component".to_string()),
2012                     TokenKind::Shader => consumed_text = Some("shader".to_string()),
2013                     TokenKind::Actor => consumed_text = Some("actor".to_string()),
2014                     TokenKind::Spawn => consumed_text = Some("spawn".to_string()),
2015                     TokenKind::Test => consumed_text = Some("test".to_string()),
2016                     TokenKind::Reactive => consumed_text = Some("Reactive".to_string()),
2017                     TokenKind::Unsafe => consumed_text = Some("Unsafe".to_string()),
2018                     TokenKind::Vertex => consumed_text = Some("vertex".to_string()),
2019                     TokenKind::Fragment => consumed_text = Some("fragment".to_string()),
2020                     _ => {
2021                         return Err(KainError::parser(format!("Unexpected token in JSX child: {:?}. Use strings or {{}} for text.", self.peek_kind()), self.current_span()));
2022                     }
2023                 }
2024                 
2025                 if let Some(t) = consumed_text {
2026                     if text_buffer.is_empty() {
2027                         text_start = self.current_span();
2028                     }
2029                     text_buffer.push_str(&t);
2030                     self.advance();
2031                 }
2032                 
2033                 last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
2034            }
2035        }
2036        
2037        if !text_buffer.is_empty() {
2038            children.push(JSXNode::Text(text_buffer, text_start.merge(Span::new(last_end, last_end))));
2039        }
2040        
2041        self.expect(TokenKind::LtSlash)?;
2042        let closing_tag = self.parse_ident()?;
2043        if closing_tag != tag {
2044            return Err(KainError::parser(format!("Expected closing tag </{}>, found </{}>", tag, closing_tag), self.current_span()));
2045        }
2046        self.expect(TokenKind::Gt)?;
2047        
2048        Ok(JSXNode::Element { tag, attributes: attrs, children, span: start.merge(self.current_span()) })
2049    }
2050
2051    fn parse_call_args(&mut self) -> KainResult<Vec<CallArg>> {
2052        let mut args = Vec::new();
2053        self.skip_formatting();
2054        while !self.check(TokenKind::RParen) && !self.at_end() {
2055            let mut name = None;
2056            // Check for named argument: ident = expr
2057            if let TokenKind::Ident(s) = self.peek_kind() {
2058                // Look ahead for '='
2059                if self.tokens.get(self.pos + 1).map(|t| t.kind == TokenKind::Eq).unwrap_or(false) {
2060                    name = Some(s);
2061                    self.advance(); // eat ident
2062                    self.advance(); // eat =
2063                }
2064            }
2065            
2066            let value = self.parse_expr()?;
2067            args.push(CallArg { name, value, span: self.current_span() });
2068            
2069            self.skip_formatting();
2070            if !self.check(TokenKind::RParen) { 
2071                self.expect(TokenKind::Comma)?; 
2072                self.skip_formatting();
2073            }
2074        }
2075        Ok(args)
2076    }
2077
2078    fn parse_visibility(&mut self) -> Visibility {
2079        if self.check(TokenKind::Pub) { self.advance(); Visibility::Public } else { Visibility::Private }
2080    }
2081
2082    fn parse_ident(&mut self) -> KainResult<String> {
2083        match self.peek_kind() {
2084            TokenKind::Ident(s) => { self.advance(); Ok(s) }
2085            TokenKind::SelfLower => { self.advance(); Ok("self".to_string()) }
2086            TokenKind::SelfUpper => { self.advance(); Ok("Self".to_string()) }
2087            k => Err(KainError::parser(format!("Expected identifier, got {:?}", k), self.current_span())),
2088        }
2089    }
2090
2091    fn get_binary_op(&self) -> Option<(BinaryOp, u8)> {
2092        match self.peek_kind() {
2093            TokenKind::Or => Some((BinaryOp::Or, 1)),
2094            TokenKind::And => Some((BinaryOp::And, 2)),
2095            TokenKind::EqEq => Some((BinaryOp::Eq, 3)),
2096            TokenKind::NotEq => Some((BinaryOp::Ne, 3)),
2097            TokenKind::Lt => Some((BinaryOp::Lt, 4)),
2098            TokenKind::Gt => Some((BinaryOp::Gt, 4)),
2099            TokenKind::LtEq => Some((BinaryOp::Le, 4)),
2100            TokenKind::GtEq => Some((BinaryOp::Ge, 4)),
2101            TokenKind::Plus => Some((BinaryOp::Add, 5)),
2102            TokenKind::Minus => Some((BinaryOp::Sub, 5)),
2103            TokenKind::Star => Some((BinaryOp::Mul, 6)),
2104            TokenKind::Slash => Some((BinaryOp::Div, 6)),
2105            TokenKind::Percent => Some((BinaryOp::Mod, 6)),
2106            TokenKind::Power => Some((BinaryOp::Pow, 7)),
2107            _ => None,
2108        }
2109    }
2110
2111    // Helper methods
2112    fn peek_kind(&self) -> TokenKind { self.tokens.get(self.pos).map(|t| t.kind.clone()).unwrap_or(TokenKind::Eof) }
2113    fn current_span(&self) -> Span { self.tokens.get(self.pos).map(|t| t.span).unwrap_or(Span::new(0, 0)) }
2114    fn at_end(&self) -> bool { matches!(self.peek_kind(), TokenKind::Eof) }
2115    fn check(&self, k: TokenKind) -> bool { std::mem::discriminant(&self.peek_kind()) == std::mem::discriminant(&k) }
2116    fn check_line_end(&self) -> bool { matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Dedent | TokenKind::Eof) }
2117    fn advance(&mut self) { if !self.at_end() { self.pos += 1; } }
2118    fn skip_newlines(&mut self) { while let TokenKind::Newline(_) = self.peek_kind() { self.advance(); } }
2119    fn check_newline(&self) -> bool { matches!(self.peek_kind(), TokenKind::Newline(_)) }
2120    fn skip_formatting(&mut self) {
2121        while matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Indent | TokenKind::Dedent) {
2122            self.advance();
2123        }
2124    }
2125
2126    fn expect(&mut self, k: TokenKind) -> KainResult<()> {
2127        if self.check(k.clone()) { self.advance(); Ok(()) }
2128        else { Err(KainError::parser(format!("Expected {:?}, got {:?}", k, self.peek_kind()), self.current_span())) }
2129    }
2130}
2131
kain/parser.rs

kain/
parser.rs
