TypeScript_Rust_Compiler/
parser.rs

1//! Parser for TypeScript code using nom parser combinators
2
3use crate::ast::*;
4use crate::error::{CompilerError, Result};
5use crate::lexer::{Token, Keyword};
6
7/// Parser for TypeScript code
8pub struct Parser {
9    tokens: Vec<Token>,
10    position: usize,
11}
12
13impl Parser {
14    /// Create a new parser
15    pub fn new(tokens: Vec<Token>) -> Self {
16        Self {
17            tokens,
18            position: 0,
19        }
20    }
21
22    /// Parse the tokens into an AST
23    pub fn parse(&mut self) -> Result<Program> {
24        let mut statements = Vec::new();
25
26        while self.position < self.tokens.len() {
27            if let Some(statement) = self.parse_statement()? {
28                statements.push(statement);
29            } else {
30                break;
31            }
32        }
33
34        Ok(Program { statements })
35    }
36
37    /// Parse a statement
38    fn parse_statement(&mut self) -> Result<Option<Statement>> {
39        if self.position >= self.tokens.len() {
40            return Ok(None);
41        }
42
43        let token = &self.tokens[self.position];
44        let statement = match token {
45            Token::EOF => return Ok(None),
46            Token::Keyword(keyword) => match keyword {
47                crate::lexer::Keyword::Let
48                | crate::lexer::Keyword::Var => self.parse_variable_declaration()?,
49                crate::lexer::Keyword::Const => {
50                    // Check if this is "const enum"
51                    if self.position + 1 < self.tokens.len() {
52                        if let Token::Keyword(crate::lexer::Keyword::Enum) = &self.tokens[self.position + 1] {
53                            // This is "const enum", parse as enum declaration
54                            self.parse_const_enum_declaration()?
55                        } else {
56                            // This is regular "const", parse as variable declaration
57                            self.parse_variable_declaration()?
58                        }
59                    } else {
60                        self.parse_variable_declaration()?
61                    }
62                },
63                crate::lexer::Keyword::Function => self.parse_function_declaration()?,
64                crate::lexer::Keyword::Class => self.parse_class_declaration()?,
65                crate::lexer::Keyword::Interface => self.parse_interface_declaration()?,
66                crate::lexer::Keyword::Type => self.parse_type_alias()?,
67                crate::lexer::Keyword::Enum => self.parse_enum_declaration()?,
68                crate::lexer::Keyword::Import => self.parse_import_declaration()?,
69                crate::lexer::Keyword::Export => self.parse_export_declaration()?,
70                crate::lexer::Keyword::Namespace => self.parse_namespace_declaration()?,
71                crate::lexer::Keyword::Module => self.parse_module_declaration()?,
72                crate::lexer::Keyword::Declare => self.parse_declare_statement()?,
73                crate::lexer::Keyword::Return => self.parse_return_statement()?,
74                crate::lexer::Keyword::Throw => self.parse_throw_statement()?,
75                crate::lexer::Keyword::If => self.parse_if_statement()?,
76                crate::lexer::Keyword::Else => self.parse_expression_statement()?,
77                _ => self.parse_expression_statement()?,
78            },
79            Token::LeftBrace => self.parse_block_statement()?,
80            Token::Semicolon => {
81                self.advance();
82                return self.parse_statement();
83            }
84            _ => self.parse_expression_statement()?,
85        };
86
87        Ok(Some(statement))
88    }
89
90    /// Parse variable declaration
91    fn parse_variable_declaration(&mut self) -> Result<Statement> {
92        let keyword = self.expect_keyword()?;
93        let name = self.expect_identifier()?;
94        let type_annotation = if self.current_token() == &Token::Colon {
95            self.advance();
96            Some(self.parse_type()?)
97        } else {
98            None
99        };
100
101        let initializer = if self.current_token() == &Token::Assign {
102            self.advance();
103            Some(self.parse_expression()?)
104        } else {
105            None
106        };
107
108        self.expect_semicolon()?;
109
110        Ok(Statement::VariableDeclaration(VariableDeclaration {
111            keyword,
112            name,
113            type_annotation,
114            initializer,
115        }))
116    }
117
118    /// Parse function declaration
119    fn parse_function_declaration(&mut self) -> Result<Statement> {
120        self.expect_keyword()?; // consume 'function' keyword
121        let name = self.expect_identifier()?;
122        let type_parameters = self.parse_type_parameters()?;
123        let parameters = self.parse_parameters()?;
124        let return_type = if self.current_token() == &Token::Colon {
125            self.advance();
126            Some(self.parse_type()?)
127        } else {
128            None
129        };
130        let body = self.parse_block_statement()?;
131
132        Ok(Statement::FunctionDeclaration(FunctionDeclaration {
133            name,
134            type_parameters,
135            parameters,
136            return_type,
137            body: Box::new(body),
138        }))
139    }
140
141    /// Parse class declaration
142    fn parse_class_declaration(&mut self) -> Result<Statement> {
143        self.expect_keyword()?; // consume 'class' keyword
144        let name = self.expect_identifier()?;
145        let type_parameters = self.parse_type_parameters()?;
146        let extends = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
147            self.advance();
148            Some(self.parse_type()?)
149        } else {
150            None
151        };
152        let implements = self.parse_implements()?;
153        let body = self.parse_class_body()?;
154
155        Ok(Statement::ClassDeclaration(ClassDeclaration {
156            name,
157            type_parameters,
158            extends,
159            implements,
160            body,
161        }))
162    }
163
164    /// Parse interface declaration
165    fn parse_interface_declaration(&mut self) -> Result<Statement> {
166        self.expect_keyword()?; // consume 'interface' keyword
167        let name = self.expect_identifier()?;
168        let type_parameters = self.parse_type_parameters()?;
169        let extends = self.parse_extends()?;
170        let body = self.parse_interface_body()?;
171
172        Ok(Statement::InterfaceDeclaration(InterfaceDeclaration {
173            name,
174            type_parameters,
175            extends,
176            body,
177        }))
178    }
179
180    /// Parse type alias
181    fn parse_type_alias(&mut self) -> Result<Statement> {
182        self.expect_keyword()?; // consume 'type' keyword
183        let name = self.expect_identifier()?;
184        let type_parameters = self.parse_type_parameters()?;
185        self.expect_token(&Token::Assign)?;
186        let type_definition = self.parse_type()?;
187        self.expect_semicolon()?;
188
189        Ok(Statement::TypeAlias(TypeAlias {
190            name,
191            type_parameters,
192            type_definition,
193        }))
194    }
195
196    /// Parse enum declaration
197    fn parse_enum_declaration(&mut self) -> Result<Statement> {
198        self.expect_keyword()?; // consume 'enum' keyword
199        let name = self.expect_identifier()?;
200        let members = self.parse_enum_members()?;
201
202        Ok(Statement::EnumDeclaration(EnumDeclaration {
203            name,
204            members,
205        }))
206    }
207
208    fn parse_const_enum_declaration(&mut self) -> Result<Statement> {
209        self.expect_keyword()?; // consume 'const' keyword
210        self.expect_keyword()?; // consume 'enum' keyword
211        let name = self.expect_identifier()?;
212        let members = self.parse_enum_members()?;
213
214        // For now, treat const enum the same as regular enum
215        // In a full implementation, we'd have a ConstEnumDeclaration type
216        Ok(Statement::EnumDeclaration(EnumDeclaration {
217            name,
218            members,
219        }))
220    }
221
222    /// Parse import declaration
223    fn parse_import_declaration(&mut self) -> Result<Statement> {
224        self.expect_keyword()?; // import
225        let specifiers = self.parse_import_specifiers()?;
226        self.expect_keyword()?; // from
227        let source = self.parse_string_literal()?;
228        self.expect_semicolon()?;
229
230        Ok(Statement::ImportDeclaration(ImportDeclaration {
231            specifiers,
232            source,
233        }))
234    }
235
236    /// Parse export declaration
237    fn parse_export_declaration(&mut self) -> Result<Statement> {
238        // Consume 'export' keyword
239        self.advance();
240        // Parse the specific declaration type directly
241        let token = self.current_token().clone();
242        let declaration = match token {
243            Token::Keyword(crate::lexer::Keyword::Class) => self.parse_class_declaration()?,
244            Token::Keyword(crate::lexer::Keyword::Interface) => {
245                self.parse_interface_declaration()?
246            }
247            Token::Keyword(crate::lexer::Keyword::Function) => self.parse_function_declaration()?,
248            Token::Keyword(crate::lexer::Keyword::Const) => self.parse_variable_declaration()?,
249            Token::Keyword(crate::lexer::Keyword::Let) => self.parse_variable_declaration()?,
250            Token::Keyword(crate::lexer::Keyword::Var) => self.parse_variable_declaration()?,
251            Token::Keyword(crate::lexer::Keyword::Enum) => self.parse_enum_declaration()?,
252            Token::Keyword(crate::lexer::Keyword::Type) => {
253                // Check if this is "export type { ... }" or "export type Name = ..."
254                if self.position + 1 < self.tokens.len() {
255                    if let Token::LeftBrace = &self.tokens[self.position + 1] {
256                        // This is "export type { ... }", parse as export type statement
257                        self.parse_export_type_statement()?
258                    } else {
259                        // This is "export type Name = ...", parse as type alias
260                        self.parse_type_alias()?
261                    }
262                } else {
263                    self.parse_type_alias()?
264                }
265            },
266            _ => {
267                return Err(CompilerError::parse_error(
268                    1,
269                    1,
270                    format!("Unexpected token in export declaration: {:?}", token),
271                ))
272            }
273        };
274        Ok(Statement::ExportDeclaration(Box::new(ExportDeclaration {
275            declaration: Box::new(declaration),
276        })))
277    }
278
279    fn parse_export_type_statement(&mut self) -> Result<Statement> {
280        self.expect_keyword()?; // consume 'type' keyword
281        self.expect_token(&Token::LeftBrace)?; // consume '{'
282        
283        let mut type_names = Vec::new();
284        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
285            let name = self.expect_identifier()?;
286            type_names.push(name);
287            
288            if self.current_token() == &Token::Comma {
289                self.advance();
290            }
291        }
292        
293        self.expect_token(&Token::RightBrace)?; // consume '}'
294        self.expect_semicolon()?;
295        
296        // For now, create a simple export statement
297        // In a full implementation, we'd have a proper ExportTypeStatement type
298        Ok(Statement::ExportDeclaration(Box::new(ExportDeclaration {
299            declaration: Box::new(Statement::TypeAlias(TypeAlias {
300                name: "exported_types".to_string(),
301                type_parameters: Vec::new(),
302                type_definition: Type::Any,
303            })),
304        })))
305    }
306
307    /// Parse namespace declaration
308    fn parse_namespace_declaration(&mut self) -> Result<Statement> {
309        self.expect_keyword()?; // namespace
310        let name = self.expect_identifier()?;
311        let body = self.parse_block_statement()?;
312
313        Ok(Statement::NamespaceDeclaration(NamespaceDeclaration {
314            name,
315            body: Box::new(body),
316        }))
317    }
318
319    /// Parse module declaration
320    fn parse_module_declaration(&mut self) -> Result<Statement> {
321        self.expect_keyword()?; // module
322        let name = self.parse_string_literal()?;
323        let body = self.parse_block_statement()?;
324
325        Ok(Statement::ModuleDeclaration(ModuleDeclaration {
326            name,
327            body: Box::new(body),
328        }))
329    }
330
331    /// Parse declare statement
332    fn parse_declare_statement(&mut self) -> Result<Statement> {
333        self.expect_keyword()?; // declare
334        let declaration = self.parse_statement()?;
335        Ok(Statement::DeclareStatement(Box::new(DeclareStatement {
336            declaration: Box::new(declaration.unwrap()),
337        })))
338    }
339
340    /// Parse return statement
341    fn parse_return_statement(&mut self) -> Result<Statement> {
342        self.expect_keyword()?; // return
343
344        let argument = if self.current_token() == &Token::Semicolon {
345            None
346        } else {
347            Some(self.parse_expression()?)
348        };
349
350        // Optional semicolon
351        if self.current_token() == &Token::Semicolon {
352            self.advance();
353        }
354
355        Ok(Statement::ReturnStatement(ReturnStatement { argument }))
356    }
357
358    /// Parse throw statement
359    fn parse_throw_statement(&mut self) -> Result<Statement> {
360        self.expect_keyword()?; // throw
361
362        let argument = self.parse_expression()?;
363
364        // Optional semicolon
365        if self.current_token() == &Token::Semicolon {
366            self.advance();
367        }
368
369        Ok(Statement::ThrowStatement(ThrowStatement { argument }))
370    }
371
372    /// Parse expression statement
373    fn parse_expression_statement(&mut self) -> Result<Statement> {
374        let expression = self.parse_expression()?;
375        self.expect_semicolon()?;
376        Ok(Statement::ExpressionStatement(ExpressionStatement {
377            expression,
378        }))
379    }
380
381    /// Parse block statement
382    fn parse_block_statement(&mut self) -> Result<Statement> {
383        self.expect_token(&Token::LeftBrace)?;
384        let mut statements = Vec::new();
385
386        while self.current_token() != &Token::RightBrace {
387            if let Some(statement) = self.parse_statement()? {
388                statements.push(statement);
389            } else {
390                break;
391            }
392        }
393
394        self.expect_token(&Token::RightBrace)?;
395        Ok(Statement::BlockStatement(BlockStatement { statements }))
396    }
397
398    /// Parse expression
399    fn parse_expression(&mut self) -> Result<Expression> {
400        self.parse_assignment_expression()
401    }
402
403    /// Parse assignment expression
404    fn parse_assignment_expression(&mut self) -> Result<Expression> {
405        let left = self.parse_conditional_expression()?;
406
407        if self.is_assignment_operator() {
408            let operator = self.current_token().clone();
409            self.advance();
410            let right = self.parse_assignment_expression()?;
411            Ok(Expression::Assignment(AssignmentExpression {
412                left: Box::new(left),
413                operator,
414                right: Box::new(right),
415            }))
416        } else {
417            Ok(left)
418        }
419    }
420
421    /// Parse conditional expression
422    fn parse_conditional_expression(&mut self) -> Result<Expression> {
423        let test = self.parse_logical_or_expression()?;
424
425        if self.current_token() == &Token::QuestionMark {
426            self.advance();
427            let consequent = self.parse_expression()?;
428            self.expect_token(&Token::Colon)?;
429            let alternate = self.parse_expression()?;
430            Ok(Expression::Conditional(ConditionalExpression {
431                test: Box::new(test),
432                consequent: Box::new(consequent),
433                alternate: Box::new(alternate),
434            }))
435        } else {
436            Ok(test)
437        }
438    }
439
440    /// Parse logical OR expression
441    fn parse_logical_or_expression(&mut self) -> Result<Expression> {
442        let mut left = self.parse_logical_and_expression()?;
443
444        while self.current_token() == &Token::Or {
445            self.advance();
446            let right = self.parse_logical_and_expression()?;
447            left = Expression::Logical(LogicalExpression {
448                left: Box::new(left),
449                operator: Token::Or,
450                right: Box::new(right),
451            });
452        }
453
454        Ok(left)
455    }
456
457    /// Parse logical AND expression
458    fn parse_logical_and_expression(&mut self) -> Result<Expression> {
459        let mut left = self.parse_equality_expression()?;
460
461        while self.current_token() == &Token::And {
462            self.advance();
463            let right = self.parse_equality_expression()?;
464            left = Expression::Logical(LogicalExpression {
465                left: Box::new(left),
466                operator: Token::And,
467                right: Box::new(right),
468            });
469        }
470
471        Ok(left)
472    }
473
474    /// Parse equality expression
475    fn parse_equality_expression(&mut self) -> Result<Expression> {
476        let mut left = self.parse_relational_expression()?;
477
478        while self.is_equality_operator() {
479            let operator = self.current_token().clone();
480            self.advance();
481            let right = self.parse_relational_expression()?;
482            left = Expression::Binary(BinaryExpression {
483                left: Box::new(left),
484                operator,
485                right: Box::new(right),
486            });
487        }
488
489        Ok(left)
490    }
491
492    /// Parse relational expression
493    fn parse_relational_expression(&mut self) -> Result<Expression> {
494        let mut left = self.parse_additive_expression()?;
495
496        while self.is_relational_operator() {
497            let operator = self.current_token().clone();
498            self.advance();
499            let right = self.parse_additive_expression()?;
500            left = Expression::Binary(BinaryExpression {
501                left: Box::new(left),
502                operator,
503                right: Box::new(right),
504            });
505        }
506
507        Ok(left)
508    }
509
510    /// Parse additive expression
511    fn parse_additive_expression(&mut self) -> Result<Expression> {
512        let mut left = self.parse_multiplicative_expression()?;
513
514        while self.is_additive_operator() {
515            let operator = self.current_token().clone();
516            self.advance();
517            let right = self.parse_multiplicative_expression()?;
518            left = Expression::Binary(BinaryExpression {
519                left: Box::new(left),
520                operator,
521                right: Box::new(right),
522            });
523        }
524
525        Ok(left)
526    }
527
528    /// Parse multiplicative expression
529    fn parse_multiplicative_expression(&mut self) -> Result<Expression> {
530        let mut left = self.parse_unary_expression()?;
531
532        while self.is_multiplicative_operator() {
533            let operator = self.current_token().clone();
534            self.advance();
535            let right = self.parse_unary_expression()?;
536            left = Expression::Binary(BinaryExpression {
537                left: Box::new(left),
538                operator,
539                right: Box::new(right),
540            });
541        }
542
543        Ok(left)
544    }
545
546    /// Parse unary expression
547    fn parse_unary_expression(&mut self) -> Result<Expression> {
548        if self.is_unary_operator() {
549            let operator = self.current_token().clone();
550            self.advance();
551            let argument = self.parse_unary_expression()?;
552            Ok(Expression::Unary(UnaryExpression {
553                operator,
554                argument: Box::new(argument),
555            }))
556        } else {
557            self.parse_postfix_expression()
558        }
559    }
560
561    /// Parse postfix expression
562    fn parse_postfix_expression(&mut self) -> Result<Expression> {
563        let mut left = self.parse_primary_expression()?;
564
565        while self.is_postfix_operator() {
566            match self.current_token() {
567                Token::LeftParen => {
568                    self.advance();
569                    let arguments = self.parse_arguments()?;
570                    self.expect_token(&Token::RightParen)?;
571                    left = Expression::Call(CallExpression {
572                        callee: Box::new(left),
573                        arguments,
574                    });
575                }
576                Token::LeftBracket => {
577                    self.advance();
578                    let index = self.parse_expression()?;
579                    self.expect_token(&Token::RightBracket)?;
580                    left = Expression::Member(MemberExpression {
581                        object: Box::new(left),
582                        property: Box::new(index),
583                        computed: true,
584                    });
585                }
586                Token::Dot => {
587                    self.advance();
588                    let property = self.expect_identifier()?;
589                    left = Expression::Member(MemberExpression {
590                        object: Box::new(left),
591                        property: Box::new(Expression::Identifier(property)),
592                        computed: false,
593                    });
594                }
595                _ => break,
596            }
597        }
598
599        Ok(left)
600    }
601
602    /// Parse primary expression
603    fn parse_primary_expression(&mut self) -> Result<Expression> {
604        let token = self.current_token().clone();
605        match token {
606            Token::Number(n) => {
607                self.advance();
608                Ok(Expression::Literal(Literal::Number(n)))
609            }
610            Token::String(s) => {
611                self.advance();
612                Ok(Expression::Literal(Literal::String(s)))
613            }
614            Token::TemplateLiteral(s) => {
615                self.advance();
616                // Create a simple template literal with one quasi
617                let template = TemplateLiteral {
618                    quasis: vec![TemplateElement {
619                        value: s,
620                        tail: true,
621                    }],
622                    expressions: vec![],
623                };
624                Ok(Expression::Template(template))
625            }
626            Token::Boolean(b) => {
627                self.advance();
628                Ok(Expression::Literal(Literal::Boolean(b)))
629            }
630            Token::Null => {
631                self.advance();
632                Ok(Expression::Literal(Literal::Null))
633            }
634            Token::Undefined => {
635                self.advance();
636                Ok(Expression::Literal(Literal::Undefined))
637            }
638            Token::Keyword(crate::lexer::Keyword::Null) => {
639                self.advance();
640                Ok(Expression::Literal(Literal::Null))
641            }
642            Token::Keyword(crate::lexer::Keyword::Undefined) => {
643                self.advance();
644                Ok(Expression::Literal(Literal::Undefined))
645            }
646            Token::Identifier(name) => {
647                self.advance();
648                Ok(Expression::Identifier(name))
649            }
650            Token::Keyword(crate::lexer::Keyword::This) => {
651                self.advance();
652                Ok(Expression::This(ThisExpression))
653            }
654            Token::Keyword(crate::lexer::Keyword::Super) => {
655                self.advance();
656                Ok(Expression::Super(SuperExpression))
657            }
658            Token::Keyword(crate::lexer::Keyword::New) => {
659                self.advance();
660                let callee = self.parse_primary_expression()?;
661                let arguments = if self.current_token() == &Token::LeftParen {
662                    self.advance(); // consume '('
663                    let args = self.parse_arguments()?;
664                    self.expect_token(&Token::RightParen)?;
665                    args
666                } else {
667                    Vec::new()
668                };
669                Ok(Expression::New(NewExpression {
670                    callee: Box::new(callee),
671                    arguments,
672                }))
673            }
674            Token::LeftParen => {
675                // Look ahead to see if this is an arrow function
676                let mut pos = self.position + 1;
677                let mut paren_count = 1;
678                
679                // Skip to matching closing paren
680                while pos < self.tokens.len() && paren_count > 0 {
681                    match &self.tokens[pos] {
682                        Token::LeftParen => paren_count += 1,
683                        Token::RightParen => paren_count -= 1,
684                        _ => {}
685                    }
686                    pos += 1;
687                }
688                
689                // Check if next token is arrow
690                if pos < self.tokens.len() && self.tokens[pos] == Token::Arrow {
691                    // This is an arrow function
692                    self.advance(); // consume (
693                    let parameters = self.parse_parameter_list()?;
694                    self.expect_token(&Token::RightParen)?;
695                    self.expect_token(&Token::Arrow)?;
696                    let body = if self.current_token() == &Token::LeftBrace {
697                        self.parse_block_statement()?
698                    } else {
699                        let expr = self.parse_expression()?;
700                        Statement::ExpressionStatement(ExpressionStatement {
701                            expression: expr,
702                        })
703                    };
704                    
705                    Ok(Expression::Arrow(Box::new(ArrowFunctionExpression {
706                        type_parameters: Vec::new(),
707                        parameters,
708                        return_type: None,
709                        body: Box::new(body),
710                    })))
711                } else {
712                    // Regular parenthesized expression
713                    self.advance();
714                    let expression = self.parse_expression()?;
715                    self.expect_token(&Token::RightParen)?;
716                    Ok(Expression::Parenthesized(ParenthesizedExpression {
717                        expression: Box::new(expression),
718                    }))
719                }
720            }
721            Token::LeftBrace => self.parse_object_expression(),
722            Token::LeftBracket => self.parse_array_expression(),
723            _ => Err(CompilerError::parse_error(
724                self.position,
725                0,
726                format!("Unexpected token: {:?}", self.current_token()),
727            )),
728        }
729    }
730
731    /// Parse object expression
732    fn parse_object_expression(&mut self) -> Result<Expression> {
733        self.expect_token(&Token::LeftBrace)?;
734        let mut properties = Vec::new();
735
736        while self.current_token() != &Token::RightBrace {
737            let key = self.parse_property_key()?;
738            let value = if self.current_token() == &Token::Colon {
739                self.advance();
740                self.parse_expression()?
741            } else {
742                key.clone()
743            };
744
745            properties.push(ObjectProperty {
746                key,
747                value,
748                shorthand: false,
749                computed: false,
750                method: false,
751            });
752
753            if self.current_token() == &Token::Comma {
754                self.advance();
755            }
756        }
757
758        self.expect_token(&Token::RightBrace)?;
759        Ok(Expression::Object(ObjectExpression { properties }))
760    }
761
762    /// Parse array expression
763    fn parse_array_expression(&mut self) -> Result<Expression> {
764        self.expect_token(&Token::LeftBracket)?;
765        let mut elements = Vec::new();
766
767        while self.current_token() != &Token::RightBracket {
768            if self.current_token() == &Token::Comma {
769                self.advance();
770                elements.push(None);
771            } else {
772                elements.push(Some(self.parse_expression()?));
773                if self.current_token() == &Token::Comma {
774                    self.advance();
775                }
776            }
777        }
778
779        self.expect_token(&Token::RightBracket)?;
780        Ok(Expression::Array(ArrayExpression { elements }))
781    }
782
783    /// Parse type
784    fn parse_type(&mut self) -> Result<Type> {
785        let mut left_type = self.parse_primary_type()?;
786        
787        // Handle union and intersection types
788        while matches!(self.current_token(), Token::Union | Token::Intersection) {
789            let operator = self.current_token().clone();
790            self.advance();
791            let right_type = self.parse_primary_type()?;
792            
793            left_type = match operator {
794                Token::Union => Type::Union {
795                    left: Box::new(left_type),
796                    right: Box::new(right_type),
797                },
798                Token::Intersection => Type::Intersection {
799                    left: Box::new(left_type),
800                    right: Box::new(right_type),
801                },
802                _ => return Err(CompilerError::parse_error(
803                    1,
804                    1,
805                    "Expected union or intersection operator",
806                )),
807            };
808        }
809        
810        // Handle array types: T[]
811        while self.current_token() == &Token::LeftBracket {
812            self.advance(); // consume [
813            self.expect_token(&Token::RightBracket)?; // consume ]
814            left_type = Type::Array(Box::new(left_type));
815        }
816        
817        Ok(left_type)
818    }
819    
820    fn parse_primary_type(&mut self) -> Result<Type> {
821        let token = self.current_token().clone();
822        match token {
823            Token::Keyword(crate::lexer::Keyword::String) => {
824                self.advance();
825                Ok(Type::String)
826            }
827            Token::Keyword(crate::lexer::Keyword::Number) => {
828                self.advance();
829                Ok(Type::Number)
830            }
831            Token::Keyword(crate::lexer::Keyword::Boolean) => {
832                self.advance();
833                Ok(Type::Boolean)
834            }
835            Token::Keyword(crate::lexer::Keyword::Any) => {
836                self.advance();
837                Ok(Type::Any)
838            }
839            Token::Keyword(crate::lexer::Keyword::Void) => {
840                self.advance();
841                Ok(Type::Void)
842            }
843            Token::Keyword(crate::lexer::Keyword::Never) => {
844                self.advance();
845                Ok(Type::Never)
846            }
847            Token::Keyword(crate::lexer::Keyword::Unknown) => {
848                self.advance();
849                Ok(Type::Unknown)
850            }
851            Token::Keyword(crate::lexer::Keyword::Array) => {
852                self.advance();
853                if self.current_token() == &Token::LessThan {
854                    self.advance(); // consume <
855                    let element_type = self.parse_primary_type()?;
856                    self.expect_token(&Token::GreaterThan)?;
857                    Ok(Type::Array(Box::new(element_type)))
858                } else {
859                    Ok(Type::Array(Box::new(Type::Any)))
860                }
861            }
862            Token::Keyword(crate::lexer::Keyword::Readonly) => {
863                self.advance();
864                // Parse the type that follows readonly
865                let element_type = self.parse_primary_type()?;
866                // For now, just return the element type (readonly is handled at runtime)
867                Ok(element_type)
868            }
869            Token::Keyword(crate::lexer::Keyword::Keyof) => {
870                self.advance();
871                let _target_type = self.parse_type()?;
872                // For now, return string as keyof T resolves to string
873                Ok(Type::String)
874            }
875            Token::Keyword(crate::lexer::Keyword::Key) => {
876                self.advance();
877                Ok(Type::String) // Key -> string for now
878            }
879            Token::Keyword(crate::lexer::Keyword::Infer) => {
880                self.advance();
881                Ok(Type::Any) // infer -> any for now
882            }
883            Token::Keyword(crate::lexer::Keyword::Null) => {
884                self.advance();
885                Ok(Type::Null) // null -> null for now
886            }
887            Token::Keyword(crate::lexer::Keyword::Undefined) => {
888                self.advance();
889                Ok(Type::Undefined) // undefined -> undefined for now
890            }
891            Token::Identifier(name) => {
892                self.advance();
893                // Check for indexed access type: T[K]
894                if self.current_token() == &Token::LeftBracket {
895                    self.advance(); // consume [
896                    let _index_type = self.parse_type()?;
897                    self.expect_token(&Token::RightBracket)?;
898                    // For now, return the base type (indexed access is handled at runtime)
899                    Ok(Type::Named(name.to_string()))
900                } else if self.current_token() == &Token::LessThan {
901                    let type_parameters = self.parse_type_parameters()?;
902                    Ok(Type::GenericNamed {
903                        name: name.to_string(),
904                        type_parameters,
905                    })
906                } else {
907                    Ok(Type::Named(name.to_string()))
908                }
909            }
910            Token::String(s) => {
911                self.advance();
912                // String literal type
913                Ok(Type::Named(format!("\"{}\"", s)))
914            }
915            Token::Number(n) => {
916                self.advance();
917                // Number literal type
918                Ok(Type::Named(n.to_string()))
919            }
920            Token::LeftParen => {
921                self.advance();
922                let type_ = self.parse_type()?;
923                self.expect_token(&Token::RightParen)?;
924                Ok(type_)
925            }
926       Token::LeftBrace => {
927           // Parse object type: { prop: type; ... } or mapped type { [P in K]: T }
928           self.advance(); // consume {
929           let mut members = Vec::new();
930
931           while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
932               // Check if this is a mapped type: [P in K] or index signature: [key: type]
933               if self.current_token() == &Token::LeftBracket {
934                   // Look ahead to determine if this is a mapped type or index signature
935                   let mut pos = self.position + 1; // skip [
936                   let mut is_mapped_type = false;
937                   
938                   // Look for 'in' keyword to distinguish mapped type from index signature
939                   while pos < self.tokens.len() && self.tokens[pos] != Token::RightBracket {
940                       if self.tokens[pos] == Token::Keyword(Keyword::In) {
941                           is_mapped_type = true;
942                           break;
943                       }
944                       pos += 1;
945                   }
946                   
947                   if is_mapped_type {
948                       let mapped_type = self.parse_mapped_type()?;
949                       members.push(ObjectTypeMember::Property(PropertySignature {
950                           name: mapped_type.type_parameter.name.clone(),
951                           optional: false,
952                           type_: Some(*mapped_type.type_.clone()),
953                           readonly: mapped_type.readonly.unwrap_or(false),
954                       }));
955                       // parse_mapped_type already handles semicolon, so continue to next iteration
956                       continue;
957                   } else {
958                       // This is an index signature, parse it as such
959                       let index_sig = self.parse_index_signature()?;
960                       members.push(ObjectTypeMember::Index(index_sig));
961                       if self.current_token() == &Token::Semicolon {
962                           self.advance();
963                       }
964                       continue;
965                   }
966               } else {
967                   // Check for readonly modifier
968                   let readonly = if self.current_token() == &Token::Keyword(Keyword::Readonly) {
969                       self.advance(); // consume readonly
970                       true
971                   } else {
972                       false
973                   };
974
975                   let name = self.expect_identifier()?;
976                   let optional = if self.current_token() == &Token::QuestionMark {
977                       self.advance();
978                       true
979                   } else {
980                       false
981                   };
982                   self.expect_token(&Token::Colon)?;
983                   let type_ = self.parse_type()?;
984
985                   members.push(ObjectTypeMember::Property(PropertySignature {
986                       name,
987                       optional,
988                       type_: Some(type_),
989                       readonly,
990                   }));
991               }
992
993               if self.current_token() == &Token::Semicolon {
994                   self.advance();
995               }
996           }
997
998           self.expect_token(&Token::RightBrace)?;
999           Ok(Type::ObjectType(ObjectType { members }))
1000       }
1001            _ => Err(CompilerError::parse_error(
1002                self.position,
1003                0,
1004                format!("Unexpected token in type: {:?}", self.current_token()),
1005            )),
1006        }
1007    }
1008
1009    // Helper methods
1010    fn current_token(&self) -> &Token {
1011        &self.tokens[self.position]
1012    }
1013
1014    fn advance(&mut self) {
1015        if self.position < self.tokens.len() {
1016            self.position += 1;
1017        }
1018    }
1019
1020    fn expect_token(&mut self, expected: &Token) -> Result<()> {
1021        if self.current_token() == expected {
1022            self.advance();
1023            Ok(())
1024        } else {
1025            Err(CompilerError::parse_error(
1026                self.position,
1027                0,
1028                format!("Expected {:?}, found {:?}", expected, self.current_token()),
1029            ))
1030        }
1031    }
1032
1033    fn expect_keyword(&mut self) -> Result<crate::lexer::Keyword> {
1034        if let Token::Keyword(keyword) = self.current_token() {
1035            let keyword = keyword.clone();
1036            self.advance();
1037            Ok(keyword)
1038        } else {
1039            Err(CompilerError::parse_error(
1040                self.position,
1041                0,
1042                format!("Expected keyword, found {:?}", self.current_token()),
1043            ))
1044        }
1045    }
1046
1047    fn expect_identifier(&mut self) -> Result<String> {
1048        if let Token::Identifier(name) = self.current_token() {
1049            let name = name.clone();
1050            self.advance();
1051            Ok(name)
1052        } else {
1053            Err(CompilerError::parse_error(
1054                self.position,
1055                0,
1056                format!("Expected identifier, found {:?}", self.current_token()),
1057            ))
1058        }
1059    }
1060
1061    fn expect_semicolon(&mut self) -> Result<()> {
1062        self.expect_token(&Token::Semicolon)
1063    }
1064
1065    fn parse_string_literal(&mut self) -> Result<String> {
1066        if let Token::String(s) = self.current_token() {
1067            let s = s.clone();
1068            self.advance();
1069            Ok(s)
1070        } else {
1071            Err(CompilerError::parse_error(
1072                self.position,
1073                0,
1074                format!("Expected string literal, found {:?}", self.current_token()),
1075            ))
1076        }
1077    }
1078
1079    fn is_assignment_operator(&self) -> bool {
1080        matches!(
1081            self.current_token(),
1082            Token::Assign
1083                | Token::PlusAssign
1084                | Token::MinusAssign
1085                | Token::MultiplyAssign
1086                | Token::DivideAssign
1087        )
1088    }
1089
1090    fn is_equality_operator(&self) -> bool {
1091        matches!(
1092            self.current_token(),
1093            Token::Equal | Token::NotEqual | Token::StrictEqual | Token::StrictNotEqual
1094        )
1095    }
1096
1097    fn is_relational_operator(&self) -> bool {
1098        matches!(
1099            self.current_token(),
1100            Token::LessThan | Token::GreaterThan | Token::LessEqual | Token::GreaterEqual
1101        )
1102    }
1103
1104    fn is_additive_operator(&self) -> bool {
1105        matches!(self.current_token(), Token::Plus | Token::Minus)
1106    }
1107
1108    fn is_multiplicative_operator(&self) -> bool {
1109        matches!(
1110            self.current_token(),
1111            Token::Multiply | Token::Divide | Token::Modulo
1112        )
1113    }
1114
1115    fn is_unary_operator(&self) -> bool {
1116        matches!(
1117            self.current_token(),
1118            Token::Plus | Token::Minus | Token::Not | Token::Keyword(crate::lexer::Keyword::Typeof)
1119        )
1120    }
1121
1122    fn is_postfix_operator(&self) -> bool {
1123        matches!(
1124            self.current_token(),
1125            Token::LeftParen | Token::LeftBracket | Token::Dot
1126        )
1127    }
1128
1129    // Placeholder methods for complex parsing
1130    fn parse_type_parameters(&mut self) -> Result<Vec<TypeParameter>> {
1131        if self.current_token() == &Token::LessThan {
1132            self.advance();
1133            let mut type_parameters = Vec::new();
1134
1135            while self.current_token() != &Token::GreaterThan {
1136                let name = self.expect_identifier()?;
1137                let constraint =
1138                    if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
1139                        self.advance();
1140                        Some(self.parse_type()?)
1141                    } else {
1142                        None
1143                    };
1144
1145                let default_type = if self.current_token() == &Token::Assign {
1146                    self.advance();
1147                    Some(self.parse_type()?)
1148                } else {
1149                    None
1150                };
1151
1152                type_parameters.push(TypeParameter {
1153                    name,
1154                    constraint: constraint.map(Box::new),
1155                    default: default_type.map(Box::new),
1156                });
1157
1158                if self.current_token() == &Token::Comma {
1159                    self.advance();
1160                }
1161            }
1162
1163            self.expect_token(&Token::GreaterThan)?;
1164            Ok(type_parameters)
1165        } else {
1166            Ok(Vec::new())
1167        }
1168    }
1169
1170    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
1171        self.expect_token(&Token::LeftParen)?;
1172        let mut parameters = Vec::new();
1173
1174        while self.current_token() != &Token::RightParen {
1175            // Handle access modifiers on parameters (TypeScript feature)
1176            let mut _modifiers = Vec::new();
1177            while let Token::Keyword(keyword) = self.current_token() {
1178                match keyword {
1179                    crate::lexer::Keyword::Public | 
1180                    crate::lexer::Keyword::Private | 
1181                    crate::lexer::Keyword::Protected | 
1182                    crate::lexer::Keyword::Readonly => {
1183                        _modifiers.push(keyword.clone());
1184                        self.advance();
1185                    }
1186                    _ => break,
1187                }
1188            }
1189            
1190            let name = self.expect_identifier()?;
1191            let optional = if self.current_token() == &Token::QuestionMark {
1192                self.advance();
1193                true
1194            } else {
1195                false
1196            };
1197
1198            let type_annotation = if self.current_token() == &Token::Colon {
1199                self.advance();
1200                Some(self.parse_type()?)
1201            } else {
1202                None
1203            };
1204
1205            let initializer = if self.current_token() == &Token::Assign {
1206                self.advance();
1207                Some(self.parse_expression()?)
1208            } else {
1209                None
1210            };
1211
1212            parameters.push(Parameter {
1213                name,
1214                optional,
1215                type_: type_annotation.map(Box::new),
1216                initializer,
1217                rest: false,
1218            });
1219
1220            if self.current_token() == &Token::Comma {
1221                self.advance();
1222            }
1223        }
1224
1225        self.expect_token(&Token::RightParen)?;
1226        Ok(parameters)
1227    }
1228    
1229    fn parse_parameter_list(&mut self) -> Result<Vec<Parameter>> {
1230        let mut parameters = Vec::new();
1231
1232        while self.current_token() != &Token::RightParen {
1233            // Handle access modifiers on parameters (TypeScript feature)
1234            let mut _modifiers = Vec::new();
1235            while let Token::Keyword(keyword) = self.current_token() {
1236                match keyword {
1237                    crate::lexer::Keyword::Public | 
1238                    crate::lexer::Keyword::Private | 
1239                    crate::lexer::Keyword::Protected | 
1240                    crate::lexer::Keyword::Readonly => {
1241                        _modifiers.push(keyword.clone());
1242                        self.advance();
1243                    }
1244                    _ => break,
1245                }
1246            }
1247            
1248            let name = self.expect_identifier()?;
1249            let optional = if self.current_token() == &Token::QuestionMark {
1250                self.advance();
1251                true
1252            } else {
1253                false
1254            };
1255
1256            let type_annotation = if self.current_token() == &Token::Colon {
1257                self.advance();
1258                Some(self.parse_type()?)
1259            } else {
1260                None
1261            };
1262
1263            let initializer = if self.current_token() == &Token::Assign {
1264                self.advance();
1265                Some(self.parse_expression()?)
1266            } else {
1267                None
1268            };
1269
1270            parameters.push(Parameter {
1271                name,
1272                optional,
1273                type_: type_annotation.map(Box::new),
1274                initializer,
1275                rest: false,
1276            });
1277
1278            if self.current_token() == &Token::Comma {
1279                self.advance();
1280            }
1281        }
1282
1283        Ok(parameters)
1284    }
1285
1286    fn parse_implements(&mut self) -> Result<Vec<Type>> {
1287        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Implements) {
1288            self.advance();
1289            let mut types = Vec::new();
1290
1291            loop {
1292                let type_ = self.parse_type()?;
1293                types.push(type_);
1294
1295                if self.current_token() == &Token::Comma {
1296                    self.advance();
1297                } else {
1298                    break;
1299                }
1300            }
1301
1302            Ok(types)
1303        } else {
1304            Ok(Vec::new())
1305        }
1306    }
1307
1308    fn parse_extends(&mut self) -> Result<Vec<Type>> {
1309        let mut extends = Vec::new();
1310        
1311        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
1312            self.advance(); // consume 'extends'
1313            
1314            // Parse the first extended type
1315            let type_ = self.parse_type()?;
1316            extends.push(type_);
1317            
1318            // Parse additional extended types (comma-separated)
1319            while self.current_token() == &Token::Comma {
1320                self.advance(); // consume ','
1321                let type_ = self.parse_type()?;
1322                extends.push(type_);
1323            }
1324        }
1325        
1326        Ok(extends)
1327    }
1328
1329    fn parse_class_body(&mut self) -> Result<ClassBody> {
1330        self.expect_token(&Token::LeftBrace)?;
1331        let mut members = Vec::new();
1332
1333        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1334            let member = self.parse_class_member()?;
1335            members.push(member);
1336        }
1337
1338        self.expect_token(&Token::RightBrace)?;
1339        Ok(ClassBody { members })
1340    }
1341
1342    fn parse_interface_body(&mut self) -> Result<InterfaceBody> {
1343        self.expect_token(&Token::LeftBrace)?;
1344        let mut members = Vec::new();
1345
1346        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1347            let member = self.parse_interface_member()?;
1348            members.push(member);
1349        }
1350        self.expect_token(&Token::RightBrace)?;
1351        Ok(InterfaceBody { members })
1352    }
1353
1354    fn parse_enum_members(&mut self) -> Result<Vec<EnumMember>> {
1355        self.expect_token(&Token::LeftBrace)?;
1356        let mut members = Vec::new();
1357
1358        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1359            let member = self.parse_enum_member()?;
1360            members.push(member);
1361
1362            if self.current_token() == &Token::Comma {
1363                self.advance();
1364            }
1365        }
1366
1367        self.expect_token(&Token::RightBrace)?;
1368        Ok(members)
1369    }
1370
1371    fn parse_import_specifiers(&mut self) -> Result<Vec<ImportSpecifier>> {
1372        let mut specifiers = Vec::new();
1373
1374        if self.current_token() == &Token::LeftBrace {
1375            self.advance(); // consume '{'
1376
1377            while self.current_token() != &Token::RightBrace {
1378                let name = self.expect_identifier()?;
1379                specifiers.push(ImportSpecifier::Named(NamedImportSpecifier {
1380                    imported: name.clone(),
1381                    name,
1382                }));
1383
1384                if self.current_token() == &Token::Comma {
1385                    self.advance();
1386                }
1387            }
1388
1389            self.expect_token(&Token::RightBrace)?; // consume '}'
1390        } else {
1391            // Default import
1392            let name = self.expect_identifier()?;
1393            specifiers.push(ImportSpecifier::Default(DefaultImportSpecifier { name }));
1394        }
1395
1396        Ok(specifiers)
1397    }
1398
1399    fn parse_arguments(&mut self) -> Result<Vec<Expression>> {
1400        let mut arguments = Vec::new();
1401
1402        while self.current_token() != &Token::RightParen {
1403            let argument = self.parse_expression()?;
1404            arguments.push(argument);
1405
1406            if self.current_token() == &Token::Comma {
1407                self.advance();
1408            } else if self.current_token() != &Token::RightParen {
1409                return Err(CompilerError::parse_error(
1410                    1,
1411                    1,
1412                    "Expected comma or closing parenthesis".to_string(),
1413                ));
1414            }
1415        }
1416
1417        Ok(arguments)
1418    }
1419
1420    fn parse_class_member(&mut self) -> Result<ClassMember> {
1421        let mut modifiers = Vec::new();
1422        
1423        // Parse access modifiers
1424        while let Token::Keyword(keyword) = self.current_token() {
1425            match keyword {
1426                crate::lexer::Keyword::Public => {
1427                    modifiers.push(crate::ast::Modifier::Public);
1428                    self.advance();
1429                }
1430                crate::lexer::Keyword::Private => {
1431                    modifiers.push(crate::ast::Modifier::Private);
1432                    self.advance();
1433                }
1434                crate::lexer::Keyword::Protected => {
1435                    modifiers.push(crate::ast::Modifier::Protected);
1436                    self.advance();
1437                }
1438                crate::lexer::Keyword::Readonly => {
1439                    modifiers.push(crate::ast::Modifier::Readonly);
1440                    self.advance();
1441                }
1442                crate::lexer::Keyword::Static => {
1443                    modifiers.push(crate::ast::Modifier::Static);
1444                    self.advance();
1445                }
1446                _ => break,
1447            }
1448        }
1449
1450        let token = self.current_token().clone();
1451
1452        match token {
1453            Token::Keyword(crate::lexer::Keyword::Get) => {
1454                self.advance();
1455                let name = if let Token::Identifier(name) = self.current_token() {
1456                    let name = name.clone();
1457                    self.advance();
1458                    name
1459                } else {
1460                    return Err(CompilerError::parse_error(
1461                        1,
1462                        1,
1463                        "Expected getter name".to_string(),
1464                    ));
1465                };
1466
1467                // Handle getter parameters (empty parentheses)
1468                if self.current_token() == &Token::LeftParen {
1469                    self.advance(); // consume '('
1470                    self.expect_token(&Token::RightParen)?; // consume ')'
1471                }
1472
1473                let return_type = if self.current_token() == &Token::Colon {
1474                    self.advance();
1475                    Some(self.parse_type()?)
1476                } else {
1477                    None
1478                };
1479                let body = if self.current_token() == &Token::LeftBrace {
1480                    self.parse_block_statement()?
1481                } else {
1482                    return Err(CompilerError::parse_error(
1483                        1,
1484                        1,
1485                        "Expected block statement for getter".to_string(),
1486                    ));
1487                };
1488
1489                Ok(ClassMember::Getter(GetterDeclaration {
1490                    name,
1491                    type_: return_type,
1492                    body: Some(body),
1493                    modifiers,
1494                }))
1495            }
1496            Token::Keyword(crate::lexer::Keyword::Set) => {
1497                self.advance();
1498                let name = if let Token::Identifier(name) = self.current_token() {
1499                    let name = name.clone();
1500                    self.advance();
1501                    name
1502                } else {
1503                    return Err(CompilerError::parse_error(
1504                        1,
1505                        1,
1506                        "Expected setter name".to_string(),
1507                    ));
1508                };
1509
1510                let parameter = if self.current_token() == &Token::LeftParen {
1511                    self.advance(); // consume '('
1512                    let name = self.expect_identifier()?;
1513                    self.expect_token(&Token::Colon)?;
1514                    let type_annotation = self.parse_type()?;
1515                    self.expect_token(&Token::RightParen)?; // consume ')'
1516                    
1517                    Parameter {
1518                        name,
1519                        optional: false,
1520                        type_: Some(Box::new(type_annotation)),
1521                        initializer: None,
1522                        rest: false,
1523                    }
1524                } else {
1525                    return Err(CompilerError::parse_error(
1526                        1,
1527                        1,
1528                        "Expected setter parameter".to_string(),
1529                    ));
1530                };
1531
1532                let body = if self.current_token() == &Token::LeftBrace {
1533                    self.parse_block_statement()?
1534                } else {
1535                    return Err(CompilerError::parse_error(
1536                        1,
1537                        1,
1538                        "Expected block statement for setter".to_string(),
1539                    ));
1540                };
1541
1542                Ok(ClassMember::Setter(SetterDeclaration {
1543                    name,
1544                    parameter,
1545                    body: Some(body),
1546                    modifiers,
1547                }))
1548            }
1549            Token::Identifier(name) => {
1550                self.advance();
1551
1552                // Special handling for constructor
1553                if name == "constructor" {
1554                    // It's a constructor
1555                    let parameters = self.parse_parameters()?;
1556                    let body = self.parse_block_statement()?;
1557
1558                    Ok(ClassMember::Constructor(ConstructorDeclaration {
1559                        parameters,
1560                        body: Some(body),
1561                        modifiers,
1562                    }))
1563                } else if self.current_token() == &Token::LeftParen {
1564                    // It's a method
1565                    let parameters = self.parse_parameters()?;
1566                    let return_type = if self.current_token() == &Token::Colon {
1567                        self.advance();
1568                        Some(self.parse_type()?)
1569                    } else {
1570                        None
1571                    };
1572                    let body = self.parse_block_statement()?;
1573
1574                    Ok(ClassMember::Method(MethodDeclaration {
1575                        name,
1576                        optional: false,
1577                        type_parameters: Vec::new(),
1578                        parameters,
1579                        return_type,
1580                        body: Some(body),
1581                        modifiers,
1582                    }))
1583                } else if self.current_token() == &Token::Colon {
1584                    // It's a property
1585                    self.advance();
1586                    let type_annotation = self.parse_type()?;
1587                    
1588                    let initializer = if self.current_token() == &Token::Assign {
1589                        self.advance();
1590                        Some(self.parse_expression()?)
1591                    } else {
1592                        None
1593                    };
1594                    
1595                    self.expect_token(&Token::Semicolon)?;
1596
1597                    Ok(ClassMember::Property(PropertyDeclaration {
1598                        name,
1599                        optional: false,
1600                        type_: Some(type_annotation),
1601                        initializer,
1602                        modifiers,
1603                    }))
1604                } else {
1605                    // It's a constructor
1606                    if name == "constructor" {
1607                        let parameters = self.parse_parameters()?;
1608                        let body = self.parse_block_statement()?;
1609
1610                        Ok(ClassMember::Constructor(ConstructorDeclaration {
1611                            parameters,
1612                            body: Some(body),
1613                            modifiers: Vec::new(),
1614                        }))
1615                    } else {
1616                        Err(CompilerError::parse_error(
1617                            1,
1618                            1,
1619                            "Unexpected class member".to_string(),
1620                        ))
1621                    }
1622                }
1623            }
1624            _ => Err(CompilerError::parse_error(
1625                1,
1626                1,
1627                "Expected class member".to_string(),
1628            )),
1629        }
1630    }
1631
1632    fn parse_interface_member(&mut self) -> Result<ObjectTypeMember> {
1633        let mut readonly = false;
1634        
1635        // Check for readonly modifier
1636        if let Token::Keyword(crate::lexer::Keyword::Readonly) = self.current_token() {
1637            readonly = true;
1638            self.advance();
1639            
1640            // Check if the next token is also 'readonly' (property name)
1641            if let Token::Keyword(crate::lexer::Keyword::Readonly) = self.current_token() {
1642                // Handle case where readonly is both modifier and property name: readonly readonly: boolean;
1643                let name = "readonly".to_string();
1644                self.advance(); // consume the property name 'readonly'
1645                
1646                if self.current_token() == &Token::Colon {
1647                    // It's a property signature
1648                    self.advance();
1649                    let type_annotation = self.parse_type()?;
1650                    self.expect_token(&Token::Semicolon)?;
1651
1652                    return Ok(ObjectTypeMember::Property(PropertySignature {
1653                        name,
1654                        optional: false,
1655                        type_: Some(type_annotation),
1656                        readonly,
1657                    }));
1658                } else {
1659                    return Err(CompilerError::parse_error(
1660                        1, 1,
1661                        "Expected colon after property name".to_string(),
1662                    ));
1663                }
1664            }
1665        }
1666        
1667        let token = self.current_token().clone();
1668
1669        match token {
1670            Token::LeftParen => {
1671                // It's a call signature: (x: number, y: number): number;
1672                let parameters = self.parse_parameters()?;
1673                let return_type = if self.current_token() == &Token::Colon {
1674                    self.advance();
1675                    Some(self.parse_type()?)
1676                } else {
1677                    None
1678                };
1679                self.expect_token(&Token::Semicolon)?;
1680
1681                Ok(ObjectTypeMember::Method(MethodSignature {
1682                    name: "call".to_string(), // Use a default name for call signatures
1683                    optional: false,
1684                    type_parameters: Vec::new(),
1685                    parameters,
1686                    return_type,
1687                }))
1688            }
1689            Token::Keyword(crate::lexer::Keyword::New) => {
1690                // It's a construct signature: new (name: string): BasicInterface;
1691                self.advance(); // consume 'new'
1692                let parameters = self.parse_parameters()?;
1693                let return_type = if self.current_token() == &Token::Colon {
1694                    self.advance();
1695                    Some(self.parse_type()?)
1696                } else {
1697                    None
1698                };
1699                self.expect_token(&Token::Semicolon)?;
1700
1701                Ok(ObjectTypeMember::Method(MethodSignature {
1702                    name: "constructor".to_string(), // Use a default name for construct signatures
1703                    optional: false,
1704                    type_parameters: Vec::new(),
1705                    parameters,
1706                    return_type,
1707                }))
1708            }
1709            Token::Keyword(crate::lexer::Keyword::Readonly) => {
1710                // Handle case where readonly is the property name (without modifier)
1711                let name = "readonly".to_string();
1712                self.advance();
1713                
1714                if self.current_token() == &Token::Colon {
1715                    // It's a property signature
1716                    self.advance();
1717                    let type_annotation = self.parse_type()?;
1718                    self.expect_token(&Token::Semicolon)?;
1719
1720                    Ok(ObjectTypeMember::Property(PropertySignature {
1721                        name,
1722                        optional: false,
1723                        type_: Some(type_annotation),
1724                        readonly,
1725                    }))
1726                } else {
1727                    Err(CompilerError::parse_error(
1728                        1, 1,
1729                        "Expected colon after property name".to_string(),
1730                    ))
1731                }
1732            }
1733            Token::Identifier(name) => {
1734                self.advance();
1735                
1736                // Check for optional marker
1737                let optional = if self.current_token() == &Token::QuestionMark {
1738                    self.advance();
1739                    true
1740                } else {
1741                    false
1742                };
1743
1744                if self.current_token() == &Token::LeftParen {
1745                    // It's a method signature
1746                    let parameters = self.parse_parameters()?;
1747                    let return_type = if self.current_token() == &Token::Colon {
1748                        self.advance();
1749                        Some(self.parse_type()?)
1750                    } else {
1751                        None
1752                    };
1753                    self.expect_token(&Token::Semicolon)?;
1754
1755                    Ok(ObjectTypeMember::Method(MethodSignature {
1756                        name,
1757                        optional,
1758                        type_parameters: Vec::new(),
1759                        parameters,
1760                        return_type,
1761                    }))
1762                } else if self.current_token() == &Token::Colon {
1763                    // It's a property signature
1764                    self.advance();
1765                    let type_annotation = self.parse_type()?;
1766                    self.expect_token(&Token::Semicolon)?;
1767
1768                    Ok(ObjectTypeMember::Property(PropertySignature {
1769                        name,
1770                        optional,
1771                        type_: Some(type_annotation),
1772                        readonly,
1773                    }))
1774                } else {
1775                    Err(CompilerError::parse_error(
1776                        1,
1777                        1,
1778                        "Expected method or property signature".to_string(),
1779                    ))
1780                }
1781            }
1782            Token::LeftBracket => {
1783                // It's an index signature: [key: string]: any;
1784                self.advance(); // consume '['
1785                let key_name = match self.current_token() {
1786                    Token::Identifier(name) => {
1787                        let name = name.clone();
1788                        self.advance();
1789                        name
1790                    }
1791                    Token::Keyword(crate::lexer::Keyword::Key) => {
1792                        self.advance();
1793                        "key".to_string()
1794                    }
1795                    _ => return Err(CompilerError::parse_error(
1796                        1, 1,
1797                        "Expected identifier or 'key' in index signature".to_string(),
1798                    ))
1799                };
1800                self.expect_token(&Token::Colon)?;
1801                let key_type = self.parse_type()?;
1802                self.expect_token(&Token::RightBracket)?;
1803                self.expect_token(&Token::Colon)?;
1804                let value_type = self.parse_type()?;
1805                self.expect_token(&Token::Semicolon)?;
1806
1807                Ok(ObjectTypeMember::Index(IndexSignature {
1808                    parameter: Box::new(Parameter {
1809                        name: key_name,
1810                        type_: Some(Box::new(key_type)),
1811                        optional: false,
1812                        initializer: None,
1813                        rest: false,
1814                    }),
1815                    type_: value_type,
1816                    readonly: false,
1817                }))
1818            }
1819            _ => Err(CompilerError::parse_error(
1820                1,
1821                1,
1822                "Expected interface member".to_string(),
1823            )),
1824        }
1825    }
1826
1827    fn parse_enum_member(&mut self) -> Result<EnumMember> {
1828        let name = self.expect_identifier()?;
1829
1830        let initializer = if self.current_token() == &Token::Assign {
1831            self.advance();
1832            Some(self.parse_expression()?)
1833        } else {
1834            None
1835        };
1836
1837        Ok(EnumMember { name, initializer })
1838    }
1839
1840    fn parse_if_statement(&mut self) -> Result<Statement> {
1841        self.expect_keyword()?; // if
1842
1843        self.expect_token(&Token::LeftParen)?;
1844        let test = self.parse_expression()?;
1845        self.expect_token(&Token::RightParen)?;
1846
1847        let consequent = self.parse_statement()?.unwrap();
1848
1849        let alternate = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Else) {
1850            self.advance();
1851            Some(self.parse_statement()?.unwrap())
1852        } else {
1853            None
1854        };
1855
1856        Ok(Statement::IfStatement(Box::new(IfStatement {
1857            condition: test,
1858            consequent: Box::new(consequent),
1859            alternate,
1860        })))
1861    }
1862
1863    fn parse_property_key(&mut self) -> Result<Expression> {
1864        // TODO: Implement property key parsing
1865        self.parse_expression()
1866    }
1867
1868    /// Parse index signature: [key: type]: returnType
1869    fn parse_index_signature(&mut self) -> Result<IndexSignature> {
1870        self.expect_token(&Token::LeftBracket)?;
1871        
1872        let key_name = match self.current_token() {
1873            Token::Identifier(name) => {
1874                let name = name.clone();
1875                self.advance();
1876                name
1877            }
1878            Token::Keyword(Keyword::Key) => {
1879                self.advance();
1880                "key".to_string()
1881            }
1882            _ => {
1883                return Err(CompilerError::parse_error(
1884                    self.position,
1885                    0,
1886                    format!("Expected identifier or 'key', found {:?}", self.current_token()),
1887                ));
1888            }
1889        };
1890        
1891        self.expect_token(&Token::Colon)?;
1892        let key_type = self.parse_type()?;
1893        self.expect_token(&Token::RightBracket)?;
1894        self.expect_token(&Token::Colon)?;
1895        let value_type = self.parse_type()?;
1896        
1897        Ok(IndexSignature {
1898            parameter: Box::new(Parameter {
1899                name: key_name,
1900                type_: Some(Box::new(key_type)),
1901                optional: false,
1902                initializer: None,
1903                rest: false,
1904            }),
1905            type_: value_type,
1906            readonly: false,
1907        })
1908    }
1909
1910    /// Parse mapped type: [P in K] or [P in keyof T]
1911    fn parse_mapped_type(&mut self) -> Result<MappedType> {
1912        // Parse [P in K]: T
1913        self.expect_token(&Token::LeftBracket)?;
1914        
1915        let type_parameter_name = match self.current_token() {
1916            Token::Identifier(name) => {
1917                let name = name.clone();
1918                self.advance();
1919                name
1920            }
1921            Token::Keyword(Keyword::Key) => {
1922                self.advance();
1923                "Key".to_string()
1924            }
1925            _ => {
1926                return Err(CompilerError::parse_error(
1927                    self.position,
1928                    0,
1929                    format!("Expected identifier or Key, found {:?}", self.current_token()),
1930                ));
1931            }
1932        };
1933        let type_parameter = TypeParameter {
1934            name: type_parameter_name.clone(),
1935            constraint: None,
1936            default: None,
1937        };
1938
1939        // Expect 'in' keyword
1940        if self.current_token() == &Token::Keyword(Keyword::In) {
1941            self.advance();
1942        } else {
1943            return Err(CompilerError::parse_error(
1944                self.position,
1945                0,
1946                format!("Expected 'in', found {:?}", self.current_token()),
1947            ));
1948        }
1949        
1950        let constraint_type = self.parse_type()?;
1951        
1952        self.expect_token(&Token::RightBracket)?;
1953        self.expect_token(&Token::Colon)?;
1954        
1955        let value_type = self.parse_type()?;
1956        
1957        // Skip semicolon if present (it's optional in mapped types)
1958        if self.current_token() == &Token::Semicolon {
1959            self.advance();
1960        }
1961        
1962        Ok(MappedType {
1963            type_parameter: Box::new(type_parameter),
1964            constraint: Some(Box::new(constraint_type)),
1965            name_type: None,
1966            type_: Box::new(value_type),
1967            readonly: None,
1968            optional: None,
1969        })
1970    }
1971}
TypeScript_Rust_Compiler/parser.rs

TypeScript_Rust_Compiler/
parser.rs
