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

TypeScript_Rust_Compiler/
parser.rs
