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

TypeScript_Rust_Compiler/
parser.rs
