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                // Create a simple template literal with one quasi
534                let template = TemplateLiteral {
535                    quasis: vec![TemplateElement {
536                        value: s,
537                        tail: true,
538                    }],
539                    expressions: vec![],
540                };
541                Ok(Expression::Template(template))
542            }
543            Token::Boolean(b) => {
544                self.advance();
545                Ok(Expression::Literal(Literal::Boolean(b)))
546            }
547            Token::Null => {
548                self.advance();
549                Ok(Expression::Literal(Literal::Null))
550            }
551            Token::Undefined => {
552                self.advance();
553                Ok(Expression::Literal(Literal::Undefined))
554            }
555            Token::Identifier(name) => {
556                self.advance();
557                Ok(Expression::Identifier(name))
558            }
559            Token::Keyword(crate::lexer::Keyword::This) => {
560                self.advance();
561                Ok(Expression::This(ThisExpression))
562            }
563            Token::Keyword(crate::lexer::Keyword::New) => {
564                self.advance();
565                let callee = self.parse_primary_expression()?;
566                let arguments = if self.current_token() == &Token::LeftParen {
567                    self.advance(); // consume '('
568                    let args = self.parse_arguments()?;
569                    self.expect_token(&Token::RightParen)?;
570                    args
571                } else {
572                    Vec::new()
573                };
574                Ok(Expression::New(NewExpression {
575                    callee: Box::new(callee),
576                    arguments,
577                }))
578            }
579            Token::LeftParen => {
580                self.advance();
581                let expression = self.parse_expression()?;
582                self.expect_token(&Token::RightParen)?;
583                Ok(Expression::Parenthesized(ParenthesizedExpression {
584                    expression: Box::new(expression),
585                }))
586            }
587            Token::LeftBrace => self.parse_object_expression(),
588            Token::LeftBracket => self.parse_array_expression(),
589            _ => Err(CompilerError::parse_error(
590                self.position,
591                0,
592                format!("Unexpected token: {:?}", self.current_token()),
593            )),
594        }
595    }
596
597    /// Parse object expression
598    fn parse_object_expression(&mut self) -> Result<Expression> {
599        self.expect_token(&Token::LeftBrace)?;
600        let mut properties = Vec::new();
601
602        while self.current_token() != &Token::RightBrace {
603            let key = self.parse_property_key()?;
604            let value = if self.current_token() == &Token::Colon {
605                self.advance();
606                self.parse_expression()?
607            } else {
608                key.clone()
609            };
610
611            properties.push(ObjectProperty {
612                key,
613                value,
614                shorthand: false,
615                computed: false,
616                method: false,
617            });
618
619            if self.current_token() == &Token::Comma {
620                self.advance();
621            }
622        }
623
624        self.expect_token(&Token::RightBrace)?;
625        Ok(Expression::Object(ObjectExpression { properties }))
626    }
627
628    /// Parse array expression
629    fn parse_array_expression(&mut self) -> Result<Expression> {
630        self.expect_token(&Token::LeftBracket)?;
631        let mut elements = Vec::new();
632
633        while self.current_token() != &Token::RightBracket {
634            if self.current_token() == &Token::Comma {
635                self.advance();
636                elements.push(None);
637            } else {
638                elements.push(Some(self.parse_expression()?));
639                if self.current_token() == &Token::Comma {
640                    self.advance();
641                }
642            }
643        }
644
645        self.expect_token(&Token::RightBracket)?;
646        Ok(Expression::Array(ArrayExpression { elements }))
647    }
648
649    /// Parse type
650    fn parse_type(&mut self) -> Result<Type> {
651        let token = self.current_token().clone();
652        match token {
653            Token::Keyword(crate::lexer::Keyword::String) => {
654                self.advance();
655                Ok(Type::String)
656            }
657            Token::Keyword(crate::lexer::Keyword::Number) => {
658                self.advance();
659                Ok(Type::Number)
660            }
661            Token::Keyword(crate::lexer::Keyword::Boolean) => {
662                self.advance();
663                Ok(Type::Boolean)
664            }
665            Token::Keyword(crate::lexer::Keyword::Any) => {
666                self.advance();
667                Ok(Type::Any)
668            }
669            Token::Keyword(crate::lexer::Keyword::Void) => {
670                self.advance();
671                Ok(Type::Void)
672            }
673            Token::Keyword(crate::lexer::Keyword::Never) => {
674                self.advance();
675                Ok(Type::Never)
676            }
677            Token::Keyword(crate::lexer::Keyword::Unknown) => {
678                self.advance();
679                Ok(Type::Unknown)
680            }
681            Token::Identifier(name) => {
682                self.advance();
683                // Check for generic type parameters
684                if self.current_token() == &Token::LessThan {
685                    let type_parameters = self.parse_type_parameters()?;
686                    Ok(Type::GenericNamed {
687                        name: name.to_string(),
688                        type_parameters,
689                    })
690                } else {
691                    Ok(Type::Named(name.to_string()))
692                }
693            }
694            Token::LeftParen => {
695                self.advance();
696                let type_ = self.parse_type()?;
697                self.expect_token(&Token::RightParen)?;
698                Ok(Type::Parenthesized(Box::new(type_)))
699            }
700            _ => Err(CompilerError::parse_error(
701                self.position,
702                0,
703                format!("Unexpected token in type: {:?}", self.current_token()),
704            )),
705        }
706    }
707
708    // Helper methods
709    fn current_token(&self) -> &Token {
710        &self.tokens[self.position]
711    }
712
713    fn advance(&mut self) {
714        if self.position < self.tokens.len() {
715            self.position += 1;
716        }
717    }
718
719    fn expect_token(&mut self, expected: &Token) -> Result<()> {
720        if self.current_token() == expected {
721            self.advance();
722            Ok(())
723        } else {
724            Err(CompilerError::parse_error(
725                self.position,
726                0,
727                format!("Expected {:?}, found {:?}", expected, self.current_token()),
728            ))
729        }
730    }
731
732    fn expect_keyword(&mut self) -> Result<crate::lexer::Keyword> {
733        if let Token::Keyword(keyword) = self.current_token() {
734            let keyword = keyword.clone();
735            self.advance();
736            Ok(keyword)
737        } else {
738            Err(CompilerError::parse_error(
739                self.position,
740                0,
741                format!("Expected keyword, found {:?}", self.current_token()),
742            ))
743        }
744    }
745
746    fn expect_identifier(&mut self) -> Result<String> {
747        if let Token::Identifier(name) = self.current_token() {
748            let name = name.clone();
749            self.advance();
750            Ok(name)
751        } else {
752            Err(CompilerError::parse_error(
753                self.position,
754                0,
755                format!("Expected identifier, found {:?}", self.current_token()),
756            ))
757        }
758    }
759
760    fn expect_semicolon(&mut self) -> Result<()> {
761        self.expect_token(&Token::Semicolon)
762    }
763
764    fn parse_string_literal(&mut self) -> Result<String> {
765        if let Token::String(s) = self.current_token() {
766            let s = s.clone();
767            self.advance();
768            Ok(s)
769        } else {
770            Err(CompilerError::parse_error(
771                self.position,
772                0,
773                format!("Expected string literal, found {:?}", self.current_token()),
774            ))
775        }
776    }
777
778    fn is_assignment_operator(&self) -> bool {
779        matches!(
780            self.current_token(),
781            Token::Assign
782                | Token::PlusAssign
783                | Token::MinusAssign
784                | Token::MultiplyAssign
785                | Token::DivideAssign
786        )
787    }
788
789    fn is_equality_operator(&self) -> bool {
790        matches!(
791            self.current_token(),
792            Token::Equal | Token::NotEqual | Token::StrictEqual | Token::StrictNotEqual
793        )
794    }
795
796    fn is_relational_operator(&self) -> bool {
797        matches!(
798            self.current_token(),
799            Token::LessThan | Token::GreaterThan | Token::LessEqual | Token::GreaterEqual
800        )
801    }
802
803    fn is_additive_operator(&self) -> bool {
804        matches!(self.current_token(), Token::Plus | Token::Minus)
805    }
806
807    fn is_multiplicative_operator(&self) -> bool {
808        matches!(
809            self.current_token(),
810            Token::Multiply | Token::Divide | Token::Modulo
811        )
812    }
813
814    fn is_unary_operator(&self) -> bool {
815        matches!(
816            self.current_token(),
817            Token::Plus | Token::Minus | Token::Not | Token::Keyword(crate::lexer::Keyword::Typeof)
818        )
819    }
820
821    fn is_postfix_operator(&self) -> bool {
822        matches!(
823            self.current_token(),
824            Token::LeftParen | Token::LeftBracket | Token::Dot
825        )
826    }
827
828    // Placeholder methods for complex parsing
829    fn parse_type_parameters(&mut self) -> Result<Vec<TypeParameter>> {
830        if self.current_token() == &Token::LessThan {
831            self.advance();
832            let mut type_parameters = Vec::new();
833
834            while self.current_token() != &Token::GreaterThan {
835                let name = self.expect_identifier()?;
836                let constraint =
837                    if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
838                        self.advance();
839                        Some(self.parse_type()?)
840                    } else {
841                        None
842                    };
843
844                let default_type = if self.current_token() == &Token::Assign {
845                    self.advance();
846                    Some(self.parse_type()?)
847                } else {
848                    None
849                };
850
851                type_parameters.push(TypeParameter {
852                    name,
853                    constraint: constraint.map(Box::new),
854                    default: default_type.map(Box::new),
855                });
856
857                if self.current_token() == &Token::Comma {
858                    self.advance();
859                }
860            }
861
862            self.expect_token(&Token::GreaterThan)?;
863            Ok(type_parameters)
864        } else {
865            Ok(Vec::new())
866        }
867    }
868
869    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
870        println!("Current token: {:?}", self.current_token());
871        self.expect_token(&Token::LeftParen)?;
872        let mut parameters = Vec::new();
873
874        while self.current_token() != &Token::RightParen {
875            let name = self.expect_identifier()?;
876            let optional = if self.current_token() == &Token::QuestionMark {
877                self.advance();
878                true
879            } else {
880                false
881            };
882
883            let type_annotation = if self.current_token() == &Token::Colon {
884                self.advance();
885                Some(self.parse_type()?)
886            } else {
887                None
888            };
889
890            let initializer = if self.current_token() == &Token::Assign {
891                self.advance();
892                Some(self.parse_expression()?)
893            } else {
894                None
895            };
896
897            parameters.push(Parameter {
898                name,
899                optional,
900                type_: type_annotation.map(Box::new),
901                initializer,
902                rest: false,
903            });
904
905            if self.current_token() == &Token::Comma {
906                self.advance();
907            }
908        }
909
910        self.expect_token(&Token::RightParen)?;
911        Ok(parameters)
912    }
913
914    fn parse_implements(&mut self) -> Result<Vec<Type>> {
915        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Implements) {
916            self.advance();
917            let mut types = Vec::new();
918
919            loop {
920                let type_ = self.parse_type()?;
921                types.push(type_);
922
923                if self.current_token() == &Token::Comma {
924                    self.advance();
925                } else {
926                    break;
927                }
928            }
929
930            Ok(types)
931        } else {
932            Ok(Vec::new())
933        }
934    }
935
936    fn parse_extends(&mut self) -> Result<Vec<Type>> {
937        // TODO: Implement extends parsing
938        Ok(Vec::new())
939    }
940
941    fn parse_class_body(&mut self) -> Result<ClassBody> {
942        self.expect_token(&Token::LeftBrace)?;
943        let mut members = Vec::new();
944
945        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
946            let member = self.parse_class_member()?;
947            members.push(member);
948        }
949
950        self.expect_token(&Token::RightBrace)?;
951        Ok(ClassBody { members })
952    }
953
954    fn parse_interface_body(&mut self) -> Result<InterfaceBody> {
955        self.expect_token(&Token::LeftBrace)?;
956        let mut members = Vec::new();
957
958        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
959            let member = self.parse_interface_member()?;
960            members.push(member);
961        }
962
963        self.expect_token(&Token::RightBrace)?;
964        Ok(InterfaceBody { members })
965    }
966
967    fn parse_enum_members(&mut self) -> Result<Vec<EnumMember>> {
968        self.expect_token(&Token::LeftBrace)?;
969        let mut members = Vec::new();
970
971        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
972            let member = self.parse_enum_member()?;
973            members.push(member);
974
975            if self.current_token() == &Token::Comma {
976                self.advance();
977            }
978        }
979
980        self.expect_token(&Token::RightBrace)?;
981        Ok(members)
982    }
983
984    fn parse_import_specifiers(&mut self) -> Result<Vec<ImportSpecifier>> {
985        let mut specifiers = Vec::new();
986
987        if self.current_token() == &Token::LeftBrace {
988            self.advance(); // consume '{'
989
990            while self.current_token() != &Token::RightBrace {
991                let name = self.expect_identifier()?;
992                specifiers.push(ImportSpecifier::Named(NamedImportSpecifier {
993                    imported: name.clone(),
994                    name,
995                }));
996
997                if self.current_token() == &Token::Comma {
998                    self.advance();
999                }
1000            }
1001
1002            self.expect_token(&Token::RightBrace)?; // consume '}'
1003        } else {
1004            // Default import
1005            let name = self.expect_identifier()?;
1006            specifiers.push(ImportSpecifier::Default(DefaultImportSpecifier { name }));
1007        }
1008
1009        Ok(specifiers)
1010    }
1011
1012    fn parse_arguments(&mut self) -> Result<Vec<Expression>> {
1013        let mut arguments = Vec::new();
1014
1015        while self.current_token() != &Token::RightParen {
1016            let argument = self.parse_expression()?;
1017            arguments.push(argument);
1018
1019            if self.current_token() == &Token::Comma {
1020                self.advance();
1021            } else if self.current_token() != &Token::RightParen {
1022                return Err(CompilerError::parse_error(
1023                    1,
1024                    1,
1025                    "Expected comma or closing parenthesis".to_string(),
1026                ));
1027            }
1028        }
1029
1030        Ok(arguments)
1031    }
1032
1033    fn parse_class_member(&mut self) -> Result<ClassMember> {
1034        let token = self.current_token().clone();
1035
1036        match token {
1037            Token::Identifier(name) => {
1038                self.advance();
1039
1040                // Check if it's a method or property
1041                if self.current_token() == &Token::LeftParen {
1042                    // It's a method
1043                    let parameters = self.parse_parameters()?;
1044                    let return_type = if self.current_token() == &Token::Colon {
1045                        self.advance();
1046                        Some(self.parse_type()?)
1047                    } else {
1048                        None
1049                    };
1050                    let body = self.parse_block_statement()?;
1051
1052                    Ok(ClassMember::Method(MethodDeclaration {
1053                        name,
1054                        optional: false,
1055                        type_parameters: Vec::new(),
1056                        parameters,
1057                        return_type,
1058                        body: Some(body),
1059                        modifiers: Vec::new(),
1060                    }))
1061                } else if self.current_token() == &Token::Colon {
1062                    // It's a property
1063                    self.advance();
1064                    let type_annotation = self.parse_type()?;
1065                    self.expect_token(&Token::Semicolon)?;
1066
1067                    Ok(ClassMember::Property(PropertyDeclaration {
1068                        name,
1069                        optional: false,
1070                        type_: Some(type_annotation),
1071                        initializer: None,
1072                        modifiers: Vec::new(),
1073                    }))
1074                } else {
1075                    // It's a constructor
1076                    if name == "constructor" {
1077                        let parameters = self.parse_parameters()?;
1078                        let body = self.parse_block_statement()?;
1079
1080                        Ok(ClassMember::Constructor(ConstructorDeclaration {
1081                            parameters,
1082                            body: Some(body),
1083                            modifiers: Vec::new(),
1084                        }))
1085                    } else {
1086                        Err(CompilerError::parse_error(
1087                            1,
1088                            1,
1089                            "Unexpected class member".to_string(),
1090                        ))
1091                    }
1092                }
1093            }
1094            _ => Err(CompilerError::parse_error(
1095                1,
1096                1,
1097                "Expected class member".to_string(),
1098            )),
1099        }
1100    }
1101
1102    fn parse_interface_member(&mut self) -> Result<ObjectTypeMember> {
1103        let token = self.current_token().clone();
1104
1105        match token {
1106            Token::Identifier(name) => {
1107                self.advance();
1108
1109                if self.current_token() == &Token::LeftParen {
1110                    // It's a method signature
1111                    let parameters = self.parse_parameters()?;
1112                    let return_type = if self.current_token() == &Token::Colon {
1113                        self.advance();
1114                        Some(self.parse_type()?)
1115                    } else {
1116                        None
1117                    };
1118                    self.expect_token(&Token::Semicolon)?;
1119
1120                    Ok(ObjectTypeMember::Method(MethodSignature {
1121                        name,
1122                        optional: false,
1123                        type_parameters: Vec::new(),
1124                        parameters,
1125                        return_type,
1126                    }))
1127                } else if self.current_token() == &Token::Colon {
1128                    // It's a property signature
1129                    self.advance();
1130                    let type_annotation = self.parse_type()?;
1131                    self.expect_token(&Token::Semicolon)?;
1132
1133                    Ok(ObjectTypeMember::Property(PropertySignature {
1134                        name,
1135                        optional: false,
1136                        type_: Some(type_annotation),
1137                        readonly: false,
1138                    }))
1139                } else {
1140                    Err(CompilerError::parse_error(
1141                        1,
1142                        1,
1143                        "Expected method or property signature".to_string(),
1144                    ))
1145                }
1146            }
1147            _ => Err(CompilerError::parse_error(
1148                1,
1149                1,
1150                "Expected interface member".to_string(),
1151            )),
1152        }
1153    }
1154
1155    fn parse_enum_member(&mut self) -> Result<EnumMember> {
1156        let name = self.expect_identifier()?;
1157
1158        let initializer = if self.current_token() == &Token::Assign {
1159            self.advance();
1160            Some(self.parse_expression()?)
1161        } else {
1162            None
1163        };
1164
1165        Ok(EnumMember { name, initializer })
1166    }
1167
1168    fn parse_if_statement(&mut self) -> Result<Statement> {
1169        self.expect_keyword()?; // if
1170
1171        self.expect_token(&Token::LeftParen)?;
1172        let test = self.parse_expression()?;
1173        self.expect_token(&Token::RightParen)?;
1174
1175        let consequent = self.parse_statement()?.unwrap();
1176
1177        let alternate = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Else) {
1178            self.advance();
1179            Some(self.parse_statement()?.unwrap())
1180        } else {
1181            None
1182        };
1183
1184        Ok(Statement::IfStatement(Box::new(IfStatement {
1185            condition: test,
1186            consequent: Box::new(consequent),
1187            alternate,
1188        })))
1189    }
1190
1191    fn parse_property_key(&mut self) -> Result<Expression> {
1192        // TODO: Implement property key parsing
1193        self.parse_expression()
1194    }
1195}
TypeScript_Rust_Compiler/parser.rs

TypeScript_Rust_Compiler/
parser.rs
