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;
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 { tokens, position: 0 }
17    }
18
19    /// Parse the tokens into an AST
20    pub fn parse(&mut self) -> Result<Program> {
21        let mut statements = Vec::new();
22
23        while self.position < self.tokens.len() {
24            if let Some(statement) = self.parse_statement()? {
25                statements.push(statement);
26            } else {
27                break;
28            }
29        }
30
31        Ok(Program { statements })
32    }
33
34    /// Parse a statement
35    fn parse_statement(&mut self) -> Result<Option<Statement>> {
36        if self.position >= self.tokens.len() {
37            return Ok(None);
38        }
39
40        let token = &self.tokens[self.position];
41        let statement = match token {
42            Token::EOF => return Ok(None),
43            Token::Keyword(keyword) => match keyword {
44                crate::lexer::Keyword::Let | crate::lexer::Keyword::Const | crate::lexer::Keyword::Var => {
45                    self.parse_variable_declaration()?
46                }
47                crate::lexer::Keyword::Function => self.parse_function_declaration()?,
48                crate::lexer::Keyword::Class => self.parse_class_declaration()?,
49                crate::lexer::Keyword::Interface => self.parse_interface_declaration()?,
50                crate::lexer::Keyword::Type => self.parse_type_alias()?,
51                crate::lexer::Keyword::Enum => self.parse_enum_declaration()?,
52                crate::lexer::Keyword::Import => self.parse_import_declaration()?,
53                crate::lexer::Keyword::Export => self.parse_export_declaration()?,
54                crate::lexer::Keyword::Namespace => self.parse_namespace_declaration()?,
55                crate::lexer::Keyword::Module => self.parse_module_declaration()?,
56                crate::lexer::Keyword::Declare => self.parse_declare_statement()?,
57                crate::lexer::Keyword::Return => self.parse_return_statement()?,
58                crate::lexer::Keyword::If => self.parse_if_statement()?,
59                crate::lexer::Keyword::Else => self.parse_expression_statement()?,
60                _ => self.parse_expression_statement()?,
61            },
62            Token::LeftBrace => self.parse_block_statement()?,
63            Token::Semicolon => {
64                self.advance();
65                return self.parse_statement();
66            }
67            _ => self.parse_expression_statement()?,
68        };
69
70        Ok(Some(statement))
71    }
72
73    /// Parse variable declaration
74    fn parse_variable_declaration(&mut self) -> Result<Statement> {
75        let keyword = self.expect_keyword()?;
76        let name = self.expect_identifier()?;
77        let type_annotation = if self.current_token() == &Token::Colon {
78            self.advance();
79            Some(self.parse_type()?)
80        } else {
81            None
82        };
83
84        let initializer = if self.current_token() == &Token::Assign {
85            self.advance();
86            Some(self.parse_expression()?)
87        } else {
88            None
89        };
90
91        self.expect_semicolon()?;
92
93        Ok(Statement::VariableDeclaration(VariableDeclaration {
94            keyword,
95            name,
96            type_annotation,
97            initializer,
98        }))
99    }
100
101    /// Parse function declaration
102    fn parse_function_declaration(&mut self) -> Result<Statement> {
103        self.expect_keyword()?; // consume 'function' keyword
104        let name = self.expect_identifier()?;
105        let type_parameters = self.parse_type_parameters()?;
106        let parameters = self.parse_parameters()?;
107        let return_type = if self.current_token() == &Token::Colon {
108            self.advance();
109            Some(self.parse_type()?)
110        } else {
111            None
112        };
113        let body = self.parse_block_statement()?;
114
115        Ok(Statement::FunctionDeclaration(FunctionDeclaration {
116            name,
117            type_parameters,
118            parameters,
119            return_type,
120            body: Box::new(body),
121        }))
122    }
123
124    /// Parse class declaration
125    fn parse_class_declaration(&mut self) -> Result<Statement> {
126        self.expect_keyword()?; // consume 'class' keyword
127        let name = self.expect_identifier()?;
128        let type_parameters = self.parse_type_parameters()?;
129        let extends = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
130            self.advance();
131            Some(self.parse_type()?)
132        } else {
133            None
134        };
135        let implements = self.parse_implements()?;
136        let body = self.parse_class_body()?;
137
138        Ok(Statement::ClassDeclaration(ClassDeclaration {
139            name,
140            type_parameters,
141            extends,
142            implements,
143            body,
144        }))
145    }
146
147    /// Parse interface declaration
148    fn parse_interface_declaration(&mut self) -> Result<Statement> {
149        self.expect_keyword()?; // consume 'interface' keyword
150        let name = self.expect_identifier()?;
151        let type_parameters = self.parse_type_parameters()?;
152        let extends = self.parse_extends()?;
153        let body = self.parse_interface_body()?;
154
155        Ok(Statement::InterfaceDeclaration(InterfaceDeclaration {
156            name,
157            type_parameters,
158            extends,
159            body,
160        }))
161    }
162
163    /// Parse type alias
164    fn parse_type_alias(&mut self) -> Result<Statement> {
165        self.expect_keyword()?; // consume 'type' keyword
166        let name = self.expect_identifier()?;
167        let type_parameters = self.parse_type_parameters()?;
168        self.expect_token(&Token::Assign)?;
169        let type_definition = self.parse_type()?;
170        self.expect_semicolon()?;
171
172        Ok(Statement::TypeAlias(TypeAlias {
173            name,
174            type_parameters,
175            type_definition,
176        }))
177    }
178
179    /// Parse enum declaration
180    fn parse_enum_declaration(&mut self) -> Result<Statement> {
181        self.expect_keyword()?; // consume 'enum' keyword
182        let name = self.expect_identifier()?;
183        let members = self.parse_enum_members()?;
184
185        Ok(Statement::EnumDeclaration(EnumDeclaration { name, members }))
186    }
187
188    /// Parse import declaration
189    fn parse_import_declaration(&mut self) -> Result<Statement> {
190        self.expect_keyword()?; // import
191        let specifiers = self.parse_import_specifiers()?;
192        self.expect_keyword()?; // from
193        let source = self.parse_string_literal()?;
194        self.expect_semicolon()?;
195
196        Ok(Statement::ImportDeclaration(ImportDeclaration {
197            specifiers,
198            source,
199        }))
200    }
201
202    /// Parse export declaration
203    fn parse_export_declaration(&mut self) -> Result<Statement> {
204        // Consume 'export' keyword
205        self.advance();
206        // Parse the specific declaration type directly
207        let token = self.current_token().clone();
208        let declaration = match token {
209            Token::Keyword(crate::lexer::Keyword::Class) => {
210                self.parse_class_declaration()?
211            }
212            Token::Keyword(crate::lexer::Keyword::Interface) => {
213                self.parse_interface_declaration()?
214            }
215            Token::Keyword(crate::lexer::Keyword::Function) => {
216                self.parse_function_declaration()?
217            }
218            Token::Keyword(crate::lexer::Keyword::Const) => {
219                self.parse_variable_declaration()?
220            }
221            Token::Keyword(crate::lexer::Keyword::Let) => {
222                self.parse_variable_declaration()?
223            }
224            Token::Keyword(crate::lexer::Keyword::Var) => {
225                self.parse_variable_declaration()?
226            }
227            Token::Keyword(crate::lexer::Keyword::Enum) => {
228                self.parse_enum_declaration()?
229            }
230            Token::Keyword(crate::lexer::Keyword::Type) => {
231                self.parse_type_alias()?
232            }
233            _ => {
234                return Err(CompilerError::parse_error(
235                    1,
236                    1,
237                    format!("Unexpected token in export declaration: {:?}", token),
238                ))
239            }
240        };
241        Ok(Statement::ExportDeclaration(Box::new(ExportDeclaration { declaration: Box::new(declaration) })))
242    }
243
244    /// Parse namespace declaration
245    fn parse_namespace_declaration(&mut self) -> Result<Statement> {
246        self.expect_keyword()?; // namespace
247        let name = self.expect_identifier()?;
248        let body = self.parse_block_statement()?;
249
250        Ok(Statement::NamespaceDeclaration(NamespaceDeclaration { name, body: Box::new(body) }))
251    }
252
253    /// Parse module declaration
254    fn parse_module_declaration(&mut self) -> Result<Statement> {
255        self.expect_keyword()?; // module
256        let name = self.parse_string_literal()?;
257        let body = self.parse_block_statement()?;
258
259        Ok(Statement::ModuleDeclaration(ModuleDeclaration { name, body: Box::new(body) }))
260    }
261
262    /// Parse declare statement
263    fn parse_declare_statement(&mut self) -> Result<Statement> {
264        self.expect_keyword()?; // declare
265        let declaration = self.parse_statement()?;
266        Ok(Statement::DeclareStatement(Box::new(DeclareStatement { declaration: Box::new(declaration.unwrap()) })))
267    }
268
269    /// Parse return statement
270    fn parse_return_statement(&mut self) -> Result<Statement> {
271        self.expect_keyword()?; // return
272        
273        let argument = if self.current_token() == &Token::Semicolon {
274            None
275        } else {
276            Some(self.parse_expression()?)
277        };
278        
279        // Optional semicolon
280        if self.current_token() == &Token::Semicolon {
281            self.advance();
282        }
283        
284        Ok(Statement::ReturnStatement(ReturnStatement { argument }))
285    }
286
287    /// Parse expression statement
288    fn parse_expression_statement(&mut self) -> Result<Statement> {
289        let expression = self.parse_expression()?;
290        self.expect_semicolon()?;
291        Ok(Statement::ExpressionStatement(ExpressionStatement { expression }))
292    }
293
294    /// Parse block statement
295    fn parse_block_statement(&mut self) -> Result<Statement> {
296        self.expect_token(&Token::LeftBrace)?;
297        let mut statements = Vec::new();
298
299        while self.current_token() != &Token::RightBrace {
300            if let Some(statement) = self.parse_statement()? {
301                statements.push(statement);
302            } else {
303                break;
304            }
305        }
306
307        self.expect_token(&Token::RightBrace)?;
308        Ok(Statement::BlockStatement(BlockStatement { statements }))
309    }
310
311    /// Parse expression
312    fn parse_expression(&mut self) -> Result<Expression> {
313        self.parse_assignment_expression()
314    }
315
316    /// Parse assignment expression
317    fn parse_assignment_expression(&mut self) -> Result<Expression> {
318        let left = self.parse_conditional_expression()?;
319        
320        if self.is_assignment_operator() {
321            let operator = self.current_token().clone();
322            self.advance();
323            let right = self.parse_assignment_expression()?;
324            Ok(Expression::Assignment(AssignmentExpression {
325                left: Box::new(left),
326                operator,
327                right: Box::new(right),
328            }))
329        } else {
330            Ok(left)
331        }
332    }
333
334    /// Parse conditional expression
335    fn parse_conditional_expression(&mut self) -> Result<Expression> {
336        let test = self.parse_logical_or_expression()?;
337        
338        if self.current_token() == &Token::QuestionMark {
339            self.advance();
340            let consequent = self.parse_expression()?;
341            self.expect_token(&Token::Colon)?;
342            let alternate = self.parse_expression()?;
343            Ok(Expression::Conditional(ConditionalExpression {
344                test: Box::new(test),
345                consequent: Box::new(consequent),
346                alternate: Box::new(alternate),
347            }))
348        } else {
349            Ok(test)
350        }
351    }
352
353    /// Parse logical OR expression
354    fn parse_logical_or_expression(&mut self) -> Result<Expression> {
355        let mut left = self.parse_logical_and_expression()?;
356        
357        while self.current_token() == &Token::Or {
358            self.advance();
359            let right = self.parse_logical_and_expression()?;
360            left = Expression::Logical(LogicalExpression {
361                left: Box::new(left),
362                operator: Token::Or,
363                right: Box::new(right),
364            });
365        }
366        
367        Ok(left)
368    }
369
370    /// Parse logical AND expression
371    fn parse_logical_and_expression(&mut self) -> Result<Expression> {
372        let mut left = self.parse_equality_expression()?;
373        
374        while self.current_token() == &Token::And {
375            self.advance();
376            let right = self.parse_equality_expression()?;
377            left = Expression::Logical(LogicalExpression {
378                left: Box::new(left),
379                operator: Token::And,
380                right: Box::new(right),
381            });
382        }
383        
384        Ok(left)
385    }
386
387    /// Parse equality expression
388    fn parse_equality_expression(&mut self) -> Result<Expression> {
389        let mut left = self.parse_relational_expression()?;
390        
391        while self.is_equality_operator() {
392            let operator = self.current_token().clone();
393            self.advance();
394            let right = self.parse_relational_expression()?;
395            left = Expression::Binary(BinaryExpression {
396                left: Box::new(left),
397                operator,
398                right: Box::new(right),
399            });
400        }
401        
402        Ok(left)
403    }
404
405    /// Parse relational expression
406    fn parse_relational_expression(&mut self) -> Result<Expression> {
407        let mut left = self.parse_additive_expression()?;
408        
409        while self.is_relational_operator() {
410            let operator = self.current_token().clone();
411            self.advance();
412            let right = self.parse_additive_expression()?;
413            left = Expression::Binary(BinaryExpression {
414                left: Box::new(left),
415                operator,
416                right: Box::new(right),
417            });
418        }
419        
420        Ok(left)
421    }
422
423    /// Parse additive expression
424    fn parse_additive_expression(&mut self) -> Result<Expression> {
425        let mut left = self.parse_multiplicative_expression()?;
426        
427        while self.is_additive_operator() {
428            let operator = self.current_token().clone();
429            self.advance();
430            let right = self.parse_multiplicative_expression()?;
431            left = Expression::Binary(BinaryExpression {
432                left: Box::new(left),
433                operator,
434                right: Box::new(right),
435            });
436        }
437        
438        Ok(left)
439    }
440
441    /// Parse multiplicative expression
442    fn parse_multiplicative_expression(&mut self) -> Result<Expression> {
443        let mut left = self.parse_unary_expression()?;
444        
445        while self.is_multiplicative_operator() {
446            let operator = self.current_token().clone();
447            self.advance();
448            let right = self.parse_unary_expression()?;
449            left = Expression::Binary(BinaryExpression {
450                left: Box::new(left),
451                operator,
452                right: Box::new(right),
453            });
454        }
455        
456        Ok(left)
457    }
458
459    /// Parse unary expression
460    fn parse_unary_expression(&mut self) -> Result<Expression> {
461        if self.is_unary_operator() {
462            let operator = self.current_token().clone();
463            self.advance();
464            let argument = self.parse_unary_expression()?;
465            Ok(Expression::Unary(UnaryExpression {
466                operator,
467                argument: Box::new(argument),
468            }))
469        } else {
470            self.parse_postfix_expression()
471        }
472    }
473
474    /// Parse postfix expression
475    fn parse_postfix_expression(&mut self) -> Result<Expression> {
476        let mut left = self.parse_primary_expression()?;
477        
478        while self.is_postfix_operator() {
479            match self.current_token() {
480                Token::LeftParen => {
481                    self.advance();
482                    let arguments = self.parse_arguments()?;
483                    self.expect_token(&Token::RightParen)?;
484                    left = Expression::Call(CallExpression {
485                        callee: Box::new(left),
486                        arguments,
487                    });
488                }
489                Token::LeftBracket => {
490                    self.advance();
491                    let index = self.parse_expression()?;
492                    self.expect_token(&Token::RightBracket)?;
493                    left = Expression::Member(MemberExpression {
494                        object: Box::new(left),
495                        property: Box::new(index),
496                        computed: true,
497                    });
498                }
499                Token::Dot => {
500                    self.advance();
501                    let property = self.expect_identifier()?;
502                    left = Expression::Member(MemberExpression {
503                        object: Box::new(left),
504                        property: Box::new(Expression::Identifier(property)),
505                        computed: false,
506                    });
507                }
508                _ => break,
509            }
510        }
511        
512        Ok(left)
513    }
514
515    /// Parse primary expression
516    fn parse_primary_expression(&mut self) -> Result<Expression> {
517        let token = self.current_token().clone();
518        match token {
519            Token::Number(n) => {
520                self.advance();
521                Ok(Expression::Literal(Literal::Number(n)))
522            }
523            Token::String(s) => {
524                self.advance();
525                Ok(Expression::Literal(Literal::String(s)))
526            }
527            Token::TemplateLiteral(s) => {
528                self.advance();
529                Ok(Expression::Literal(Literal::String(s)))
530            }
531            Token::Boolean(b) => {
532                self.advance();
533                Ok(Expression::Literal(Literal::Boolean(b)))
534            }
535            Token::Null => {
536                self.advance();
537                Ok(Expression::Literal(Literal::Null))
538            }
539            Token::Undefined => {
540                self.advance();
541                Ok(Expression::Literal(Literal::Undefined))
542            }
543            Token::Identifier(name) => {
544                self.advance();
545                Ok(Expression::Identifier(name))
546            }
547            Token::Keyword(crate::lexer::Keyword::This) => {
548                self.advance();
549                Ok(Expression::This(ThisExpression))
550            }
551            Token::Keyword(crate::lexer::Keyword::New) => {
552                self.advance();
553                let callee = self.parse_primary_expression()?;
554                let arguments = if self.current_token() == &Token::LeftParen {
555                    self.advance(); // consume '('
556                    let args = self.parse_arguments()?;
557                    self.expect_token(&Token::RightParen)?;
558                    args
559                } else {
560                    Vec::new()
561                };
562                Ok(Expression::New(NewExpression {
563                    callee: Box::new(callee),
564                    arguments,
565                }))
566            }
567            Token::LeftParen => {
568                self.advance();
569                let expression = self.parse_expression()?;
570                self.expect_token(&Token::RightParen)?;
571                Ok(Expression::Parenthesized(ParenthesizedExpression {
572                    expression: Box::new(expression),
573                }))
574            }
575            Token::LeftBrace => self.parse_object_expression(),
576            Token::LeftBracket => self.parse_array_expression(),
577            _ => Err(CompilerError::parse_error(
578                self.position,
579                0,
580                format!("Unexpected token: {:?}", self.current_token()),
581            )),
582        }
583    }
584
585    /// Parse object expression
586    fn parse_object_expression(&mut self) -> Result<Expression> {
587        self.expect_token(&Token::LeftBrace)?;
588        let mut properties = Vec::new();
589
590        while self.current_token() != &Token::RightBrace {
591            let key = self.parse_property_key()?;
592            let value = if self.current_token() == &Token::Colon {
593                self.advance();
594                self.parse_expression()?
595            } else {
596                key.clone()
597            };
598
599            properties.push(ObjectProperty { 
600                key, 
601                value, 
602                shorthand: false, 
603                computed: false, 
604                method: false 
605            });
606
607            if self.current_token() == &Token::Comma {
608                self.advance();
609            }
610        }
611
612        self.expect_token(&Token::RightBrace)?;
613        Ok(Expression::Object(ObjectExpression { properties }))
614    }
615
616    /// Parse array expression
617    fn parse_array_expression(&mut self) -> Result<Expression> {
618        self.expect_token(&Token::LeftBracket)?;
619        let mut elements = Vec::new();
620
621        while self.current_token() != &Token::RightBracket {
622            if self.current_token() == &Token::Comma {
623                self.advance();
624                elements.push(None);
625            } else {
626                elements.push(Some(self.parse_expression()?));
627                if self.current_token() == &Token::Comma {
628                    self.advance();
629                }
630            }
631        }
632
633        self.expect_token(&Token::RightBracket)?;
634        Ok(Expression::Array(ArrayExpression { elements }))
635    }
636
637    /// Parse type
638    fn parse_type(&mut self) -> Result<Type> {
639        let token = self.current_token().clone();
640        match token {
641            Token::Keyword(crate::lexer::Keyword::String) => {
642                self.advance();
643                Ok(Type::String)
644            }
645            Token::Keyword(crate::lexer::Keyword::Number) => {
646                self.advance();
647                Ok(Type::Number)
648            }
649            Token::Keyword(crate::lexer::Keyword::Boolean) => {
650                self.advance();
651                Ok(Type::Boolean)
652            }
653            Token::Keyword(crate::lexer::Keyword::Any) => {
654                self.advance();
655                Ok(Type::Any)
656            }
657            Token::Keyword(crate::lexer::Keyword::Void) => {
658                self.advance();
659                Ok(Type::Void)
660            }
661            Token::Keyword(crate::lexer::Keyword::Never) => {
662                self.advance();
663                Ok(Type::Never)
664            }
665            Token::Keyword(crate::lexer::Keyword::Unknown) => {
666                self.advance();
667                Ok(Type::Unknown)
668            }
669            Token::Identifier(name) => {
670                self.advance();
671                // Check for generic type parameters
672                if self.current_token() == &Token::LessThan {
673                    let type_parameters = self.parse_type_parameters()?;
674                    Ok(Type::GenericNamed {
675                        name: name.to_string(),
676                        type_parameters,
677                    })
678                } else {
679                    Ok(Type::Named(name.to_string()))
680                }
681            }
682            Token::LeftParen => {
683                self.advance();
684                let type_ = self.parse_type()?;
685                self.expect_token(&Token::RightParen)?;
686                Ok(Type::Parenthesized(Box::new(type_)))
687            }
688            _ => Err(CompilerError::parse_error(
689                self.position,
690                0,
691                format!("Unexpected token in type: {:?}", self.current_token()),
692            )),
693        }
694    }
695
696    // Helper methods
697    fn current_token(&self) -> &Token {
698        &self.tokens[self.position]
699    }
700
701    fn advance(&mut self) {
702        if self.position < self.tokens.len() {
703            self.position += 1;
704        }
705    }
706
707    fn expect_token(&mut self, expected: &Token) -> Result<()> {
708        if self.current_token() == expected {
709            self.advance();
710            Ok(())
711        } else {
712            Err(CompilerError::parse_error(
713                self.position,
714                0,
715                format!("Expected {:?}, found {:?}", expected, self.current_token()),
716            ))
717        }
718    }
719
720    fn expect_keyword(&mut self) -> Result<crate::lexer::Keyword> {
721        if let Token::Keyword(keyword) = self.current_token() {
722            let keyword = keyword.clone();
723            self.advance();
724            Ok(keyword)
725        } else {
726            Err(CompilerError::parse_error(
727                self.position,
728                0,
729                format!("Expected keyword, found {:?}", self.current_token()),
730            ))
731        }
732    }
733
734    fn expect_identifier(&mut self) -> Result<String> {
735        if let Token::Identifier(name) = self.current_token() {
736            let name = name.clone();
737            self.advance();
738            Ok(name)
739        } else {
740            Err(CompilerError::parse_error(
741                self.position,
742                0,
743                format!("Expected identifier, found {:?}", self.current_token()),
744            ))
745        }
746    }
747
748    fn expect_semicolon(&mut self) -> Result<()> {
749        self.expect_token(&Token::Semicolon)
750    }
751
752    fn parse_string_literal(&mut self) -> Result<String> {
753        if let Token::String(s) = self.current_token() {
754            let s = s.clone();
755            self.advance();
756            Ok(s)
757        } else {
758            Err(CompilerError::parse_error(
759                self.position,
760                0,
761                format!("Expected string literal, found {:?}", self.current_token()),
762            ))
763        }
764    }
765
766    fn is_assignment_operator(&self) -> bool {
767        matches!(
768            self.current_token(),
769            Token::Assign | Token::PlusAssign | Token::MinusAssign | Token::MultiplyAssign | Token::DivideAssign
770        )
771    }
772
773    fn is_equality_operator(&self) -> bool {
774        matches!(self.current_token(), 
775            Token::Equal | Token::NotEqual | Token::StrictEqual | Token::StrictNotEqual)
776    }
777
778    fn is_relational_operator(&self) -> bool {
779        matches!(
780            self.current_token(),
781            Token::LessThan | Token::GreaterThan | Token::LessEqual | Token::GreaterEqual
782        )
783    }
784
785    fn is_additive_operator(&self) -> bool {
786        matches!(self.current_token(), Token::Plus | Token::Minus)
787    }
788
789    fn is_multiplicative_operator(&self) -> bool {
790        matches!(self.current_token(), Token::Multiply | Token::Divide | Token::Modulo)
791    }
792
793    fn is_unary_operator(&self) -> bool {
794        matches!(self.current_token(), 
795            Token::Plus | Token::Minus | Token::Not | 
796            Token::Keyword(crate::lexer::Keyword::Typeof)
797        )
798    }
799
800    fn is_postfix_operator(&self) -> bool {
801        matches!(
802            self.current_token(),
803            Token::LeftParen | Token::LeftBracket | Token::Dot
804        )
805    }
806
807    // Placeholder methods for complex parsing
808    fn parse_type_parameters(&mut self) -> Result<Vec<TypeParameter>> {
809        if self.current_token() == &Token::LessThan {
810            self.advance();
811            let mut type_parameters = Vec::new();
812            
813            while self.current_token() != &Token::GreaterThan {
814                let name = self.expect_identifier()?;
815                let constraint = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
816                    self.advance();
817                    Some(self.parse_type()?)
818                } else {
819                    None
820                };
821                
822                let default_type = if self.current_token() == &Token::Assign {
823                    self.advance();
824                    Some(self.parse_type()?)
825                } else {
826                    None
827                };
828                
829                type_parameters.push(TypeParameter {
830                    name,
831                    constraint: constraint.map(Box::new),
832                    default: default_type.map(Box::new),
833                });
834                
835                if self.current_token() == &Token::Comma {
836                    self.advance();
837                }
838            }
839            
840            self.expect_token(&Token::GreaterThan)?;
841            Ok(type_parameters)
842        } else {
843            Ok(Vec::new())
844        }
845    }
846
847    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
848        println!("Current token: {:?}", self.current_token());
849        self.expect_token(&Token::LeftParen)?;
850        let mut parameters = Vec::new();
851        
852        while self.current_token() != &Token::RightParen {
853            let name = self.expect_identifier()?;
854            let optional = if self.current_token() == &Token::QuestionMark {
855                self.advance();
856                true
857            } else {
858                false
859            };
860            
861            let type_annotation = if self.current_token() == &Token::Colon {
862                self.advance();
863                Some(self.parse_type()?)
864            } else {
865                None
866            };
867            
868            let initializer = if self.current_token() == &Token::Assign {
869                self.advance();
870                Some(self.parse_expression()?)
871            } else {
872                None
873            };
874            
875            parameters.push(Parameter {
876                name,
877                optional,
878                type_: type_annotation.map(Box::new),
879                initializer,
880                rest: false,
881            });
882            
883            if self.current_token() == &Token::Comma {
884                self.advance();
885            }
886        }
887        
888        self.expect_token(&Token::RightParen)?;
889        Ok(parameters)
890    }
891
892    fn parse_implements(&mut self) -> Result<Vec<Type>> {
893        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Implements) {
894            self.advance();
895            let mut types = Vec::new();
896            
897            loop {
898                let type_ = self.parse_type()?;
899                types.push(type_);
900                
901                if self.current_token() == &Token::Comma {
902                    self.advance();
903                } else {
904                    break;
905                }
906            }
907            
908            Ok(types)
909        } else {
910            Ok(Vec::new())
911        }
912    }
913
914    fn parse_extends(&mut self) -> Result<Vec<Type>> {
915        // TODO: Implement extends parsing
916        Ok(Vec::new())
917    }
918
919    fn parse_class_body(&mut self) -> Result<ClassBody> {
920        self.expect_token(&Token::LeftBrace)?;
921        let mut members = Vec::new();
922        
923        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
924            let member = self.parse_class_member()?;
925            members.push(member);
926        }
927        
928        self.expect_token(&Token::RightBrace)?;
929        Ok(ClassBody { members })
930    }
931
932    fn parse_interface_body(&mut self) -> Result<InterfaceBody> {
933        self.expect_token(&Token::LeftBrace)?;
934        let mut members = Vec::new();
935        
936        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
937            let member = self.parse_interface_member()?;
938            members.push(member);
939        }
940        
941        self.expect_token(&Token::RightBrace)?;
942        Ok(InterfaceBody { members })
943    }
944
945    fn parse_enum_members(&mut self) -> Result<Vec<EnumMember>> {
946        self.expect_token(&Token::LeftBrace)?;
947        let mut members = Vec::new();
948        
949        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
950            let member = self.parse_enum_member()?;
951            members.push(member);
952            
953            if self.current_token() == &Token::Comma {
954                self.advance();
955            }
956        }
957        
958        self.expect_token(&Token::RightBrace)?;
959        Ok(members)
960    }
961
962    fn parse_import_specifiers(&mut self) -> Result<Vec<ImportSpecifier>> {
963        let mut specifiers = Vec::new();
964        
965        if self.current_token() == &Token::LeftBrace {
966            self.advance(); // consume '{'
967            
968            while self.current_token() != &Token::RightBrace {
969                let name = self.expect_identifier()?;
970                specifiers.push(ImportSpecifier::Named(NamedImportSpecifier {
971                    imported: name.clone(),
972                    name: name,
973                }));
974                
975                if self.current_token() == &Token::Comma {
976                    self.advance();
977                }
978            }
979            
980            self.expect_token(&Token::RightBrace)?; // consume '}'
981        } else {
982            // Default import
983            let name = self.expect_identifier()?;
984            specifiers.push(ImportSpecifier::Default(DefaultImportSpecifier {
985                name: name,
986            }));
987        }
988        
989        Ok(specifiers)
990    }
991
992    fn parse_arguments(&mut self) -> Result<Vec<Expression>> {
993        let mut arguments = Vec::new();
994        
995        while self.current_token() != &Token::RightParen {
996            let argument = self.parse_expression()?;
997            arguments.push(argument);
998            
999            if self.current_token() == &Token::Comma {
1000                self.advance();
1001            } else if self.current_token() != &Token::RightParen {
1002                return Err(CompilerError::parse_error(
1003                    1,
1004                    1,
1005                    "Expected comma or closing parenthesis".to_string(),
1006                ));
1007            }
1008        }
1009        
1010        Ok(arguments)
1011    }
1012
1013    fn parse_class_member(&mut self) -> Result<ClassMember> {
1014        let token = self.current_token().clone();
1015        
1016        match token {
1017            Token::Identifier(name) => {
1018                self.advance();
1019                
1020                // Check if it's a method or property
1021                if self.current_token() == &Token::LeftParen {
1022                    // It's a method
1023                    let parameters = self.parse_parameters()?;
1024                    let return_type = if self.current_token() == &Token::Colon {
1025                        self.advance();
1026                        Some(self.parse_type()?)
1027                    } else {
1028                        None
1029                    };
1030                    let body = self.parse_block_statement()?;
1031                    
1032                    Ok(ClassMember::Method(MethodDeclaration {
1033                        name,
1034                        optional: false,
1035                        type_parameters: Vec::new(),
1036                        parameters,
1037                        return_type,
1038                        body: Some(body),
1039                        modifiers: Vec::new(),
1040                    }))
1041                } else if self.current_token() == &Token::Colon {
1042                    // It's a property
1043                    self.advance();
1044                    let type_annotation = self.parse_type()?;
1045                    self.expect_token(&Token::Semicolon)?;
1046                    
1047                    Ok(ClassMember::Property(PropertyDeclaration {
1048                        name,
1049                        optional: false,
1050                        type_: Some(type_annotation),
1051                        initializer: None,
1052                        modifiers: Vec::new(),
1053                    }))
1054                } else {
1055                    // It's a constructor
1056                    if name == "constructor" {
1057                        let parameters = self.parse_parameters()?;
1058                        let body = self.parse_block_statement()?;
1059                        
1060                        Ok(ClassMember::Constructor(ConstructorDeclaration {
1061                            parameters,
1062                            body: Some(body),
1063                            modifiers: Vec::new(),
1064                        }))
1065                    } else {
1066                        Err(CompilerError::parse_error(1, 1, "Unexpected class member".to_string()))
1067                    }
1068                }
1069            }
1070            _ => Err(CompilerError::parse_error(1, 1, "Expected class member".to_string()))
1071        }
1072    }
1073
1074    fn parse_interface_member(&mut self) -> Result<ObjectTypeMember> {
1075        let token = self.current_token().clone();
1076        
1077        match token {
1078            Token::Identifier(name) => {
1079                self.advance();
1080                
1081                if self.current_token() == &Token::LeftParen {
1082                    // It's a method signature
1083                    let parameters = self.parse_parameters()?;
1084                    let return_type = if self.current_token() == &Token::Colon {
1085                        self.advance();
1086                        Some(self.parse_type()?)
1087                    } else {
1088                        None
1089                    };
1090                    self.expect_token(&Token::Semicolon)?;
1091                    
1092                    Ok(ObjectTypeMember::Method(MethodSignature {
1093                        name,
1094                        optional: false,
1095                        type_parameters: Vec::new(),
1096                        parameters,
1097                        return_type,
1098                    }))
1099                } else if self.current_token() == &Token::Colon {
1100                    // It's a property signature
1101                    self.advance();
1102                    let type_annotation = self.parse_type()?;
1103                    self.expect_token(&Token::Semicolon)?;
1104                    
1105                    Ok(ObjectTypeMember::Property(PropertySignature {
1106                        name,
1107                        optional: false,
1108                        type_: Some(type_annotation),
1109                        readonly: false,
1110                    }))
1111                } else {
1112                    Err(CompilerError::parse_error(1, 1, "Expected method or property signature".to_string()))
1113                }
1114            }
1115            _ => Err(CompilerError::parse_error(1, 1, "Expected interface member".to_string()))
1116        }
1117    }
1118
1119    fn parse_enum_member(&mut self) -> Result<EnumMember> {
1120        let name = self.expect_identifier()?;
1121        
1122        let initializer = if self.current_token() == &Token::Assign {
1123            self.advance();
1124            Some(self.parse_expression()?)
1125        } else {
1126            None
1127        };
1128        
1129        Ok(EnumMember {
1130            name,
1131            initializer,
1132        })
1133    }
1134
1135    fn parse_if_statement(&mut self) -> Result<Statement> {
1136        self.expect_keyword()?; // if
1137        
1138        self.expect_token(&Token::LeftParen)?;
1139        let test = self.parse_expression()?;
1140        self.expect_token(&Token::RightParen)?;
1141        
1142        let consequent = self.parse_statement()?.unwrap();
1143        
1144        let alternate = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Else) {
1145            self.advance();
1146            Some(self.parse_statement()?.unwrap())
1147        } else {
1148            None
1149        };
1150        
1151        Ok(Statement::IfStatement(Box::new(IfStatement {
1152            condition: test,
1153            consequent: Box::new(consequent),
1154            alternate,
1155        })))
1156    }
1157
1158    fn parse_property_key(&mut self) -> Result<Expression> {
1159        // TODO: Implement property key parsing
1160        self.parse_expression()
1161    }
1162}
TypeScript_Rust_Compiler/parser.rs

TypeScript_Rust_Compiler/
parser.rs
