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::New) => {
655                self.advance();
656                let callee = self.parse_primary_expression()?;
657                let arguments = if self.current_token() == &Token::LeftParen {
658                    self.advance(); // consume '('
659                    let args = self.parse_arguments()?;
660                    self.expect_token(&Token::RightParen)?;
661                    args
662                } else {
663                    Vec::new()
664                };
665                Ok(Expression::New(NewExpression {
666                    callee: Box::new(callee),
667                    arguments,
668                }))
669            }
670            Token::LeftParen => {
671                // Look ahead to see if this is an arrow function
672                let mut pos = self.position + 1;
673                let mut paren_count = 1;
674                
675                // Skip to matching closing paren
676                while pos < self.tokens.len() && paren_count > 0 {
677                    match &self.tokens[pos] {
678                        Token::LeftParen => paren_count += 1,
679                        Token::RightParen => paren_count -= 1,
680                        _ => {}
681                    }
682                    pos += 1;
683                }
684                
685                // Check if next token is arrow
686                if pos < self.tokens.len() && self.tokens[pos] == Token::Arrow {
687                    // This is an arrow function
688                    self.advance(); // consume (
689                    let parameters = self.parse_parameter_list()?;
690                    self.expect_token(&Token::RightParen)?;
691                    self.expect_token(&Token::Arrow)?;
692                    let body = if self.current_token() == &Token::LeftBrace {
693                        self.parse_block_statement()?
694                    } else {
695                        let expr = self.parse_expression()?;
696                        Statement::ExpressionStatement(ExpressionStatement {
697                            expression: expr,
698                        })
699                    };
700                    
701                    Ok(Expression::Arrow(Box::new(ArrowFunctionExpression {
702                        type_parameters: Vec::new(),
703                        parameters,
704                        return_type: None,
705                        body: Box::new(body),
706                    })))
707                } else {
708                    // Regular parenthesized expression
709                    self.advance();
710                    let expression = self.parse_expression()?;
711                    self.expect_token(&Token::RightParen)?;
712                    Ok(Expression::Parenthesized(ParenthesizedExpression {
713                        expression: Box::new(expression),
714                    }))
715                }
716            }
717            Token::LeftBrace => self.parse_object_expression(),
718            Token::LeftBracket => self.parse_array_expression(),
719            _ => Err(CompilerError::parse_error(
720                self.position,
721                0,
722                format!("Unexpected token: {:?}", self.current_token()),
723            )),
724        }
725    }
726
727    /// Parse object expression
728    fn parse_object_expression(&mut self) -> Result<Expression> {
729        self.expect_token(&Token::LeftBrace)?;
730        let mut properties = Vec::new();
731
732        while self.current_token() != &Token::RightBrace {
733            let key = self.parse_property_key()?;
734            let value = if self.current_token() == &Token::Colon {
735                self.advance();
736                self.parse_expression()?
737            } else {
738                key.clone()
739            };
740
741            properties.push(ObjectProperty {
742                key,
743                value,
744                shorthand: false,
745                computed: false,
746                method: false,
747            });
748
749            if self.current_token() == &Token::Comma {
750                self.advance();
751            }
752        }
753
754        self.expect_token(&Token::RightBrace)?;
755        Ok(Expression::Object(ObjectExpression { properties }))
756    }
757
758    /// Parse array expression
759    fn parse_array_expression(&mut self) -> Result<Expression> {
760        self.expect_token(&Token::LeftBracket)?;
761        let mut elements = Vec::new();
762
763        while self.current_token() != &Token::RightBracket {
764            if self.current_token() == &Token::Comma {
765                self.advance();
766                elements.push(None);
767            } else {
768                elements.push(Some(self.parse_expression()?));
769                if self.current_token() == &Token::Comma {
770                    self.advance();
771                }
772            }
773        }
774
775        self.expect_token(&Token::RightBracket)?;
776        Ok(Expression::Array(ArrayExpression { elements }))
777    }
778
779    /// Parse type
780    fn parse_type(&mut self) -> Result<Type> {
781        let mut left_type = self.parse_primary_type()?;
782        
783        // Handle union and intersection types
784        while matches!(self.current_token(), Token::Union | Token::Intersection) {
785            let operator = self.current_token().clone();
786            self.advance();
787            let right_type = self.parse_primary_type()?;
788            
789            left_type = match operator {
790                Token::Union => Type::Union {
791                    left: Box::new(left_type),
792                    right: Box::new(right_type),
793                },
794                Token::Intersection => Type::Intersection {
795                    left: Box::new(left_type),
796                    right: Box::new(right_type),
797                },
798                _ => return Err(CompilerError::parse_error(
799                    1,
800                    1,
801                    "Expected union or intersection operator",
802                )),
803            };
804        }
805        
806        // Handle array types: T[]
807        while self.current_token() == &Token::LeftBracket {
808            self.advance(); // consume [
809            self.expect_token(&Token::RightBracket)?; // consume ]
810            left_type = Type::Array(Box::new(left_type));
811        }
812        
813        Ok(left_type)
814    }
815    
816    fn parse_primary_type(&mut self) -> Result<Type> {
817        let token = self.current_token().clone();
818        match token {
819            Token::Keyword(crate::lexer::Keyword::String) => {
820                self.advance();
821                Ok(Type::String)
822            }
823            Token::Keyword(crate::lexer::Keyword::Number) => {
824                self.advance();
825                Ok(Type::Number)
826            }
827            Token::Keyword(crate::lexer::Keyword::Boolean) => {
828                self.advance();
829                Ok(Type::Boolean)
830            }
831            Token::Keyword(crate::lexer::Keyword::Any) => {
832                self.advance();
833                Ok(Type::Any)
834            }
835            Token::Keyword(crate::lexer::Keyword::Void) => {
836                self.advance();
837                Ok(Type::Void)
838            }
839            Token::Keyword(crate::lexer::Keyword::Never) => {
840                self.advance();
841                Ok(Type::Never)
842            }
843            Token::Keyword(crate::lexer::Keyword::Unknown) => {
844                self.advance();
845                Ok(Type::Unknown)
846            }
847            Token::Keyword(crate::lexer::Keyword::Array) => {
848                self.advance();
849                if self.current_token() == &Token::LessThan {
850                    self.advance(); // consume <
851                    let element_type = self.parse_primary_type()?;
852                    self.expect_token(&Token::GreaterThan)?;
853                    Ok(Type::Array(Box::new(element_type)))
854                } else {
855                    Ok(Type::Array(Box::new(Type::Any)))
856                }
857            }
858            Token::Keyword(crate::lexer::Keyword::Readonly) => {
859                self.advance();
860                // Parse the type that follows readonly
861                let element_type = self.parse_primary_type()?;
862                // For now, just return the element type (readonly is handled at runtime)
863                Ok(element_type)
864            }
865            Token::Keyword(crate::lexer::Keyword::Keyof) => {
866                self.advance();
867                let _target_type = self.parse_type()?;
868                // For now, return string as keyof T resolves to string
869                Ok(Type::String)
870            }
871            Token::Keyword(crate::lexer::Keyword::Key) => {
872                self.advance();
873                Ok(Type::String) // Key -> string for now
874            }
875            Token::Keyword(crate::lexer::Keyword::Infer) => {
876                self.advance();
877                Ok(Type::Any) // infer -> any for now
878            }
879            Token::Keyword(crate::lexer::Keyword::Null) => {
880                self.advance();
881                Ok(Type::Null) // null -> null for now
882            }
883            Token::Keyword(crate::lexer::Keyword::Undefined) => {
884                self.advance();
885                Ok(Type::Undefined) // undefined -> undefined for now
886            }
887            Token::Identifier(name) => {
888                self.advance();
889                // Check for indexed access type: T[K]
890                if self.current_token() == &Token::LeftBracket {
891                    self.advance(); // consume [
892                    let _index_type = self.parse_type()?;
893                    self.expect_token(&Token::RightBracket)?;
894                    // For now, return the base type (indexed access is handled at runtime)
895                    Ok(Type::Named(name.to_string()))
896                } else if self.current_token() == &Token::LessThan {
897                    let type_parameters = self.parse_type_parameters()?;
898                    Ok(Type::GenericNamed {
899                        name: name.to_string(),
900                        type_parameters,
901                    })
902                } else {
903                    Ok(Type::Named(name.to_string()))
904                }
905            }
906            Token::String(s) => {
907                self.advance();
908                // String literal type
909                Ok(Type::Named(format!("\"{}\"", s)))
910            }
911            Token::Number(n) => {
912                self.advance();
913                // Number literal type
914                Ok(Type::Named(n.to_string()))
915            }
916            Token::LeftParen => {
917                self.advance();
918                let type_ = self.parse_type()?;
919                self.expect_token(&Token::RightParen)?;
920                Ok(type_)
921            }
922       Token::LeftBrace => {
923           // Parse object type: { prop: type; ... } or mapped type { [P in K]: T }
924           self.advance(); // consume {
925           let mut members = Vec::new();
926
927           while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
928               // Check if this is a mapped type: [P in K] or index signature: [key: type]
929               if self.current_token() == &Token::LeftBracket {
930                   // Look ahead to determine if this is a mapped type or index signature
931                   let mut pos = self.position + 1; // skip [
932                   let mut is_mapped_type = false;
933                   
934                   // Look for 'in' keyword to distinguish mapped type from index signature
935                   while pos < self.tokens.len() && self.tokens[pos] != Token::RightBracket {
936                       if self.tokens[pos] == Token::Keyword(Keyword::In) {
937                           is_mapped_type = true;
938                           break;
939                       }
940                       pos += 1;
941                   }
942                   
943                   if is_mapped_type {
944                       let mapped_type = self.parse_mapped_type()?;
945                       members.push(ObjectTypeMember::Property(PropertySignature {
946                           name: mapped_type.type_parameter.name.clone(),
947                           optional: false,
948                           type_: Some(*mapped_type.type_.clone()),
949                           readonly: mapped_type.readonly.unwrap_or(false),
950                       }));
951                       // parse_mapped_type already handles semicolon, so continue to next iteration
952                       continue;
953                   } else {
954                       // This is an index signature, parse it as such
955                       let index_sig = self.parse_index_signature()?;
956                       members.push(ObjectTypeMember::Index(index_sig));
957                       if self.current_token() == &Token::Semicolon {
958                           self.advance();
959                       }
960                       continue;
961                   }
962               } else {
963                   // Check for readonly modifier
964                   let readonly = if self.current_token() == &Token::Keyword(Keyword::Readonly) {
965                       self.advance(); // consume readonly
966                       true
967                   } else {
968                       false
969                   };
970
971                   let name = self.expect_identifier()?;
972                   let optional = if self.current_token() == &Token::QuestionMark {
973                       self.advance();
974                       true
975                   } else {
976                       false
977                   };
978                   self.expect_token(&Token::Colon)?;
979                   let type_ = self.parse_type()?;
980
981                   members.push(ObjectTypeMember::Property(PropertySignature {
982                       name,
983                       optional,
984                       type_: Some(type_),
985                       readonly,
986                   }));
987               }
988
989               if self.current_token() == &Token::Semicolon {
990                   self.advance();
991               }
992           }
993
994           self.expect_token(&Token::RightBrace)?;
995           Ok(Type::ObjectType(ObjectType { members }))
996       }
997            _ => Err(CompilerError::parse_error(
998                self.position,
999                0,
1000                format!("Unexpected token in type: {:?}", self.current_token()),
1001            )),
1002        }
1003    }
1004
1005    // Helper methods
1006    fn current_token(&self) -> &Token {
1007        &self.tokens[self.position]
1008    }
1009
1010    fn advance(&mut self) {
1011        if self.position < self.tokens.len() {
1012            self.position += 1;
1013        }
1014    }
1015
1016    fn expect_token(&mut self, expected: &Token) -> Result<()> {
1017        if self.current_token() == expected {
1018            self.advance();
1019            Ok(())
1020        } else {
1021            Err(CompilerError::parse_error(
1022                self.position,
1023                0,
1024                format!("Expected {:?}, found {:?}", expected, self.current_token()),
1025            ))
1026        }
1027    }
1028
1029    fn expect_keyword(&mut self) -> Result<crate::lexer::Keyword> {
1030        if let Token::Keyword(keyword) = self.current_token() {
1031            let keyword = keyword.clone();
1032            self.advance();
1033            Ok(keyword)
1034        } else {
1035            Err(CompilerError::parse_error(
1036                self.position,
1037                0,
1038                format!("Expected keyword, found {:?}", self.current_token()),
1039            ))
1040        }
1041    }
1042
1043    fn expect_identifier(&mut self) -> Result<String> {
1044        if let Token::Identifier(name) = self.current_token() {
1045            let name = name.clone();
1046            self.advance();
1047            Ok(name)
1048        } else {
1049            Err(CompilerError::parse_error(
1050                self.position,
1051                0,
1052                format!("Expected identifier, found {:?}", self.current_token()),
1053            ))
1054        }
1055    }
1056
1057    fn expect_semicolon(&mut self) -> Result<()> {
1058        self.expect_token(&Token::Semicolon)
1059    }
1060
1061    fn parse_string_literal(&mut self) -> Result<String> {
1062        if let Token::String(s) = self.current_token() {
1063            let s = s.clone();
1064            self.advance();
1065            Ok(s)
1066        } else {
1067            Err(CompilerError::parse_error(
1068                self.position,
1069                0,
1070                format!("Expected string literal, found {:?}", self.current_token()),
1071            ))
1072        }
1073    }
1074
1075    fn is_assignment_operator(&self) -> bool {
1076        matches!(
1077            self.current_token(),
1078            Token::Assign
1079                | Token::PlusAssign
1080                | Token::MinusAssign
1081                | Token::MultiplyAssign
1082                | Token::DivideAssign
1083        )
1084    }
1085
1086    fn is_equality_operator(&self) -> bool {
1087        matches!(
1088            self.current_token(),
1089            Token::Equal | Token::NotEqual | Token::StrictEqual | Token::StrictNotEqual
1090        )
1091    }
1092
1093    fn is_relational_operator(&self) -> bool {
1094        matches!(
1095            self.current_token(),
1096            Token::LessThan | Token::GreaterThan | Token::LessEqual | Token::GreaterEqual
1097        )
1098    }
1099
1100    fn is_additive_operator(&self) -> bool {
1101        matches!(self.current_token(), Token::Plus | Token::Minus)
1102    }
1103
1104    fn is_multiplicative_operator(&self) -> bool {
1105        matches!(
1106            self.current_token(),
1107            Token::Multiply | Token::Divide | Token::Modulo
1108        )
1109    }
1110
1111    fn is_unary_operator(&self) -> bool {
1112        matches!(
1113            self.current_token(),
1114            Token::Plus | Token::Minus | Token::Not | Token::Keyword(crate::lexer::Keyword::Typeof)
1115        )
1116    }
1117
1118    fn is_postfix_operator(&self) -> bool {
1119        matches!(
1120            self.current_token(),
1121            Token::LeftParen | Token::LeftBracket | Token::Dot
1122        )
1123    }
1124
1125    // Placeholder methods for complex parsing
1126    fn parse_type_parameters(&mut self) -> Result<Vec<TypeParameter>> {
1127        if self.current_token() == &Token::LessThan {
1128            self.advance();
1129            let mut type_parameters = Vec::new();
1130
1131            while self.current_token() != &Token::GreaterThan {
1132                let name = self.expect_identifier()?;
1133                let constraint =
1134                    if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
1135                        self.advance();
1136                        Some(self.parse_type()?)
1137                    } else {
1138                        None
1139                    };
1140
1141                let default_type = if self.current_token() == &Token::Assign {
1142                    self.advance();
1143                    Some(self.parse_type()?)
1144                } else {
1145                    None
1146                };
1147
1148                type_parameters.push(TypeParameter {
1149                    name,
1150                    constraint: constraint.map(Box::new),
1151                    default: default_type.map(Box::new),
1152                });
1153
1154                if self.current_token() == &Token::Comma {
1155                    self.advance();
1156                }
1157            }
1158
1159            self.expect_token(&Token::GreaterThan)?;
1160            Ok(type_parameters)
1161        } else {
1162            Ok(Vec::new())
1163        }
1164    }
1165
1166    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
1167        self.expect_token(&Token::LeftParen)?;
1168        let mut parameters = Vec::new();
1169
1170        while self.current_token() != &Token::RightParen {
1171            // Handle access modifiers on parameters (TypeScript feature)
1172            let mut _modifiers = Vec::new();
1173            while let Token::Keyword(keyword) = self.current_token() {
1174                match keyword {
1175                    crate::lexer::Keyword::Public | 
1176                    crate::lexer::Keyword::Private | 
1177                    crate::lexer::Keyword::Protected | 
1178                    crate::lexer::Keyword::Readonly => {
1179                        _modifiers.push(keyword.clone());
1180                        self.advance();
1181                    }
1182                    _ => break,
1183                }
1184            }
1185            
1186            let name = self.expect_identifier()?;
1187            let optional = if self.current_token() == &Token::QuestionMark {
1188                self.advance();
1189                true
1190            } else {
1191                false
1192            };
1193
1194            let type_annotation = if self.current_token() == &Token::Colon {
1195                self.advance();
1196                Some(self.parse_type()?)
1197            } else {
1198                None
1199            };
1200
1201            let initializer = if self.current_token() == &Token::Assign {
1202                self.advance();
1203                Some(self.parse_expression()?)
1204            } else {
1205                None
1206            };
1207
1208            parameters.push(Parameter {
1209                name,
1210                optional,
1211                type_: type_annotation.map(Box::new),
1212                initializer,
1213                rest: false,
1214            });
1215
1216            if self.current_token() == &Token::Comma {
1217                self.advance();
1218            }
1219        }
1220
1221        self.expect_token(&Token::RightParen)?;
1222        Ok(parameters)
1223    }
1224    
1225    fn parse_parameter_list(&mut self) -> Result<Vec<Parameter>> {
1226        let mut parameters = Vec::new();
1227
1228        while self.current_token() != &Token::RightParen {
1229            // Handle access modifiers on parameters (TypeScript feature)
1230            let mut _modifiers = Vec::new();
1231            while let Token::Keyword(keyword) = self.current_token() {
1232                match keyword {
1233                    crate::lexer::Keyword::Public | 
1234                    crate::lexer::Keyword::Private | 
1235                    crate::lexer::Keyword::Protected | 
1236                    crate::lexer::Keyword::Readonly => {
1237                        _modifiers.push(keyword.clone());
1238                        self.advance();
1239                    }
1240                    _ => break,
1241                }
1242            }
1243            
1244            let name = self.expect_identifier()?;
1245            let optional = if self.current_token() == &Token::QuestionMark {
1246                self.advance();
1247                true
1248            } else {
1249                false
1250            };
1251
1252            let type_annotation = if self.current_token() == &Token::Colon {
1253                self.advance();
1254                Some(self.parse_type()?)
1255            } else {
1256                None
1257            };
1258
1259            let initializer = if self.current_token() == &Token::Assign {
1260                self.advance();
1261                Some(self.parse_expression()?)
1262            } else {
1263                None
1264            };
1265
1266            parameters.push(Parameter {
1267                name,
1268                optional,
1269                type_: type_annotation.map(Box::new),
1270                initializer,
1271                rest: false,
1272            });
1273
1274            if self.current_token() == &Token::Comma {
1275                self.advance();
1276            }
1277        }
1278
1279        Ok(parameters)
1280    }
1281
1282    fn parse_implements(&mut self) -> Result<Vec<Type>> {
1283        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Implements) {
1284            self.advance();
1285            let mut types = Vec::new();
1286
1287            loop {
1288                let type_ = self.parse_type()?;
1289                types.push(type_);
1290
1291                if self.current_token() == &Token::Comma {
1292                    self.advance();
1293                } else {
1294                    break;
1295                }
1296            }
1297
1298            Ok(types)
1299        } else {
1300            Ok(Vec::new())
1301        }
1302    }
1303
1304    fn parse_extends(&mut self) -> Result<Vec<Type>> {
1305        let mut extends = Vec::new();
1306        
1307        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
1308            self.advance(); // consume 'extends'
1309            
1310            // Parse the first extended type
1311            let type_ = self.parse_type()?;
1312            extends.push(type_);
1313            
1314            // Parse additional extended types (comma-separated)
1315            while self.current_token() == &Token::Comma {
1316                self.advance(); // consume ','
1317                let type_ = self.parse_type()?;
1318                extends.push(type_);
1319            }
1320        }
1321        
1322        Ok(extends)
1323    }
1324
1325    fn parse_class_body(&mut self) -> Result<ClassBody> {
1326        self.expect_token(&Token::LeftBrace)?;
1327        let mut members = Vec::new();
1328
1329        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1330            let member = self.parse_class_member()?;
1331            members.push(member);
1332        }
1333
1334        self.expect_token(&Token::RightBrace)?;
1335        Ok(ClassBody { members })
1336    }
1337
1338    fn parse_interface_body(&mut self) -> Result<InterfaceBody> {
1339        self.expect_token(&Token::LeftBrace)?;
1340        let mut members = Vec::new();
1341
1342        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1343            let member = self.parse_interface_member()?;
1344            members.push(member);
1345        }
1346        self.expect_token(&Token::RightBrace)?;
1347        Ok(InterfaceBody { members })
1348    }
1349
1350    fn parse_enum_members(&mut self) -> Result<Vec<EnumMember>> {
1351        self.expect_token(&Token::LeftBrace)?;
1352        let mut members = Vec::new();
1353
1354        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1355            let member = self.parse_enum_member()?;
1356            members.push(member);
1357
1358            if self.current_token() == &Token::Comma {
1359                self.advance();
1360            }
1361        }
1362
1363        self.expect_token(&Token::RightBrace)?;
1364        Ok(members)
1365    }
1366
1367    fn parse_import_specifiers(&mut self) -> Result<Vec<ImportSpecifier>> {
1368        let mut specifiers = Vec::new();
1369
1370        if self.current_token() == &Token::LeftBrace {
1371            self.advance(); // consume '{'
1372
1373            while self.current_token() != &Token::RightBrace {
1374                let name = self.expect_identifier()?;
1375                specifiers.push(ImportSpecifier::Named(NamedImportSpecifier {
1376                    imported: name.clone(),
1377                    name,
1378                }));
1379
1380                if self.current_token() == &Token::Comma {
1381                    self.advance();
1382                }
1383            }
1384
1385            self.expect_token(&Token::RightBrace)?; // consume '}'
1386        } else {
1387            // Default import
1388            let name = self.expect_identifier()?;
1389            specifiers.push(ImportSpecifier::Default(DefaultImportSpecifier { name }));
1390        }
1391
1392        Ok(specifiers)
1393    }
1394
1395    fn parse_arguments(&mut self) -> Result<Vec<Expression>> {
1396        let mut arguments = Vec::new();
1397
1398        while self.current_token() != &Token::RightParen {
1399            let argument = self.parse_expression()?;
1400            arguments.push(argument);
1401
1402            if self.current_token() == &Token::Comma {
1403                self.advance();
1404            } else if self.current_token() != &Token::RightParen {
1405                return Err(CompilerError::parse_error(
1406                    1,
1407                    1,
1408                    "Expected comma or closing parenthesis".to_string(),
1409                ));
1410            }
1411        }
1412
1413        Ok(arguments)
1414    }
1415
1416    fn parse_class_member(&mut self) -> Result<ClassMember> {
1417        let mut modifiers = Vec::new();
1418        
1419        // Parse access modifiers
1420        while let Token::Keyword(keyword) = self.current_token() {
1421            match keyword {
1422                crate::lexer::Keyword::Public => {
1423                    modifiers.push(crate::ast::Modifier::Public);
1424                    self.advance();
1425                }
1426                crate::lexer::Keyword::Private => {
1427                    modifiers.push(crate::ast::Modifier::Private);
1428                    self.advance();
1429                }
1430                crate::lexer::Keyword::Protected => {
1431                    modifiers.push(crate::ast::Modifier::Protected);
1432                    self.advance();
1433                }
1434                crate::lexer::Keyword::Readonly => {
1435                    modifiers.push(crate::ast::Modifier::Readonly);
1436                    self.advance();
1437                }
1438                crate::lexer::Keyword::Static => {
1439                    modifiers.push(crate::ast::Modifier::Static);
1440                    self.advance();
1441                }
1442                _ => break,
1443            }
1444        }
1445
1446        let token = self.current_token().clone();
1447
1448        match token {
1449            Token::Keyword(crate::lexer::Keyword::Get) => {
1450                self.advance();
1451                let name = if let Token::Identifier(name) = self.current_token() {
1452                    let name = name.clone();
1453                    self.advance();
1454                    name
1455                } else {
1456                    return Err(CompilerError::parse_error(
1457                        1,
1458                        1,
1459                        "Expected getter name".to_string(),
1460                    ));
1461                };
1462
1463                let return_type = if self.current_token() == &Token::Colon {
1464                    self.advance();
1465                    Some(self.parse_type()?)
1466                } else {
1467                    None
1468                };
1469
1470                let body = if self.current_token() == &Token::LeftBrace {
1471                    self.parse_block_statement()?
1472                } else {
1473                    return Err(CompilerError::parse_error(
1474                        1,
1475                        1,
1476                        "Expected block statement for getter".to_string(),
1477                    ));
1478                };
1479
1480                Ok(ClassMember::Getter(GetterDeclaration {
1481                    name,
1482                    type_: return_type,
1483                    body: Some(body),
1484                    modifiers,
1485                }))
1486            }
1487            Token::Keyword(crate::lexer::Keyword::Set) => {
1488                self.advance();
1489                let name = if let Token::Identifier(name) = self.current_token() {
1490                    let name = name.clone();
1491                    self.advance();
1492                    name
1493                } else {
1494                    return Err(CompilerError::parse_error(
1495                        1,
1496                        1,
1497                        "Expected setter name".to_string(),
1498                    ));
1499                };
1500
1501                let parameter = if self.current_token() == &Token::LeftParen {
1502                    self.advance();
1503                    let parameters = self.parse_parameters()?;
1504                    if parameters.len() != 1 {
1505                        return Err(CompilerError::parse_error(
1506                            1,
1507                            1,
1508                            "Setter must have exactly one parameter".to_string(),
1509                        ));
1510                    }
1511                    parameters[0].clone()
1512                } else {
1513                    return Err(CompilerError::parse_error(
1514                        1,
1515                        1,
1516                        "Expected setter parameter".to_string(),
1517                    ));
1518                };
1519
1520                let body = if self.current_token() == &Token::LeftBrace {
1521                    self.parse_block_statement()?
1522                } else {
1523                    return Err(CompilerError::parse_error(
1524                        1,
1525                        1,
1526                        "Expected block statement for setter".to_string(),
1527                    ));
1528                };
1529
1530                Ok(ClassMember::Setter(SetterDeclaration {
1531                    name,
1532                    parameter,
1533                    body: Some(body),
1534                    modifiers,
1535                }))
1536            }
1537            Token::Identifier(name) => {
1538                self.advance();
1539
1540                // Check if it's a method or property
1541                if self.current_token() == &Token::LeftParen {
1542                    // It's a method
1543                    let parameters = self.parse_parameters()?;
1544                    let return_type = if self.current_token() == &Token::Colon {
1545                        self.advance();
1546                        Some(self.parse_type()?)
1547                    } else {
1548                        None
1549                    };
1550                    let body = self.parse_block_statement()?;
1551
1552                    Ok(ClassMember::Method(MethodDeclaration {
1553                        name,
1554                        optional: false,
1555                        type_parameters: Vec::new(),
1556                        parameters,
1557                        return_type,
1558                        body: Some(body),
1559                        modifiers,
1560                    }))
1561                } else if self.current_token() == &Token::Colon {
1562                    // It's a property
1563                    self.advance();
1564                    let type_annotation = self.parse_type()?;
1565                    
1566                    let initializer = if self.current_token() == &Token::Assign {
1567                        self.advance();
1568                        Some(self.parse_expression()?)
1569                    } else {
1570                        None
1571                    };
1572                    
1573                    self.expect_token(&Token::Semicolon)?;
1574
1575                    Ok(ClassMember::Property(PropertyDeclaration {
1576                        name,
1577                        optional: false,
1578                        type_: Some(type_annotation),
1579                        initializer,
1580                        modifiers,
1581                    }))
1582                } else {
1583                    // It's a constructor
1584                    if name == "constructor" {
1585                        let parameters = self.parse_parameters()?;
1586                        let body = self.parse_block_statement()?;
1587
1588                        Ok(ClassMember::Constructor(ConstructorDeclaration {
1589                            parameters,
1590                            body: Some(body),
1591                            modifiers: Vec::new(),
1592                        }))
1593                    } else {
1594                        Err(CompilerError::parse_error(
1595                            1,
1596                            1,
1597                            "Unexpected class member".to_string(),
1598                        ))
1599                    }
1600                }
1601            }
1602            _ => Err(CompilerError::parse_error(
1603                1,
1604                1,
1605                "Expected class member".to_string(),
1606            )),
1607        }
1608    }
1609
1610    fn parse_interface_member(&mut self) -> Result<ObjectTypeMember> {
1611        let mut readonly = false;
1612        
1613        // Check for readonly modifier
1614        if let Token::Keyword(crate::lexer::Keyword::Readonly) = self.current_token() {
1615            readonly = true;
1616            self.advance();
1617            
1618            // Check if the next token is also 'readonly' (property name)
1619            if let Token::Keyword(crate::lexer::Keyword::Readonly) = self.current_token() {
1620                // Handle case where readonly is both modifier and property name: readonly readonly: boolean;
1621                let name = "readonly".to_string();
1622                self.advance(); // consume the property name 'readonly'
1623                
1624                if self.current_token() == &Token::Colon {
1625                    // It's a property signature
1626                    self.advance();
1627                    let type_annotation = self.parse_type()?;
1628                    self.expect_token(&Token::Semicolon)?;
1629
1630                    return Ok(ObjectTypeMember::Property(PropertySignature {
1631                        name,
1632                        optional: false,
1633                        type_: Some(type_annotation),
1634                        readonly,
1635                    }));
1636                } else {
1637                    return Err(CompilerError::parse_error(
1638                        1, 1,
1639                        "Expected colon after property name".to_string(),
1640                    ));
1641                }
1642            }
1643        }
1644        
1645        let token = self.current_token().clone();
1646
1647        match token {
1648            Token::LeftParen => {
1649                // It's a call signature: (x: number, y: number): number;
1650                let parameters = self.parse_parameters()?;
1651                let return_type = if self.current_token() == &Token::Colon {
1652                    self.advance();
1653                    Some(self.parse_type()?)
1654                } else {
1655                    None
1656                };
1657                self.expect_token(&Token::Semicolon)?;
1658
1659                Ok(ObjectTypeMember::Method(MethodSignature {
1660                    name: "call".to_string(), // Use a default name for call signatures
1661                    optional: false,
1662                    type_parameters: Vec::new(),
1663                    parameters,
1664                    return_type,
1665                }))
1666            }
1667            Token::Keyword(crate::lexer::Keyword::New) => {
1668                // It's a construct signature: new (name: string): BasicInterface;
1669                self.advance(); // consume 'new'
1670                let parameters = self.parse_parameters()?;
1671                let return_type = if self.current_token() == &Token::Colon {
1672                    self.advance();
1673                    Some(self.parse_type()?)
1674                } else {
1675                    None
1676                };
1677                self.expect_token(&Token::Semicolon)?;
1678
1679                Ok(ObjectTypeMember::Method(MethodSignature {
1680                    name: "constructor".to_string(), // Use a default name for construct signatures
1681                    optional: false,
1682                    type_parameters: Vec::new(),
1683                    parameters,
1684                    return_type,
1685                }))
1686            }
1687            Token::Keyword(crate::lexer::Keyword::Readonly) => {
1688                // Handle case where readonly is the property name (without modifier)
1689                let name = "readonly".to_string();
1690                self.advance();
1691                
1692                if self.current_token() == &Token::Colon {
1693                    // It's a property signature
1694                    self.advance();
1695                    let type_annotation = self.parse_type()?;
1696                    self.expect_token(&Token::Semicolon)?;
1697
1698                    Ok(ObjectTypeMember::Property(PropertySignature {
1699                        name,
1700                        optional: false,
1701                        type_: Some(type_annotation),
1702                        readonly,
1703                    }))
1704                } else {
1705                    Err(CompilerError::parse_error(
1706                        1, 1,
1707                        "Expected colon after property name".to_string(),
1708                    ))
1709                }
1710            }
1711            Token::Identifier(name) => {
1712                self.advance();
1713                
1714                // Check for optional marker
1715                let optional = if self.current_token() == &Token::QuestionMark {
1716                    self.advance();
1717                    true
1718                } else {
1719                    false
1720                };
1721
1722                if self.current_token() == &Token::LeftParen {
1723                    // It's a method signature
1724                    let parameters = self.parse_parameters()?;
1725                    let return_type = if self.current_token() == &Token::Colon {
1726                        self.advance();
1727                        Some(self.parse_type()?)
1728                    } else {
1729                        None
1730                    };
1731                    self.expect_token(&Token::Semicolon)?;
1732
1733                    Ok(ObjectTypeMember::Method(MethodSignature {
1734                        name,
1735                        optional,
1736                        type_parameters: Vec::new(),
1737                        parameters,
1738                        return_type,
1739                    }))
1740                } else if self.current_token() == &Token::Colon {
1741                    // It's a property signature
1742                    self.advance();
1743                    let type_annotation = self.parse_type()?;
1744                    self.expect_token(&Token::Semicolon)?;
1745
1746                    Ok(ObjectTypeMember::Property(PropertySignature {
1747                        name,
1748                        optional,
1749                        type_: Some(type_annotation),
1750                        readonly,
1751                    }))
1752                } else {
1753                    Err(CompilerError::parse_error(
1754                        1,
1755                        1,
1756                        "Expected method or property signature".to_string(),
1757                    ))
1758                }
1759            }
1760            Token::LeftBracket => {
1761                // It's an index signature: [key: string]: any;
1762                self.advance(); // consume '['
1763                let key_name = match self.current_token() {
1764                    Token::Identifier(name) => {
1765                        let name = name.clone();
1766                        self.advance();
1767                        name
1768                    }
1769                    Token::Keyword(crate::lexer::Keyword::Key) => {
1770                        self.advance();
1771                        "key".to_string()
1772                    }
1773                    _ => return Err(CompilerError::parse_error(
1774                        1, 1,
1775                        "Expected identifier or 'key' in index signature".to_string(),
1776                    ))
1777                };
1778                self.expect_token(&Token::Colon)?;
1779                let key_type = self.parse_type()?;
1780                self.expect_token(&Token::RightBracket)?;
1781                self.expect_token(&Token::Colon)?;
1782                let value_type = self.parse_type()?;
1783                self.expect_token(&Token::Semicolon)?;
1784
1785                Ok(ObjectTypeMember::Index(IndexSignature {
1786                    parameter: Box::new(Parameter {
1787                        name: key_name,
1788                        type_: Some(Box::new(key_type)),
1789                        optional: false,
1790                        initializer: None,
1791                        rest: false,
1792                    }),
1793                    type_: value_type,
1794                    readonly: false,
1795                }))
1796            }
1797            _ => Err(CompilerError::parse_error(
1798                1,
1799                1,
1800                "Expected interface member".to_string(),
1801            )),
1802        }
1803    }
1804
1805    fn parse_enum_member(&mut self) -> Result<EnumMember> {
1806        let name = self.expect_identifier()?;
1807
1808        let initializer = if self.current_token() == &Token::Assign {
1809            self.advance();
1810            Some(self.parse_expression()?)
1811        } else {
1812            None
1813        };
1814
1815        Ok(EnumMember { name, initializer })
1816    }
1817
1818    fn parse_if_statement(&mut self) -> Result<Statement> {
1819        self.expect_keyword()?; // if
1820
1821        self.expect_token(&Token::LeftParen)?;
1822        let test = self.parse_expression()?;
1823        self.expect_token(&Token::RightParen)?;
1824
1825        let consequent = self.parse_statement()?.unwrap();
1826
1827        let alternate = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Else) {
1828            self.advance();
1829            Some(self.parse_statement()?.unwrap())
1830        } else {
1831            None
1832        };
1833
1834        Ok(Statement::IfStatement(Box::new(IfStatement {
1835            condition: test,
1836            consequent: Box::new(consequent),
1837            alternate,
1838        })))
1839    }
1840
1841    fn parse_property_key(&mut self) -> Result<Expression> {
1842        // TODO: Implement property key parsing
1843        self.parse_expression()
1844    }
1845
1846    /// Parse index signature: [key: type]: returnType
1847    fn parse_index_signature(&mut self) -> Result<IndexSignature> {
1848        self.expect_token(&Token::LeftBracket)?;
1849        
1850        let key_name = match self.current_token() {
1851            Token::Identifier(name) => {
1852                let name = name.clone();
1853                self.advance();
1854                name
1855            }
1856            Token::Keyword(Keyword::Key) => {
1857                self.advance();
1858                "key".to_string()
1859            }
1860            _ => {
1861                return Err(CompilerError::parse_error(
1862                    self.position,
1863                    0,
1864                    format!("Expected identifier or 'key', found {:?}", self.current_token()),
1865                ));
1866            }
1867        };
1868        
1869        self.expect_token(&Token::Colon)?;
1870        let key_type = self.parse_type()?;
1871        self.expect_token(&Token::RightBracket)?;
1872        self.expect_token(&Token::Colon)?;
1873        let value_type = self.parse_type()?;
1874        
1875        Ok(IndexSignature {
1876            parameter: Box::new(Parameter {
1877                name: key_name,
1878                type_: Some(Box::new(key_type)),
1879                optional: false,
1880                initializer: None,
1881                rest: false,
1882            }),
1883            type_: value_type,
1884            readonly: false,
1885        })
1886    }
1887
1888    /// Parse mapped type: [P in K] or [P in keyof T]
1889    fn parse_mapped_type(&mut self) -> Result<MappedType> {
1890        // Parse [P in K]: T
1891        self.expect_token(&Token::LeftBracket)?;
1892        
1893        let type_parameter_name = match self.current_token() {
1894            Token::Identifier(name) => {
1895                let name = name.clone();
1896                self.advance();
1897                name
1898            }
1899            Token::Keyword(Keyword::Key) => {
1900                self.advance();
1901                "Key".to_string()
1902            }
1903            _ => {
1904                return Err(CompilerError::parse_error(
1905                    self.position,
1906                    0,
1907                    format!("Expected identifier or Key, found {:?}", self.current_token()),
1908                ));
1909            }
1910        };
1911        let type_parameter = TypeParameter {
1912            name: type_parameter_name.clone(),
1913            constraint: None,
1914            default: None,
1915        };
1916
1917        // Expect 'in' keyword
1918        if self.current_token() == &Token::Keyword(Keyword::In) {
1919            self.advance();
1920        } else {
1921            return Err(CompilerError::parse_error(
1922                self.position,
1923                0,
1924                format!("Expected 'in', found {:?}", self.current_token()),
1925            ));
1926        }
1927        
1928        let constraint_type = self.parse_type()?;
1929        
1930        self.expect_token(&Token::RightBracket)?;
1931        self.expect_token(&Token::Colon)?;
1932        
1933        let value_type = self.parse_type()?;
1934        
1935        // Skip semicolon if present (it's optional in mapped types)
1936        if self.current_token() == &Token::Semicolon {
1937            self.advance();
1938        }
1939        
1940        Ok(MappedType {
1941            type_parameter: Box::new(type_parameter),
1942            constraint: Some(Box::new(constraint_type)),
1943            name_type: None,
1944            type_: Box::new(value_type),
1945            readonly: None,
1946            optional: None,
1947        })
1948    }
1949}
TypeScript_Rust_Compiler/parser.rs

TypeScript_Rust_Compiler/
parser.rs
