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::Var => self.parse_var(),
904            TokenKind::Return => self.parse_return(),
905            TokenKind::For => self.parse_for(),
906            TokenKind::While => self.parse_while(),
907            TokenKind::Loop => self.parse_loop(),
908            TokenKind::Break => self.parse_break(),
909            TokenKind::Continue => self.parse_continue(),
910            _ => Ok(Stmt::Expr(self.parse_expr()?)),
911        }
912    }
913
914    fn parse_let(&mut self) -> KoreResult<Stmt> {
915        let start = self.current_span();
916        self.expect(TokenKind::Let)?;
917        let pattern = self.parse_pattern()?;
918        let ty = if self.check(TokenKind::Colon) { self.advance(); Some(self.parse_type()?) } else { None };
919        self.expect(TokenKind::Eq)?;
920        let value = Some(self.parse_expr()?);
921        Ok(Stmt::Let { pattern, ty, value, span: start.merge(self.current_span()) })
922    }
923
924    fn parse_var(&mut self) -> KoreResult<Stmt> {
925        let start = self.current_span();
926        self.expect(TokenKind::Var)?;
927        let name = self.parse_ident()?;
928        let ty = if self.check(TokenKind::Colon) { self.advance(); Some(self.parse_type()?) } else { None };
929        self.expect(TokenKind::Eq)?;
930        let value = Some(self.parse_expr()?);
931        // var x = val is effectively let mut x = val
932        let pattern = Pattern::Binding { name, mutable: true, span: start };
933        Ok(Stmt::Let { pattern, ty, value, span: start.merge(self.current_span()) })
934    }
935
936    fn parse_return(&mut self) -> KoreResult<Stmt> {
937        let start = self.current_span();
938        self.expect(TokenKind::Return)?;
939        let value = if !self.check_line_end() { Some(self.parse_expr()?) } else { None };
940        Ok(Stmt::Return(value, start.merge(self.current_span())))
941    }
942
943    fn parse_for(&mut self) -> KoreResult<Stmt> {
944        let start = self.current_span();
945        self.expect(TokenKind::For)?;
946        let name = self.parse_ident()?;
947        self.expect(TokenKind::In)?;
948        let iter = self.parse_expr()?;
949        self.expect(TokenKind::Colon)?;
950        let body = self.parse_block()?;
951        Ok(Stmt::For { binding: Pattern::Binding { name, mutable: false, span: start }, iter, body, span: start.merge(self.current_span()) })
952    }
953
954    fn parse_while(&mut self) -> KoreResult<Stmt> {
955        let start = self.current_span();
956        self.expect(TokenKind::While)?;
957        let condition = self.parse_expr()?;
958        self.expect(TokenKind::Colon)?;
959        let body = self.parse_block()?;
960        Ok(Stmt::While { condition, body, span: start.merge(self.current_span()) })
961    }
962
963    fn parse_loop(&mut self) -> KoreResult<Stmt> {
964        let start = self.current_span();
965        self.expect(TokenKind::Loop)?;
966        self.expect(TokenKind::Colon)?;
967        let body = self.parse_block()?;
968        Ok(Stmt::Loop { body, span: start.merge(self.current_span()) })
969    }
970
971    fn parse_break(&mut self) -> KoreResult<Stmt> {
972        let start = self.current_span();
973        self.expect(TokenKind::Break)?;
974        // Optional value: break expr
975        let value = if !self.check_line_end() && !self.check(TokenKind::Dedent) {
976            Some(self.parse_expr()?)
977        } else {
978            None
979        };
980        Ok(Stmt::Break(value, start.merge(self.current_span())))
981    }
982
983    fn parse_continue(&mut self) -> KoreResult<Stmt> {
984        let start = self.current_span();
985        self.expect(TokenKind::Continue)?;
986        Ok(Stmt::Continue(start.merge(self.current_span())))
987    }
988    fn parse_expr(&mut self) -> KoreResult<Expr> { self.parse_assignment() }
989
990    fn parse_assignment(&mut self) -> KoreResult<Expr> {
991        let expr = self.parse_binary(0)?;
992        
993        if self.check(TokenKind::Eq) {
994            self.advance();
995            let value = self.parse_assignment()?;
996            let span = expr.span().merge(value.span());
997            Ok(Expr::Assign { target: Box::new(expr), value: Box::new(value), span })
998        } else {
999            Ok(expr)
1000        }
1001    }
1002
1003    fn parse_binary(&mut self, min_prec: u8) -> KoreResult<Expr> {
1004        let mut left = self.parse_unary()?;
1005        
1006        while let Some((op, prec)) = self.get_binary_op() {
1007            if prec < min_prec { break; }
1008            self.advance();
1009            let right = self.parse_binary(prec + 1)?;
1010            let span = left.span().merge(right.span());
1011            left = Expr::Binary { left: Box::new(left), op, right: Box::new(right), span };
1012        }
1013        Ok(left)
1014    }
1015
1016    fn parse_unary(&mut self) -> KoreResult<Expr> {
1017        match self.peek_kind() {
1018            TokenKind::Minus => { let s = self.current_span(); self.advance(); Ok(Expr::Unary { op: UnaryOp::Neg, operand: Box::new(self.parse_unary()?), span: s }) }
1019            TokenKind::Not => { let s = self.current_span(); self.advance(); Ok(Expr::Unary { op: UnaryOp::Not, operand: Box::new(self.parse_unary()?), span: s }) }
1020            TokenKind::Await => {
1021                let start = self.current_span();
1022                self.advance();
1023                let expr = self.parse_unary()?; // Right-associative: await await x
1024                Ok(Expr::Await(Box::new(expr), start.merge(self.current_span())))
1025            }
1026            TokenKind::Send => {
1027                let start = self.current_span();
1028                self.advance();
1029                let expr = self.parse_postfix()?;
1030                
1031                if let Expr::Call { callee, args, span } = expr {
1032                    if let Expr::Field { object, field, span: _ } = *callee {
1033                        let mut data = Vec::new();
1034                        for arg in args {
1035                            if let Some(name) = arg.name {
1036                                data.push((name, arg.value));
1037                            } else {
1038                                return Err(KoreError::parser("Send requires named arguments", arg.span));
1039                            }
1040                        }
1041                        Ok(Expr::SendMsg { target: object, message: field, data, span: start.merge(span) })
1042                    } else {
1043                        Err(KoreError::parser("Expected method call after send (e.g., actor.message())", span))
1044                    }
1045                } else {
1046                    Err(KoreError::parser("Expected message call after send", expr.span()))
1047                }
1048            }
1049            _ => self.parse_postfix(),
1050        }
1051    }
1052
1053    fn parse_postfix(&mut self) -> KoreResult<Expr> {
1054        let mut expr = self.parse_primary()?;
1055        loop {
1056            match self.peek_kind() {
1057                TokenKind::LParen => { 
1058                    self.advance(); 
1059                    let args = self.parse_call_args()?; 
1060                    self.expect(TokenKind::RParen)?; 
1061                    let s = expr.span().merge(self.current_span()); 
1062                    
1063                    if let Expr::Field { object, field, span: _ } = expr {
1064                        expr = Expr::MethodCall { receiver: object, method: field, args, span: s };
1065                    } else {
1066                        expr = Expr::Call { callee: Box::new(expr), args, span: s }; 
1067                    }
1068                }
1069                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 }; }
1070            TokenKind::As => {
1071                self.advance();
1072                let target = self.parse_type()?;
1073                let s = expr.span().merge(self.current_span());
1074                expr = Expr::Cast { value: Box::new(expr), target, span: s };
1075            }
1076            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 }; }
1077            TokenKind::Question => { self.advance(); let s = expr.span().merge(self.current_span()); expr = Expr::Try(Box::new(expr), s); }
1078            TokenKind::Not => {
1079                // Macro invocation: ident!(args)
1080                if let Expr::Ident(name, _) = &expr {
1081                    self.advance(); // consume '!'
1082                    self.expect(TokenKind::LParen)?;
1083                    let args = if !self.check(TokenKind::RParen) {
1084                        let mut args = Vec::new();
1085                        args.push(self.parse_expr()?);
1086                        while self.check(TokenKind::Comma) {
1087                            self.advance();
1088                            if self.check(TokenKind::RParen) { break; }
1089                            args.push(self.parse_expr()?);
1090                        }
1091                        args
1092                    } else {
1093                        Vec::new()
1094                    };
1095                    self.expect(TokenKind::RParen)?;
1096                    let s = expr.span().merge(self.current_span());
1097                    expr = Expr::MacroCall { name: name.clone(), args, span: s };
1098                } else {
1099                     // Maybe unary not? But we are in postfix. Unary not is handled in parse_unary.
1100                     // Postfix ! usually means macro or maybe future features (like factorial?).
1101                     // For now, only support macros on identifiers.
1102                     return Err(KoreError::parser("Macro invocation only allowed on identifiers", self.current_span()));
1103                }
1104            }
1105            _ => break,
1106            }
1107        }
1108        Ok(expr)
1109    }
1110
1111    fn parse_primary(&mut self) -> KoreResult<Expr> {
1112        let span = self.current_span();
1113        match self.peek_kind() {
1114            TokenKind::Int(n) => { self.advance(); Ok(Expr::Int(n, span)) }
1115            TokenKind::Float(n) => { self.advance(); Ok(Expr::Float(n, span)) }
1116            TokenKind::String(ref s) => { let s = s.clone(); self.advance(); Ok(Expr::String(s, span)) }
1117            TokenKind::FString(ref s) => {
1118                let s = s.clone();
1119                self.advance();
1120                let mut parts = Vec::new();
1121                let mut last_idx = 0;
1122                let mut chars = s.char_indices().peekable();
1123                
1124                while let Some((idx, c)) = chars.next() {
1125                    if c == '{' {
1126                        if idx > last_idx {
1127                            parts.push(Expr::String(s[last_idx..idx].to_string(), span));
1128                        }
1129                        
1130                        let expr_start = idx + 1;
1131                        let mut depth = 1;
1132                        let mut expr_end = expr_start;
1133                        
1134                        while let Some((i, c2)) = chars.next() {
1135                            if c2 == '{' { depth += 1; }
1136                            else if c2 == '}' {
1137                                depth -= 1;
1138                                if depth == 0 {
1139                                    expr_end = i;
1140                                    break;
1141                                }
1142                            }
1143                        }
1144                        
1145                        if depth == 0 {
1146                            let expr_str = &s[expr_start..expr_end];
1147                            let tokens = Lexer::new(expr_str).tokenize()?;
1148                            let mut parser = Parser::new(&tokens);
1149                            let expr = parser.parse_expr()?;
1150                            parts.push(expr);
1151                            last_idx = expr_end + 1;
1152                        } else {
1153                             return Err(KoreError::parser("Unclosed '{' in f-string", span));
1154                        }
1155                    }
1156                }
1157                
1158                if last_idx < s.len() {
1159                    parts.push(Expr::String(s[last_idx..].to_string(), span));
1160                }
1161                
1162                Ok(Expr::FString(parts, span))
1163            }
1164            TokenKind::True => { self.advance(); Ok(Expr::Bool(true, span)) }
1165            TokenKind::False => { self.advance(); Ok(Expr::Bool(false, span)) }
1166            TokenKind::None => { self.advance(); Ok(Expr::None(span)) }
1167            TokenKind::Ident(ref s) => { 
1168                let name = s.clone(); 
1169                self.advance();
1170
1171                if self.check(TokenKind::ColonColon) {
1172                    self.advance();
1173                    let variant = self.parse_ident()?;
1174
1175                    let fields = if self.check(TokenKind::LParen) {
1176                        self.advance();
1177                        self.skip_newlines();
1178                        let mut items = Vec::new();
1179                        if !self.check(TokenKind::RParen) {
1180                            items.push(self.parse_expr()?);
1181                            while self.check(TokenKind::Comma) {
1182                                self.advance();
1183                                if self.check(TokenKind::RParen) {
1184                                    break;
1185                                }
1186                                items.push(self.parse_expr()?);
1187                            }
1188                        }
1189                        self.expect(TokenKind::RParen)?;
1190                        if items.is_empty() {
1191                            EnumVariantFields::Unit
1192                        } else {
1193                            EnumVariantFields::Tuple(items)
1194                        }
1195                    } else if self.check(TokenKind::LBrace) {
1196                        self.advance();
1197                        let mut fields = Vec::new();
1198
1199                        self.skip_newlines();
1200                        let indented = if self.check(TokenKind::Indent) {
1201                            self.advance();
1202                            true
1203                        } else {
1204                            false
1205                        };
1206
1207                        while !self.check(TokenKind::RBrace) && !self.at_end() {
1208                            if indented && self.check(TokenKind::Dedent) {
1209                                break;
1210                            }
1211
1212                            let field_name = self.parse_ident()?;
1213                            self.expect(TokenKind::Colon)?;
1214                            let field_value = self.parse_expr()?;
1215                            fields.push((field_name, field_value));
1216
1217                            if !self.check(TokenKind::RBrace) && (!indented || !self.check(TokenKind::Dedent)) {
1218                                if self.check(TokenKind::Comma) {
1219                                    self.advance();
1220                                }
1221                            }
1222                            self.skip_newlines();
1223                        }
1224
1225                        if indented {
1226                            self.expect(TokenKind::Dedent)?;
1227                        }
1228                        self.expect(TokenKind::RBrace)?;
1229                        EnumVariantFields::Struct(fields)
1230                    } else {
1231                        EnumVariantFields::Unit
1232                    };
1233
1234                    return Ok(Expr::EnumVariant {
1235                        enum_name: name,
1236                        variant,
1237                        fields,
1238                        span: span.merge(self.current_span()),
1239                    });
1240                }
1241                
1242                // Check if this is a struct literal: Name { field: value, ... }
1243                if self.check(TokenKind::LBrace) {
1244                    self.advance(); // consume {
1245                    let mut fields = Vec::new();
1246                    
1247                    self.skip_newlines();
1248                    let indented = if self.check(TokenKind::Indent) {
1249                        self.advance();
1250                        true
1251                    } else {
1252                        false
1253                    };
1254                    
1255                    while !self.check(TokenKind::RBrace) && !self.at_end() {
1256                        if indented && self.check(TokenKind::Dedent) {
1257                            break;
1258                        }
1259                        
1260                        let field_name = self.parse_ident()?;
1261                        self.expect(TokenKind::Colon)?;
1262                        let field_value = self.parse_expr()?;
1263                        fields.push((field_name, field_value));
1264                        
1265                        // Optional comma if not closing
1266                        if !self.check(TokenKind::RBrace) && (!indented || !self.check(TokenKind::Dedent)) {
1267                            if self.check(TokenKind::Comma) {
1268                                self.advance();
1269                            }
1270                        }
1271                        self.skip_newlines();
1272                    }
1273                    
1274                    if indented {
1275                        self.expect(TokenKind::Dedent)?;
1276                    }
1277                    self.expect(TokenKind::RBrace)?;
1278                    
1279                    Ok(Expr::Struct { 
1280                        name, 
1281                        fields, 
1282                        span: span.merge(self.current_span()) 
1283                    })
1284                } else {
1285                    Ok(Expr::Ident(name, span))
1286                }
1287            }
1288            TokenKind::SelfLower => { 
1289                self.advance(); 
1290                Ok(Expr::Ident("self".to_string(), span)) 
1291            }
1292            TokenKind::SelfUpper => { 
1293                self.advance(); 
1294                Ok(Expr::Ident("Self".to_string(), span)) 
1295            }
1296            TokenKind::LParen => { 
1297                self.advance(); 
1298                if self.check(TokenKind::RParen) {
1299                    self.advance();
1300                    Ok(Expr::Tuple(vec![], span.merge(self.current_span())))
1301                } else {
1302                    let first = self.parse_expr()?;
1303                    if self.check(TokenKind::Comma) {
1304                        self.advance();
1305                        let mut items = vec![first];
1306                        while !self.check(TokenKind::RParen) {
1307                            items.push(self.parse_expr()?);
1308                            if !self.check(TokenKind::RParen) { self.expect(TokenKind::Comma)?; }
1309                        }
1310                        self.expect(TokenKind::RParen)?;
1311                        Ok(Expr::Tuple(items, span.merge(self.current_span())))
1312                    } else {
1313                        self.expect(TokenKind::RParen)?;
1314                        Ok(Expr::Paren(Box::new(first), span.merge(self.current_span())))
1315                    }
1316                }
1317            }
1318            TokenKind::LBracket => { 
1319                self.advance();
1320                self.skip_newlines();
1321                
1322                // Check for indent (multi-line array)
1323                let indented = if self.check(TokenKind::Indent) {
1324                    self.advance();
1325                    true
1326                } else {
1327                    false
1328                };
1329                
1330                let mut items = vec![];
1331                while !self.check(TokenKind::RBracket) && !self.at_end() {
1332                    if indented && self.check(TokenKind::Dedent) {
1333                        break;
1334                    }
1335                    self.skip_newlines();
1336                    if self.check(TokenKind::RBracket) {
1337                        break;
1338                    }
1339                    items.push(self.parse_expr()?);
1340                    self.skip_newlines();
1341                    if !self.check(TokenKind::RBracket) && !self.check(TokenKind::Dedent) { 
1342                        if self.check(TokenKind::Comma) {
1343                            self.advance();
1344                            self.skip_newlines();
1345                        }
1346                    }
1347                }
1348                
1349                if indented {
1350                    if self.check(TokenKind::Dedent) {
1351                        self.advance();
1352                    }
1353                }
1354                self.skip_newlines();
1355                self.expect(TokenKind::RBracket)?; 
1356                Ok(Expr::Array(items, span)) 
1357            }
1358            TokenKind::Comptime => {
1359                self.advance();
1360                self.expect(TokenKind::Colon)?;
1361                let body = self.parse_block()?;
1362                Ok(Expr::Comptime(Box::new(Expr::Block(body, span)), span))
1363            }
1364            TokenKind::Pipe => {
1365                self.advance();
1366                let mut params = Vec::new();
1367                while !self.check(TokenKind::Pipe) {
1368                    let name = self.parse_ident()?;
1369                    params.push(Param {
1370                        name,
1371                        ty: Type::Infer(span),
1372                        mutable: false,
1373                        default: None,
1374                        span,
1375                    });
1376                    if !self.check(TokenKind::Pipe) { self.expect(TokenKind::Comma)?; }
1377                }
1378                self.expect(TokenKind::Pipe)?;
1379                let body = self.parse_expr()?;
1380                Ok(Expr::Lambda { params, return_type: None, body: Box::new(body), span: span.merge(self.current_span()) })
1381            }
1382            TokenKind::Match => self.parse_match(),
1383            TokenKind::Spawn => {
1384                self.advance();
1385                let actor = self.parse_ident()?;
1386                self.expect(TokenKind::LParen)?;
1387                let args = self.parse_call_args()?;
1388                self.expect(TokenKind::RParen)?;
1389                
1390                let mut init = Vec::new();
1391                for arg in args {
1392                    if let Some(name) = arg.name {
1393                        init.push((name, arg.value));
1394                    } else {
1395                         return Err(KoreError::parser("Spawn requires named arguments", arg.span));
1396                    }
1397                }
1398                Ok(Expr::Spawn { actor, init, span: span.merge(self.current_span()) })
1399            }
1400            TokenKind::Return => {
1401                let start = self.current_span();
1402                self.advance();
1403                let value = if !self.check_line_end() 
1404                    && !self.check(TokenKind::Comma) 
1405                    && !self.check(TokenKind::RParen) 
1406                    && !self.check(TokenKind::RBrace) 
1407                    && !self.check(TokenKind::RBracket) 
1408                {
1409                    Some(Box::new(self.parse_expr()?))
1410                } else {
1411                    None
1412                };
1413                Ok(Expr::Return(value, start.merge(self.current_span())))
1414            }
1415            TokenKind::If => self.parse_if(),
1416            TokenKind::Lt => {
1417                let jsx = self.parse_jsx_element()?;
1418                Ok(Expr::JSX(jsx, span.merge(self.current_span())))
1419            }
1420            // Lambda with fn syntax: fn(x: Int) -> Int: return x * 2
1421            // or fn(x: Int): return x * 2
1422            TokenKind::Fn => {
1423                self.advance(); // consume fn
1424                self.expect(TokenKind::LParen)?;
1425                
1426                // Parse parameters with types
1427                let mut params = Vec::new();
1428                while !self.check(TokenKind::RParen) && !self.at_end() {
1429                    let p_span = self.current_span();
1430                    let name = self.parse_ident()?;
1431                    
1432                    // Parse type annotation
1433                    let ty = if self.check(TokenKind::Colon) {
1434                        self.advance();
1435                        self.parse_type()?
1436                    } else {
1437                        Type::Infer(p_span)
1438                    };
1439                    
1440                    params.push(Param {
1441                        name,
1442                        ty,
1443                        mutable: false,
1444                        default: None,
1445                        span: p_span,
1446                    });
1447                    
1448                    if !self.check(TokenKind::RParen) {
1449                        self.expect(TokenKind::Comma)?;
1450                    }
1451                }
1452                self.expect(TokenKind::RParen)?;
1453                
1454                // Parse optional return type
1455                let return_type = if self.check(TokenKind::Arrow) {
1456                    self.advance();
1457                    Some(self.parse_type()?)
1458                } else {
1459                    None
1460                };
1461                
1462                self.expect(TokenKind::Colon)?;
1463                
1464                // Parse body - can be a single expression or a block
1465                let body = if self.check(TokenKind::Return) {
1466                    // Single return statement: fn(x): return x * 2
1467                    self.advance();
1468                    self.parse_expr()?
1469                } else if self.check(TokenKind::Indent) || self.check_newline() {
1470                    // Block body (multi-line lambda)
1471                    self.skip_newlines();
1472                    let block = self.parse_block()?;
1473                    Expr::Block(block, span)
1474                } else {
1475                    // Single expression: fn(x): x * 2
1476                    self.parse_expr()?
1477                };
1478                
1479                Ok(Expr::Lambda { 
1480                    params, 
1481                    return_type, 
1482                    body: Box::new(body), 
1483                    span: span.merge(self.current_span()) 
1484                })
1485            }
1486            // Control flow as expressions (for use in match arms, etc.)
1487            TokenKind::Continue => {
1488                self.advance();
1489                // Continue as an expression wraps in a block that continues
1490                Ok(Expr::Continue(span))
1491            }
1492            TokenKind::Break => {
1493                self.advance();
1494                // Optional break value
1495                let value = if !self.check_line_end() && !self.check(TokenKind::Dedent) 
1496                    && !self.check(TokenKind::Comma) && !self.check(TokenKind::RParen) {
1497                    Some(Box::new(self.parse_expr()?))
1498                } else {
1499                    None
1500                };
1501                Ok(Expr::Break(value, span))
1502            }
1503            _ => Err(KoreError::parser(format!("Unexpected token: {:?}", self.peek_kind()), span)),
1504        }
1505    }
1506
1507    fn parse_match(&mut self) -> KoreResult<Expr> {
1508        let start = self.current_span();
1509        self.expect(TokenKind::Match)?;
1510        let scrutinee = Box::new(self.parse_expr()?);
1511        self.expect(TokenKind::Colon)?;
1512        self.skip_newlines();
1513        self.expect(TokenKind::Indent)?;
1514        let mut arms = Vec::new();
1515        while !self.check(TokenKind::Dedent) && !self.at_end() {
1516            self.skip_newlines();
1517            if self.check(TokenKind::Dedent) { break; }
1518            let arm_start = self.current_span();
1519            let pattern = self.parse_pattern()?;
1520            self.expect(TokenKind::FatArrow)?;
1521            
1522            // Parse arm body - check if it starts with newline (multi-line body)
1523            let body = if matches!(self.peek_kind(), TokenKind::Newline(_)) {
1524                // Multi-line match arm body
1525                self.skip_newlines();
1526                
1527                if self.check(TokenKind::Indent) {
1528                    // It's an indented block - parse statements until dedent
1529                    self.advance(); // consume Indent
1530                    let mut stmts = Vec::new();
1531                    
1532                    while !self.check(TokenKind::Dedent) && !self.at_end() {
1533                        self.skip_newlines();
1534                        if self.check(TokenKind::Dedent) { break; }
1535                        stmts.push(self.parse_stmt()?);
1536                        self.skip_newlines();
1537                    }
1538                    
1539                    if self.check(TokenKind::Dedent) { 
1540                        self.advance(); // consume Dedent for arm body
1541                    }
1542                    
1543                    // Convert stmts to expression
1544                    if stmts.len() == 1 {
1545                        if let Stmt::Expr(e) = &stmts[0] {
1546                            e.clone()
1547                        } else if let Stmt::Return(Some(ref e), _) = &stmts[0] {
1548                            e.clone()
1549                        } else {
1550                            let block = Block { stmts, span: arm_start.merge(self.current_span()) };
1551                            Expr::Block(block, arm_start.merge(self.current_span()))
1552                        }
1553                    } else {
1554                        let block = Block { stmts, span: arm_start.merge(self.current_span()) };
1555                        Expr::Block(block, arm_start.merge(self.current_span()))
1556                    }
1557                } else {
1558                    // Just an expression on the next line (no indent)
1559                    self.parse_expr()?
1560                }
1561            } else {
1562                // Inline expression (same line as =>)
1563                self.parse_expr()?
1564            };
1565            
1566            arms.push(MatchArm { pattern, guard: None, body, span: self.current_span() });
1567            self.skip_newlines();
1568        }
1569        if self.check(TokenKind::Dedent) { self.advance(); }
1570        Ok(Expr::Match { scrutinee, arms, span: start.merge(self.current_span()) })
1571    }
1572
1573    fn parse_if(&mut self) -> KoreResult<Expr> {
1574        let start = self.current_span();
1575        self.expect(TokenKind::If)?;
1576        let condition = Box::new(self.parse_expr()?);
1577        self.expect(TokenKind::Colon)?;
1578        
1579        // Check if this is an inline if (no newline/indent) or block if
1580        let is_block = matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Indent);
1581        let then_branch = if is_block {
1582            self.parse_block()?
1583        } else {
1584            // Inline if: parse single statement
1585            let stmt = self.parse_stmt()?;
1586            Block { stmts: vec![stmt], span: start.merge(self.current_span()) }
1587        };
1588        
1589        let else_branch = if self.check(TokenKind::Else) {
1590            self.advance();
1591            
1592            // Check for 'else if' (elif pattern) - no colon between else and if
1593            if self.check(TokenKind::If) {
1594                // Parse the 'if' expression
1595                let elif_expr = self.parse_if()?;
1596                
1597                // Extract the condition, then_branch, and else_branch from the If expression
1598                if let Expr::If { condition, then_branch, else_branch: nested_else, .. } = elif_expr {
1599                    Some(Box::new(ElseBranch::ElseIf(condition, then_branch, nested_else)))
1600                } else {
1601                    // Shouldn't happen, but fallback
1602                    return Err(KoreError::parser("Expected if expression after else", self.current_span()));
1603                }
1604            } else {
1605                self.expect(TokenKind::Colon)?;
1606                let is_block = matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Indent);
1607                if is_block {
1608                    Some(Box::new(ElseBranch::Else(self.parse_block()?)))
1609                } else {
1610                    let stmt = self.parse_stmt()?;
1611                    Some(Box::new(ElseBranch::Else(Block { stmts: vec![stmt], span: start.merge(self.current_span()) })))
1612                }
1613            }
1614        } else { None };
1615        Ok(Expr::If { condition, then_branch, else_branch, span: start.merge(self.current_span()) })
1616    }
1617
1618    fn parse_pattern(&mut self) -> KoreResult<Pattern> {
1619        let span = self.current_span();
1620        match self.peek_kind() {
1621            TokenKind::Ident(ref s) if s == "_" => { self.advance(); Ok(Pattern::Wildcard(span)) }
1622            TokenKind::Ident(ref s) => { 
1623                let name = s.clone(); 
1624                self.advance(); 
1625                
1626                if self.check(TokenKind::ColonColon) {
1627                    self.advance(); // consume ::
1628                    let variant = self.parse_ident()?;
1629                    
1630                    let fields = if self.check(TokenKind::LParen) {
1631                        self.advance();
1632                        let mut patterns = Vec::new();
1633                        while !self.check(TokenKind::RParen) {
1634                            patterns.push(self.parse_pattern()?);
1635                            if !self.check(TokenKind::RParen) {
1636                                self.expect(TokenKind::Comma)?;
1637                            }
1638                        }
1639                        self.expect(TokenKind::RParen)?;
1640                        VariantPatternFields::Tuple(patterns)
1641                    } else if self.check(TokenKind::LBrace) {
1642                        self.advance();
1643                        let mut fields = Vec::new();
1644                        while !self.check(TokenKind::RBrace) {
1645                            let fname = self.parse_ident()?;
1646                            self.expect(TokenKind::Colon)?;
1647                            let pat = self.parse_pattern()?;
1648                            fields.push((fname, pat));
1649                            if !self.check(TokenKind::RBrace) {
1650                                self.expect(TokenKind::Comma)?;
1651                            }
1652                        }
1653                        self.expect(TokenKind::RBrace)?;
1654                        VariantPatternFields::Struct(fields)
1655                    } else {
1656                        VariantPatternFields::Unit
1657                    };
1658                    
1659                    Ok(Pattern::Variant {
1660                        enum_name: Some(name),
1661                        variant,
1662                        fields,
1663                        span: span.merge(self.current_span()),
1664                    })
1665                } else if self.check(TokenKind::LParen) {
1666                    // Unqualified variant pattern: Variant(args) without EnumName::
1667                    // Common in Python-style pattern matching
1668                    self.advance(); // consume (
1669                    let mut patterns = Vec::new();
1670                    while !self.check(TokenKind::RParen) {
1671                        patterns.push(self.parse_pattern()?);
1672                        if !self.check(TokenKind::RParen) {
1673                            self.expect(TokenKind::Comma)?;
1674                        }
1675                    }
1676                    self.expect(TokenKind::RParen)?;
1677                    
1678                    Ok(Pattern::Variant {
1679                        enum_name: None, // Unqualified - will be resolved at type-check time
1680                        variant: name,
1681                        fields: VariantPatternFields::Tuple(patterns),
1682                        span: span.merge(self.current_span()),
1683                    })
1684                } else {
1685                    Ok(Pattern::Binding { name, mutable: false, span }) 
1686                }
1687            }
1688            TokenKind::Mut => {
1689                self.advance();
1690                let name = self.parse_ident()?;
1691                Ok(Pattern::Binding { name, mutable: true, span: span.merge(self.current_span()) })
1692            }
1693            TokenKind::Int(n) => { self.advance(); Ok(Pattern::Literal(Expr::Int(n, span))) }
1694            TokenKind::String(ref s) => { 
1695                let string_val = s.clone();
1696                self.advance(); 
1697                Ok(Pattern::Literal(Expr::String(string_val, span))) 
1698            }
1699            TokenKind::True => { self.advance(); Ok(Pattern::Literal(Expr::Bool(true, span))) }
1700            TokenKind::False => { self.advance(); Ok(Pattern::Literal(Expr::Bool(false, span))) }
1701            TokenKind::LParen => {
1702                self.advance();
1703                let mut patterns = Vec::new();
1704                while !self.check(TokenKind::RParen) {
1705                    patterns.push(self.parse_pattern()?);
1706                    if !self.check(TokenKind::RParen) { self.expect(TokenKind::Comma)?; }
1707                }
1708                self.expect(TokenKind::RParen)?;
1709                Ok(Pattern::Tuple(patterns, span.merge(self.current_span())))
1710            }
1711            TokenKind::LBracket => {
1712                self.advance();
1713                let mut patterns = Vec::new();
1714                while !self.check(TokenKind::RBracket) {
1715                    patterns.push(self.parse_pattern()?);
1716                    if !self.check(TokenKind::RBracket) { self.expect(TokenKind::Comma)?; }
1717                }
1718                self.expect(TokenKind::RBracket)?;
1719                Ok(Pattern::Slice { patterns, rest: None, span: span.merge(self.current_span()) })
1720            }
1721            _ => Err(KoreError::parser("Expected pattern", span)),
1722        }
1723    }
1724
1725    #[allow(dead_code)]
1726    fn parse_jsx(&mut self) -> KoreResult<JSXNode> {
1727        self.skip_newlines();
1728        self.expect(TokenKind::Indent)?;
1729        self.skip_newlines();
1730        let result = self.parse_jsx_element()?;
1731        self.skip_newlines();
1732        if self.check(TokenKind::Dedent) { self.advance(); }
1733        Ok(result)
1734    }
1735
1736    fn parse_jsx_element(&mut self) -> KoreResult<JSXNode> {
1737        let start = self.current_span();
1738        self.expect(TokenKind::Lt)?;
1739        let tag = self.parse_ident()?;
1740        let mut attrs = Vec::new();
1741        while !self.check(TokenKind::Gt) && !self.check(TokenKind::Slash) {
1742            let name = self.parse_ident()?;
1743            self.expect(TokenKind::Eq)?;
1744            let value = if self.check(TokenKind::LBrace) {
1745                self.advance();
1746                let e = self.parse_expr()?;
1747                self.expect(TokenKind::RBrace)?;
1748                JSXAttrValue::Expr(e)
1749            } else if let TokenKind::String(s) = self.peek_kind() {
1750                self.advance();
1751                JSXAttrValue::String(s)
1752            } else {
1753                return Err(KoreError::parser("Expected attribute value", self.current_span()));
1754            };
1755            attrs.push(JSXAttribute { name, value, span: self.current_span() });
1756        }
1757        
1758        if self.check(TokenKind::Slash) {
1759            self.advance();
1760            self.expect(TokenKind::Gt)?;
1761            return Ok(JSXNode::Element { tag, attributes: attrs, children: vec![], span: start.merge(self.current_span()) });
1762        }
1763        
1764        self.expect(TokenKind::Gt)?;
1765        
1766        let mut children = Vec::new();
1767        // Track the end of the previous token to detect gaps (whitespace)
1768        let mut last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1769        let mut text_buffer = String::new();
1770        let mut text_start = self.current_span();
1771
1772        while !self.check(TokenKind::LtSlash) && !self.at_end() {
1773            let current_span = self.current_span();
1774            
1775            // Check for gap (whitespace)
1776            if current_span.start > last_end {
1777                // If we have text in buffer, append space. If buffer empty, maybe leading space?
1778                // For simplicity, just append space if buffer not empty, or if we want to preserve spacing.
1779                // But JSX usually collapses whitespace.
1780                // However, "Count is: {count}" needs space.
1781                // Let's unconditionally add space if gap detected, but handle collapse later?
1782                // No, let's just add space.
1783                if !text_buffer.is_empty() {
1784                    text_buffer.push(' ');
1785                }
1786            }
1787
1788            if self.check(TokenKind::LBrace) {
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                self.advance();
1795                let expr = self.parse_expr()?;
1796                self.expect(TokenKind::RBrace)?;
1797                children.push(JSXNode::Expression(Box::new(expr)));
1798                
1799                last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1800                text_start = self.current_span(); // Reset text start for next text run
1801            } else if self.check(TokenKind::Lt) {
1802                 if !text_buffer.is_empty() {
1803                    children.push(JSXNode::Text(text_buffer.clone(), text_start.merge(Span::new(last_end, last_end))));
1804                    text_buffer.clear();
1805                }
1806
1807                 children.push(self.parse_jsx_element()?);
1808                 
1809                 last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1810                 text_start = self.current_span();
1811            } else {
1812                 let mut consumed_text = None;
1813                 match self.peek_kind() {
1814                     TokenKind::String(s) => consumed_text = Some(s),
1815                     TokenKind::Ident(s) => consumed_text = Some(s),
1816                     TokenKind::Int(n) => consumed_text = Some(n.to_string()),
1817                     TokenKind::Newline(_) | TokenKind::Indent | TokenKind::Dedent => {
1818                         // Treat newline/indent as whitespace
1819                         if !text_buffer.is_empty() && !text_buffer.ends_with(' ') {
1820                             text_buffer.push(' ');
1821                         }
1822                         self.advance();
1823                     }
1824                     TokenKind::Colon => consumed_text = Some(":".to_string()),
1825                     TokenKind::Comma => consumed_text = Some(",".to_string()),
1826                     TokenKind::Dot => consumed_text = Some(".".to_string()),
1827                     TokenKind::Question => consumed_text = Some("?".to_string()),
1828                     TokenKind::Not => consumed_text = Some("!".to_string()),
1829                     TokenKind::Minus => consumed_text = Some("-".to_string()),
1830                     TokenKind::Eq => consumed_text = Some("=".to_string()),
1831                     _ => {
1832                         return Err(KoreError::parser(format!("Unexpected token in JSX child: {:?}. Use strings or {{}} for text.", self.peek_kind()), self.current_span()));
1833                     }
1834                 }
1835                 
1836                 if let Some(t) = consumed_text {
1837                     if text_buffer.is_empty() {
1838                         text_start = self.current_span();
1839                     }
1840                     text_buffer.push_str(&t);
1841                     self.advance();
1842                 }
1843                 
1844                 last_end = self.tokens.get(self.pos - 1).map(|t| t.span.end).unwrap_or(0);
1845            }
1846        }
1847        
1848        if !text_buffer.is_empty() {
1849            children.push(JSXNode::Text(text_buffer, text_start.merge(Span::new(last_end, last_end))));
1850        }
1851        
1852        self.expect(TokenKind::LtSlash)?;
1853        let closing_tag = self.parse_ident()?;
1854        if closing_tag != tag {
1855            return Err(KoreError::parser(format!("Expected closing tag </{}>, found </{}>", tag, closing_tag), self.current_span()));
1856        }
1857        self.expect(TokenKind::Gt)?;
1858        
1859        Ok(JSXNode::Element { tag, attributes: attrs, children, span: start.merge(self.current_span()) })
1860    }
1861
1862    fn parse_call_args(&mut self) -> KoreResult<Vec<CallArg>> {
1863        let mut args = Vec::new();
1864        self.skip_formatting();
1865        while !self.check(TokenKind::RParen) && !self.at_end() {
1866            let mut name = None;
1867            // Check for named argument: ident = expr
1868            if let TokenKind::Ident(s) = self.peek_kind() {
1869                // Look ahead for '='
1870                if self.tokens.get(self.pos + 1).map(|t| t.kind == TokenKind::Eq).unwrap_or(false) {
1871                    name = Some(s);
1872                    self.advance(); // eat ident
1873                    self.advance(); // eat =
1874                }
1875            }
1876            
1877            let value = self.parse_expr()?;
1878            args.push(CallArg { name, value, span: self.current_span() });
1879            
1880            self.skip_formatting();
1881            if !self.check(TokenKind::RParen) { 
1882                self.expect(TokenKind::Comma)?; 
1883                self.skip_formatting();
1884            }
1885        }
1886        Ok(args)
1887    }
1888
1889    fn parse_visibility(&mut self) -> Visibility {
1890        if self.check(TokenKind::Pub) { self.advance(); Visibility::Public } else { Visibility::Private }
1891    }
1892
1893    fn parse_ident(&mut self) -> KoreResult<String> {
1894        match self.peek_kind() {
1895            TokenKind::Ident(s) => { self.advance(); Ok(s) }
1896            TokenKind::SelfLower => { self.advance(); Ok("self".to_string()) }
1897            TokenKind::SelfUpper => { self.advance(); Ok("Self".to_string()) }
1898            k => Err(KoreError::parser(format!("Expected identifier, got {:?}", k), self.current_span())),
1899        }
1900    }
1901
1902    fn get_binary_op(&self) -> Option<(BinaryOp, u8)> {
1903        match self.peek_kind() {
1904            TokenKind::Or => Some((BinaryOp::Or, 1)),
1905            TokenKind::And => Some((BinaryOp::And, 2)),
1906            TokenKind::EqEq => Some((BinaryOp::Eq, 3)),
1907            TokenKind::NotEq => Some((BinaryOp::Ne, 3)),
1908            TokenKind::Lt => Some((BinaryOp::Lt, 4)),
1909            TokenKind::Gt => Some((BinaryOp::Gt, 4)),
1910            TokenKind::LtEq => Some((BinaryOp::Le, 4)),
1911            TokenKind::GtEq => Some((BinaryOp::Ge, 4)),
1912            TokenKind::Plus => Some((BinaryOp::Add, 5)),
1913            TokenKind::Minus => Some((BinaryOp::Sub, 5)),
1914            TokenKind::Star => Some((BinaryOp::Mul, 6)),
1915            TokenKind::Slash => Some((BinaryOp::Div, 6)),
1916            TokenKind::Percent => Some((BinaryOp::Mod, 6)),
1917            TokenKind::Power => Some((BinaryOp::Pow, 7)),
1918            _ => None,
1919        }
1920    }
1921
1922    // Helper methods
1923    fn peek_kind(&self) -> TokenKind { self.tokens.get(self.pos).map(|t| t.kind.clone()).unwrap_or(TokenKind::Eof) }
1924    fn current_span(&self) -> Span { self.tokens.get(self.pos).map(|t| t.span).unwrap_or(Span::new(0, 0)) }
1925    fn at_end(&self) -> bool { matches!(self.peek_kind(), TokenKind::Eof) }
1926    fn check(&self, k: TokenKind) -> bool { std::mem::discriminant(&self.peek_kind()) == std::mem::discriminant(&k) }
1927    fn check_line_end(&self) -> bool { matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Dedent | TokenKind::Eof) }
1928    fn advance(&mut self) { if !self.at_end() { self.pos += 1; } }
1929    fn skip_newlines(&mut self) { while let TokenKind::Newline(_) = self.peek_kind() { self.advance(); } }
1930    fn check_newline(&self) -> bool { matches!(self.peek_kind(), TokenKind::Newline(_)) }
1931    fn skip_formatting(&mut self) {
1932        while matches!(self.peek_kind(), TokenKind::Newline(_) | TokenKind::Indent | TokenKind::Dedent) {
1933            self.advance();
1934        }
1935    }
1936
1937    fn expect(&mut self, k: TokenKind) -> KoreResult<()> {
1938        if self.check(k.clone()) { self.advance(); Ok(()) }
1939        else { Err(KoreError::parser(format!("Expected {:?}, got {:?}", k, self.peek_kind()), self.current_span())) }
1940    }
1941}
1942