Skip to main content

kore/
parser.rs

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