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_primary_type()?;
868                Ok(Type::String) // keyof T -> string for now
869            }
870            Token::Keyword(crate::lexer::Keyword::Key) => {
871                self.advance();
872                Ok(Type::String) // Key -> string for now
873            }
874            Token::Keyword(crate::lexer::Keyword::Infer) => {
875                self.advance();
876                Ok(Type::Any) // infer -> any for now
877            }
878            Token::Keyword(crate::lexer::Keyword::Null) => {
879                self.advance();
880                Ok(Type::Null) // null -> null for now
881            }
882            Token::Keyword(crate::lexer::Keyword::Undefined) => {
883                self.advance();
884                Ok(Type::Undefined) // undefined -> undefined for now
885            }
886            Token::Identifier(name) => {
887                self.advance();
888                // Check for generic type parameters
889                if self.current_token() == &Token::LessThan {
890                    let type_parameters = self.parse_type_parameters()?;
891                    Ok(Type::GenericNamed {
892                        name: name.to_string(),
893                        type_parameters,
894                    })
895                } else {
896                    Ok(Type::Named(name.to_string()))
897                }
898            }
899            Token::LeftParen => {
900                self.advance();
901                let type_ = self.parse_type()?;
902                self.expect_token(&Token::RightParen)?;
903                Ok(type_)
904            }
905       Token::LeftBrace => {
906           // Parse object type: { prop: type; ... }
907           self.advance(); // consume {
908           let mut members = Vec::new();
909
910           while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
911               // Check for readonly modifier
912               let readonly = if self.current_token() == &Token::Keyword(Keyword::Readonly) {
913                   self.advance(); // consume readonly
914                   true
915               } else {
916                   false
917               };
918
919               let name = self.expect_identifier()?;
920               let optional = if self.current_token() == &Token::QuestionMark {
921                   self.advance();
922                   true
923               } else {
924                   false
925               };
926               self.expect_token(&Token::Colon)?;
927               let type_ = self.parse_type()?;
928
929               members.push(ObjectTypeMember::Property(PropertySignature {
930                   name,
931                   optional,
932                   type_: Some(type_),
933                   readonly,
934               }));
935
936               if self.current_token() == &Token::Semicolon {
937                   self.advance();
938               }
939           }
940
941           self.expect_token(&Token::RightBrace)?;
942           Ok(Type::ObjectType(ObjectType { members }))
943       }
944            _ => Err(CompilerError::parse_error(
945                self.position,
946                0,
947                format!("Unexpected token in type: {:?}", self.current_token()),
948            )),
949        }
950    }
951
952    // Helper methods
953    fn current_token(&self) -> &Token {
954        &self.tokens[self.position]
955    }
956
957    fn advance(&mut self) {
958        if self.position < self.tokens.len() {
959            self.position += 1;
960        }
961    }
962
963    fn expect_token(&mut self, expected: &Token) -> Result<()> {
964        if self.current_token() == expected {
965            self.advance();
966            Ok(())
967        } else {
968            Err(CompilerError::parse_error(
969                self.position,
970                0,
971                format!("Expected {:?}, found {:?}", expected, self.current_token()),
972            ))
973        }
974    }
975
976    fn expect_keyword(&mut self) -> Result<crate::lexer::Keyword> {
977        if let Token::Keyword(keyword) = self.current_token() {
978            let keyword = keyword.clone();
979            self.advance();
980            Ok(keyword)
981        } else {
982            Err(CompilerError::parse_error(
983                self.position,
984                0,
985                format!("Expected keyword, found {:?}", self.current_token()),
986            ))
987        }
988    }
989
990    fn expect_identifier(&mut self) -> Result<String> {
991        if let Token::Identifier(name) = self.current_token() {
992            let name = name.clone();
993            self.advance();
994            Ok(name)
995        } else {
996            Err(CompilerError::parse_error(
997                self.position,
998                0,
999                format!("Expected identifier, found {:?}", self.current_token()),
1000            ))
1001        }
1002    }
1003
1004    fn expect_semicolon(&mut self) -> Result<()> {
1005        self.expect_token(&Token::Semicolon)
1006    }
1007
1008    fn parse_string_literal(&mut self) -> Result<String> {
1009        if let Token::String(s) = self.current_token() {
1010            let s = s.clone();
1011            self.advance();
1012            Ok(s)
1013        } else {
1014            Err(CompilerError::parse_error(
1015                self.position,
1016                0,
1017                format!("Expected string literal, found {:?}", self.current_token()),
1018            ))
1019        }
1020    }
1021
1022    fn is_assignment_operator(&self) -> bool {
1023        matches!(
1024            self.current_token(),
1025            Token::Assign
1026                | Token::PlusAssign
1027                | Token::MinusAssign
1028                | Token::MultiplyAssign
1029                | Token::DivideAssign
1030        )
1031    }
1032
1033    fn is_equality_operator(&self) -> bool {
1034        matches!(
1035            self.current_token(),
1036            Token::Equal | Token::NotEqual | Token::StrictEqual | Token::StrictNotEqual
1037        )
1038    }
1039
1040    fn is_relational_operator(&self) -> bool {
1041        matches!(
1042            self.current_token(),
1043            Token::LessThan | Token::GreaterThan | Token::LessEqual | Token::GreaterEqual
1044        )
1045    }
1046
1047    fn is_additive_operator(&self) -> bool {
1048        matches!(self.current_token(), Token::Plus | Token::Minus)
1049    }
1050
1051    fn is_multiplicative_operator(&self) -> bool {
1052        matches!(
1053            self.current_token(),
1054            Token::Multiply | Token::Divide | Token::Modulo
1055        )
1056    }
1057
1058    fn is_unary_operator(&self) -> bool {
1059        matches!(
1060            self.current_token(),
1061            Token::Plus | Token::Minus | Token::Not | Token::Keyword(crate::lexer::Keyword::Typeof)
1062        )
1063    }
1064
1065    fn is_postfix_operator(&self) -> bool {
1066        matches!(
1067            self.current_token(),
1068            Token::LeftParen | Token::LeftBracket | Token::Dot
1069        )
1070    }
1071
1072    // Placeholder methods for complex parsing
1073    fn parse_type_parameters(&mut self) -> Result<Vec<TypeParameter>> {
1074        if self.current_token() == &Token::LessThan {
1075            self.advance();
1076            let mut type_parameters = Vec::new();
1077
1078            while self.current_token() != &Token::GreaterThan {
1079                let name = self.expect_identifier()?;
1080                let constraint =
1081                    if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
1082                        self.advance();
1083                        Some(self.parse_type()?)
1084                    } else {
1085                        None
1086                    };
1087
1088                let default_type = if self.current_token() == &Token::Assign {
1089                    self.advance();
1090                    Some(self.parse_type()?)
1091                } else {
1092                    None
1093                };
1094
1095                type_parameters.push(TypeParameter {
1096                    name,
1097                    constraint: constraint.map(Box::new),
1098                    default: default_type.map(Box::new),
1099                });
1100
1101                if self.current_token() == &Token::Comma {
1102                    self.advance();
1103                }
1104            }
1105
1106            self.expect_token(&Token::GreaterThan)?;
1107            Ok(type_parameters)
1108        } else {
1109            Ok(Vec::new())
1110        }
1111    }
1112
1113    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
1114        self.expect_token(&Token::LeftParen)?;
1115        let mut parameters = Vec::new();
1116
1117        while self.current_token() != &Token::RightParen {
1118            // Handle access modifiers on parameters (TypeScript feature)
1119            let mut _modifiers = Vec::new();
1120            while let Token::Keyword(keyword) = self.current_token() {
1121                match keyword {
1122                    crate::lexer::Keyword::Public | 
1123                    crate::lexer::Keyword::Private | 
1124                    crate::lexer::Keyword::Protected | 
1125                    crate::lexer::Keyword::Readonly => {
1126                        _modifiers.push(keyword.clone());
1127                        self.advance();
1128                    }
1129                    _ => break,
1130                }
1131            }
1132            
1133            let name = self.expect_identifier()?;
1134            let optional = if self.current_token() == &Token::QuestionMark {
1135                self.advance();
1136                true
1137            } else {
1138                false
1139            };
1140
1141            let type_annotation = if self.current_token() == &Token::Colon {
1142                self.advance();
1143                Some(self.parse_type()?)
1144            } else {
1145                None
1146            };
1147
1148            let initializer = if self.current_token() == &Token::Assign {
1149                self.advance();
1150                Some(self.parse_expression()?)
1151            } else {
1152                None
1153            };
1154
1155            parameters.push(Parameter {
1156                name,
1157                optional,
1158                type_: type_annotation.map(Box::new),
1159                initializer,
1160                rest: false,
1161            });
1162
1163            if self.current_token() == &Token::Comma {
1164                self.advance();
1165            }
1166        }
1167
1168        self.expect_token(&Token::RightParen)?;
1169        Ok(parameters)
1170    }
1171    
1172    fn parse_parameter_list(&mut self) -> Result<Vec<Parameter>> {
1173        let mut parameters = Vec::new();
1174
1175        while self.current_token() != &Token::RightParen {
1176            // Handle access modifiers on parameters (TypeScript feature)
1177            let mut _modifiers = Vec::new();
1178            while let Token::Keyword(keyword) = self.current_token() {
1179                match keyword {
1180                    crate::lexer::Keyword::Public | 
1181                    crate::lexer::Keyword::Private | 
1182                    crate::lexer::Keyword::Protected | 
1183                    crate::lexer::Keyword::Readonly => {
1184                        _modifiers.push(keyword.clone());
1185                        self.advance();
1186                    }
1187                    _ => break,
1188                }
1189            }
1190            
1191            let name = self.expect_identifier()?;
1192            let optional = if self.current_token() == &Token::QuestionMark {
1193                self.advance();
1194                true
1195            } else {
1196                false
1197            };
1198
1199            let type_annotation = if self.current_token() == &Token::Colon {
1200                self.advance();
1201                Some(self.parse_type()?)
1202            } else {
1203                None
1204            };
1205
1206            let initializer = if self.current_token() == &Token::Assign {
1207                self.advance();
1208                Some(self.parse_expression()?)
1209            } else {
1210                None
1211            };
1212
1213            parameters.push(Parameter {
1214                name,
1215                optional,
1216                type_: type_annotation.map(Box::new),
1217                initializer,
1218                rest: false,
1219            });
1220
1221            if self.current_token() == &Token::Comma {
1222                self.advance();
1223            }
1224        }
1225
1226        Ok(parameters)
1227    }
1228
1229    fn parse_implements(&mut self) -> Result<Vec<Type>> {
1230        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Implements) {
1231            self.advance();
1232            let mut types = Vec::new();
1233
1234            loop {
1235                let type_ = self.parse_type()?;
1236                types.push(type_);
1237
1238                if self.current_token() == &Token::Comma {
1239                    self.advance();
1240                } else {
1241                    break;
1242                }
1243            }
1244
1245            Ok(types)
1246        } else {
1247            Ok(Vec::new())
1248        }
1249    }
1250
1251    fn parse_extends(&mut self) -> Result<Vec<Type>> {
1252        let mut extends = Vec::new();
1253        
1254        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
1255            self.advance(); // consume 'extends'
1256            
1257            // Parse the first extended type
1258            let type_ = self.parse_type()?;
1259            extends.push(type_);
1260            
1261            // Parse additional extended types (comma-separated)
1262            while self.current_token() == &Token::Comma {
1263                self.advance(); // consume ','
1264                let type_ = self.parse_type()?;
1265                extends.push(type_);
1266            }
1267        }
1268        
1269        Ok(extends)
1270    }
1271
1272    fn parse_class_body(&mut self) -> Result<ClassBody> {
1273        self.expect_token(&Token::LeftBrace)?;
1274        let mut members = Vec::new();
1275
1276        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1277            let member = self.parse_class_member()?;
1278            members.push(member);
1279        }
1280
1281        self.expect_token(&Token::RightBrace)?;
1282        Ok(ClassBody { members })
1283    }
1284
1285    fn parse_interface_body(&mut self) -> Result<InterfaceBody> {
1286        self.expect_token(&Token::LeftBrace)?;
1287        let mut members = Vec::new();
1288
1289        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1290            let member = self.parse_interface_member()?;
1291            members.push(member);
1292        }
1293        self.expect_token(&Token::RightBrace)?;
1294        Ok(InterfaceBody { members })
1295    }
1296
1297    fn parse_enum_members(&mut self) -> Result<Vec<EnumMember>> {
1298        self.expect_token(&Token::LeftBrace)?;
1299        let mut members = Vec::new();
1300
1301        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1302            let member = self.parse_enum_member()?;
1303            members.push(member);
1304
1305            if self.current_token() == &Token::Comma {
1306                self.advance();
1307            }
1308        }
1309
1310        self.expect_token(&Token::RightBrace)?;
1311        Ok(members)
1312    }
1313
1314    fn parse_import_specifiers(&mut self) -> Result<Vec<ImportSpecifier>> {
1315        let mut specifiers = Vec::new();
1316
1317        if self.current_token() == &Token::LeftBrace {
1318            self.advance(); // consume '{'
1319
1320            while self.current_token() != &Token::RightBrace {
1321                let name = self.expect_identifier()?;
1322                specifiers.push(ImportSpecifier::Named(NamedImportSpecifier {
1323                    imported: name.clone(),
1324                    name,
1325                }));
1326
1327                if self.current_token() == &Token::Comma {
1328                    self.advance();
1329                }
1330            }
1331
1332            self.expect_token(&Token::RightBrace)?; // consume '}'
1333        } else {
1334            // Default import
1335            let name = self.expect_identifier()?;
1336            specifiers.push(ImportSpecifier::Default(DefaultImportSpecifier { name }));
1337        }
1338
1339        Ok(specifiers)
1340    }
1341
1342    fn parse_arguments(&mut self) -> Result<Vec<Expression>> {
1343        let mut arguments = Vec::new();
1344
1345        while self.current_token() != &Token::RightParen {
1346            let argument = self.parse_expression()?;
1347            arguments.push(argument);
1348
1349            if self.current_token() == &Token::Comma {
1350                self.advance();
1351            } else if self.current_token() != &Token::RightParen {
1352                return Err(CompilerError::parse_error(
1353                    1,
1354                    1,
1355                    "Expected comma or closing parenthesis".to_string(),
1356                ));
1357            }
1358        }
1359
1360        Ok(arguments)
1361    }
1362
1363    fn parse_class_member(&mut self) -> Result<ClassMember> {
1364        let mut modifiers = Vec::new();
1365        
1366        // Parse access modifiers
1367        while let Token::Keyword(keyword) = self.current_token() {
1368            match keyword {
1369                crate::lexer::Keyword::Public => {
1370                    modifiers.push(crate::ast::Modifier::Public);
1371                    self.advance();
1372                }
1373                crate::lexer::Keyword::Private => {
1374                    modifiers.push(crate::ast::Modifier::Private);
1375                    self.advance();
1376                }
1377                crate::lexer::Keyword::Protected => {
1378                    modifiers.push(crate::ast::Modifier::Protected);
1379                    self.advance();
1380                }
1381                crate::lexer::Keyword::Readonly => {
1382                    modifiers.push(crate::ast::Modifier::Readonly);
1383                    self.advance();
1384                }
1385                _ => break,
1386            }
1387        }
1388
1389        let token = self.current_token().clone();
1390
1391        match token {
1392            Token::Identifier(name) => {
1393                self.advance();
1394
1395                // Check if it's a method or property
1396                if self.current_token() == &Token::LeftParen {
1397                    // It's a method
1398                    let parameters = self.parse_parameters()?;
1399                    let return_type = if self.current_token() == &Token::Colon {
1400                        self.advance();
1401                        Some(self.parse_type()?)
1402                    } else {
1403                        None
1404                    };
1405                    let body = self.parse_block_statement()?;
1406
1407                    Ok(ClassMember::Method(MethodDeclaration {
1408                        name,
1409                        optional: false,
1410                        type_parameters: Vec::new(),
1411                        parameters,
1412                        return_type,
1413                        body: Some(body),
1414                        modifiers,
1415                    }))
1416                } else if self.current_token() == &Token::Colon {
1417                    // It's a property
1418                    self.advance();
1419                    let type_annotation = self.parse_type()?;
1420                    
1421                    let initializer = if self.current_token() == &Token::Assign {
1422                        self.advance();
1423                        Some(self.parse_expression()?)
1424                    } else {
1425                        None
1426                    };
1427                    
1428                    self.expect_token(&Token::Semicolon)?;
1429
1430                    Ok(ClassMember::Property(PropertyDeclaration {
1431                        name,
1432                        optional: false,
1433                        type_: Some(type_annotation),
1434                        initializer,
1435                        modifiers,
1436                    }))
1437                } else {
1438                    // It's a constructor
1439                    if name == "constructor" {
1440                        let parameters = self.parse_parameters()?;
1441                        let body = self.parse_block_statement()?;
1442
1443                        Ok(ClassMember::Constructor(ConstructorDeclaration {
1444                            parameters,
1445                            body: Some(body),
1446                            modifiers: Vec::new(),
1447                        }))
1448                    } else {
1449                        Err(CompilerError::parse_error(
1450                            1,
1451                            1,
1452                            "Unexpected class member".to_string(),
1453                        ))
1454                    }
1455                }
1456            }
1457            _ => Err(CompilerError::parse_error(
1458                1,
1459                1,
1460                "Expected class member".to_string(),
1461            )),
1462        }
1463    }
1464
1465    fn parse_interface_member(&mut self) -> Result<ObjectTypeMember> {
1466        let mut readonly = false;
1467        
1468        // Check for readonly modifier
1469        if let Token::Keyword(crate::lexer::Keyword::Readonly) = self.current_token() {
1470            readonly = true;
1471            self.advance();
1472            
1473            // Check if the next token is also 'readonly' (property name)
1474            if let Token::Keyword(crate::lexer::Keyword::Readonly) = self.current_token() {
1475                // Handle case where readonly is both modifier and property name: readonly readonly: boolean;
1476                let name = "readonly".to_string();
1477                self.advance(); // consume the property name 'readonly'
1478                
1479                if self.current_token() == &Token::Colon {
1480                    // It's a property signature
1481                    self.advance();
1482                    let type_annotation = self.parse_type()?;
1483                    self.expect_token(&Token::Semicolon)?;
1484
1485                    return Ok(ObjectTypeMember::Property(PropertySignature {
1486                        name,
1487                        optional: false,
1488                        type_: Some(type_annotation),
1489                        readonly,
1490                    }));
1491                } else {
1492                    return Err(CompilerError::parse_error(
1493                        1, 1,
1494                        "Expected colon after property name".to_string(),
1495                    ));
1496                }
1497            }
1498        }
1499        
1500        let token = self.current_token().clone();
1501
1502        match token {
1503            Token::LeftParen => {
1504                // It's a call signature: (x: number, y: number): number;
1505                let parameters = self.parse_parameters()?;
1506                let return_type = if self.current_token() == &Token::Colon {
1507                    self.advance();
1508                    Some(self.parse_type()?)
1509                } else {
1510                    None
1511                };
1512                self.expect_token(&Token::Semicolon)?;
1513
1514                Ok(ObjectTypeMember::Method(MethodSignature {
1515                    name: "call".to_string(), // Use a default name for call signatures
1516                    optional: false,
1517                    type_parameters: Vec::new(),
1518                    parameters,
1519                    return_type,
1520                }))
1521            }
1522            Token::Keyword(crate::lexer::Keyword::New) => {
1523                // It's a construct signature: new (name: string): BasicInterface;
1524                self.advance(); // consume 'new'
1525                let parameters = self.parse_parameters()?;
1526                let return_type = if self.current_token() == &Token::Colon {
1527                    self.advance();
1528                    Some(self.parse_type()?)
1529                } else {
1530                    None
1531                };
1532                self.expect_token(&Token::Semicolon)?;
1533
1534                Ok(ObjectTypeMember::Method(MethodSignature {
1535                    name: "constructor".to_string(), // Use a default name for construct signatures
1536                    optional: false,
1537                    type_parameters: Vec::new(),
1538                    parameters,
1539                    return_type,
1540                }))
1541            }
1542            Token::Keyword(crate::lexer::Keyword::Readonly) => {
1543                // Handle case where readonly is the property name (without modifier)
1544                let name = "readonly".to_string();
1545                self.advance();
1546                
1547                if self.current_token() == &Token::Colon {
1548                    // It's a property signature
1549                    self.advance();
1550                    let type_annotation = self.parse_type()?;
1551                    self.expect_token(&Token::Semicolon)?;
1552
1553                    Ok(ObjectTypeMember::Property(PropertySignature {
1554                        name,
1555                        optional: false,
1556                        type_: Some(type_annotation),
1557                        readonly,
1558                    }))
1559                } else {
1560                    Err(CompilerError::parse_error(
1561                        1, 1,
1562                        "Expected colon after property name".to_string(),
1563                    ))
1564                }
1565            }
1566            Token::Identifier(name) => {
1567                self.advance();
1568                
1569                // Check for optional marker
1570                let optional = if self.current_token() == &Token::QuestionMark {
1571                    self.advance();
1572                    true
1573                } else {
1574                    false
1575                };
1576
1577                if self.current_token() == &Token::LeftParen {
1578                    // It's a method signature
1579                    let parameters = self.parse_parameters()?;
1580                    let return_type = if self.current_token() == &Token::Colon {
1581                        self.advance();
1582                        Some(self.parse_type()?)
1583                    } else {
1584                        None
1585                    };
1586                    self.expect_token(&Token::Semicolon)?;
1587
1588                    Ok(ObjectTypeMember::Method(MethodSignature {
1589                        name,
1590                        optional,
1591                        type_parameters: Vec::new(),
1592                        parameters,
1593                        return_type,
1594                    }))
1595                } else if self.current_token() == &Token::Colon {
1596                    // It's a property signature
1597                    self.advance();
1598                    let type_annotation = self.parse_type()?;
1599                    self.expect_token(&Token::Semicolon)?;
1600
1601                    Ok(ObjectTypeMember::Property(PropertySignature {
1602                        name,
1603                        optional,
1604                        type_: Some(type_annotation),
1605                        readonly,
1606                    }))
1607                } else {
1608                    Err(CompilerError::parse_error(
1609                        1,
1610                        1,
1611                        "Expected method or property signature".to_string(),
1612                    ))
1613                }
1614            }
1615            Token::LeftBracket => {
1616                // It's an index signature: [key: string]: any;
1617                self.advance(); // consume '['
1618                let key_name = match self.current_token() {
1619                    Token::Identifier(name) => {
1620                        let name = name.clone();
1621                        self.advance();
1622                        name
1623                    }
1624                    Token::Keyword(crate::lexer::Keyword::Key) => {
1625                        self.advance();
1626                        "key".to_string()
1627                    }
1628                    _ => return Err(CompilerError::parse_error(
1629                        1, 1,
1630                        "Expected identifier or 'key' in index signature".to_string(),
1631                    ))
1632                };
1633                self.expect_token(&Token::Colon)?;
1634                let key_type = self.parse_type()?;
1635                self.expect_token(&Token::RightBracket)?;
1636                self.expect_token(&Token::Colon)?;
1637                let value_type = self.parse_type()?;
1638                self.expect_token(&Token::Semicolon)?;
1639
1640                Ok(ObjectTypeMember::Index(IndexSignature {
1641                    parameter: Box::new(Parameter {
1642                        name: key_name,
1643                        type_: Some(Box::new(key_type)),
1644                        optional: false,
1645                        initializer: None,
1646                        rest: false,
1647                    }),
1648                    type_: value_type,
1649                    readonly: false,
1650                }))
1651            }
1652            _ => Err(CompilerError::parse_error(
1653                1,
1654                1,
1655                "Expected interface member".to_string(),
1656            )),
1657        }
1658    }
1659
1660    fn parse_enum_member(&mut self) -> Result<EnumMember> {
1661        let name = self.expect_identifier()?;
1662
1663        let initializer = if self.current_token() == &Token::Assign {
1664            self.advance();
1665            Some(self.parse_expression()?)
1666        } else {
1667            None
1668        };
1669
1670        Ok(EnumMember { name, initializer })
1671    }
1672
1673    fn parse_if_statement(&mut self) -> Result<Statement> {
1674        self.expect_keyword()?; // if
1675
1676        self.expect_token(&Token::LeftParen)?;
1677        let test = self.parse_expression()?;
1678        self.expect_token(&Token::RightParen)?;
1679
1680        let consequent = self.parse_statement()?.unwrap();
1681
1682        let alternate = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Else) {
1683            self.advance();
1684            Some(self.parse_statement()?.unwrap())
1685        } else {
1686            None
1687        };
1688
1689        Ok(Statement::IfStatement(Box::new(IfStatement {
1690            condition: test,
1691            consequent: Box::new(consequent),
1692            alternate,
1693        })))
1694    }
1695
1696    fn parse_property_key(&mut self) -> Result<Expression> {
1697        // TODO: Implement property key parsing
1698        self.parse_expression()
1699    }
1700}
TypeScript_Rust_Compiler/parser.rs

TypeScript_Rust_Compiler/
parser.rs
