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 mut left_type = self.parse_primary_type()?;
652        
653        // Handle union and intersection types
654        while matches!(self.current_token(), Token::Union | Token::Intersection) {
655            let operator = self.current_token().clone();
656            self.advance();
657            let right_type = self.parse_primary_type()?;
658            
659            left_type = match operator {
660                Token::Union => Type::Union {
661                    left: Box::new(left_type),
662                    right: Box::new(right_type),
663                },
664                Token::Intersection => Type::Intersection {
665                    left: Box::new(left_type),
666                    right: Box::new(right_type),
667                },
668                _ => return Err(CompilerError::parse_error(
669                    1,
670                    1,
671                    "Expected union or intersection operator",
672                )),
673            };
674        }
675        
676        Ok(left_type)
677    }
678    
679    fn parse_primary_type(&mut self) -> Result<Type> {
680        let token = self.current_token().clone();
681        match token {
682            Token::Keyword(crate::lexer::Keyword::String) => {
683                self.advance();
684                Ok(Type::String)
685            }
686            Token::Keyword(crate::lexer::Keyword::Number) => {
687                self.advance();
688                Ok(Type::Number)
689            }
690            Token::Keyword(crate::lexer::Keyword::Boolean) => {
691                self.advance();
692                Ok(Type::Boolean)
693            }
694            Token::Keyword(crate::lexer::Keyword::Any) => {
695                self.advance();
696                Ok(Type::Any)
697            }
698            Token::Keyword(crate::lexer::Keyword::Void) => {
699                self.advance();
700                Ok(Type::Void)
701            }
702            Token::Keyword(crate::lexer::Keyword::Never) => {
703                self.advance();
704                Ok(Type::Never)
705            }
706            Token::Keyword(crate::lexer::Keyword::Unknown) => {
707                self.advance();
708                Ok(Type::Unknown)
709            }
710            Token::Keyword(crate::lexer::Keyword::Array) => {
711                self.advance();
712                if self.current_token() == &Token::LessThan {
713                    self.advance(); // consume <
714                    let element_type = self.parse_primary_type()?;
715                    self.expect_token(&Token::GreaterThan)?;
716                    Ok(Type::Array(Box::new(element_type)))
717                } else {
718                    Ok(Type::Array(Box::new(Type::Any)))
719                }
720            }
721            Token::Keyword(crate::lexer::Keyword::Readonly) => {
722                self.advance();
723                // Parse the type that follows readonly
724                let element_type = self.parse_primary_type()?;
725                // For now, just return the element type (readonly is handled at runtime)
726                Ok(element_type)
727            }
728            Token::Keyword(crate::lexer::Keyword::Keyof) => {
729                self.advance();
730                let target_type = self.parse_primary_type()?;
731                Ok(Type::String) // keyof T -> string for now
732            }
733            Token::Keyword(crate::lexer::Keyword::Key) => {
734                self.advance();
735                Ok(Type::String) // Key -> string for now
736            }
737            Token::Keyword(crate::lexer::Keyword::Infer) => {
738                self.advance();
739                Ok(Type::Any) // infer -> any for now
740            }
741            Token::Keyword(crate::lexer::Keyword::Null) => {
742                self.advance();
743                Ok(Type::Null) // null -> null for now
744            }
745            Token::Identifier(name) => {
746                self.advance();
747                // Check for generic type parameters
748                if self.current_token() == &Token::LessThan {
749                    let type_parameters = self.parse_type_parameters()?;
750                    Ok(Type::GenericNamed {
751                        name: name.to_string(),
752                        type_parameters,
753                    })
754                } else {
755                    Ok(Type::Named(name.to_string()))
756                }
757            }
758            Token::LeftParen => {
759                self.advance();
760                let type_ = self.parse_type()?;
761                self.expect_token(&Token::RightParen)?;
762                Ok(Type::Parenthesized(Box::new(type_)))
763            }
764            _ => Err(CompilerError::parse_error(
765                self.position,
766                0,
767                format!("Unexpected token in type: {:?}", self.current_token()),
768            )),
769        }
770    }
771
772    // Helper methods
773    fn current_token(&self) -> &Token {
774        &self.tokens[self.position]
775    }
776
777    fn advance(&mut self) {
778        if self.position < self.tokens.len() {
779            self.position += 1;
780        }
781    }
782
783    fn expect_token(&mut self, expected: &Token) -> Result<()> {
784        if self.current_token() == expected {
785            self.advance();
786            Ok(())
787        } else {
788            Err(CompilerError::parse_error(
789                self.position,
790                0,
791                format!("Expected {:?}, found {:?}", expected, self.current_token()),
792            ))
793        }
794    }
795
796    fn expect_keyword(&mut self) -> Result<crate::lexer::Keyword> {
797        if let Token::Keyword(keyword) = self.current_token() {
798            let keyword = keyword.clone();
799            self.advance();
800            Ok(keyword)
801        } else {
802            Err(CompilerError::parse_error(
803                self.position,
804                0,
805                format!("Expected keyword, found {:?}", self.current_token()),
806            ))
807        }
808    }
809
810    fn expect_identifier(&mut self) -> Result<String> {
811        if let Token::Identifier(name) = self.current_token() {
812            let name = name.clone();
813            self.advance();
814            Ok(name)
815        } else {
816            Err(CompilerError::parse_error(
817                self.position,
818                0,
819                format!("Expected identifier, found {:?}", self.current_token()),
820            ))
821        }
822    }
823
824    fn expect_semicolon(&mut self) -> Result<()> {
825        self.expect_token(&Token::Semicolon)
826    }
827
828    fn parse_string_literal(&mut self) -> Result<String> {
829        if let Token::String(s) = self.current_token() {
830            let s = s.clone();
831            self.advance();
832            Ok(s)
833        } else {
834            Err(CompilerError::parse_error(
835                self.position,
836                0,
837                format!("Expected string literal, found {:?}", self.current_token()),
838            ))
839        }
840    }
841
842    fn is_assignment_operator(&self) -> bool {
843        matches!(
844            self.current_token(),
845            Token::Assign
846                | Token::PlusAssign
847                | Token::MinusAssign
848                | Token::MultiplyAssign
849                | Token::DivideAssign
850        )
851    }
852
853    fn is_equality_operator(&self) -> bool {
854        matches!(
855            self.current_token(),
856            Token::Equal | Token::NotEqual | Token::StrictEqual | Token::StrictNotEqual
857        )
858    }
859
860    fn is_relational_operator(&self) -> bool {
861        matches!(
862            self.current_token(),
863            Token::LessThan | Token::GreaterThan | Token::LessEqual | Token::GreaterEqual
864        )
865    }
866
867    fn is_additive_operator(&self) -> bool {
868        matches!(self.current_token(), Token::Plus | Token::Minus)
869    }
870
871    fn is_multiplicative_operator(&self) -> bool {
872        matches!(
873            self.current_token(),
874            Token::Multiply | Token::Divide | Token::Modulo
875        )
876    }
877
878    fn is_unary_operator(&self) -> bool {
879        matches!(
880            self.current_token(),
881            Token::Plus | Token::Minus | Token::Not | Token::Keyword(crate::lexer::Keyword::Typeof)
882        )
883    }
884
885    fn is_postfix_operator(&self) -> bool {
886        matches!(
887            self.current_token(),
888            Token::LeftParen | Token::LeftBracket | Token::Dot
889        )
890    }
891
892    // Placeholder methods for complex parsing
893    fn parse_type_parameters(&mut self) -> Result<Vec<TypeParameter>> {
894        if self.current_token() == &Token::LessThan {
895            self.advance();
896            let mut type_parameters = Vec::new();
897
898            while self.current_token() != &Token::GreaterThan {
899                let name = self.expect_identifier()?;
900                let constraint =
901                    if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Extends) {
902                        self.advance();
903                        Some(self.parse_type()?)
904                    } else {
905                        None
906                    };
907
908                let default_type = if self.current_token() == &Token::Assign {
909                    self.advance();
910                    Some(self.parse_type()?)
911                } else {
912                    None
913                };
914
915                type_parameters.push(TypeParameter {
916                    name,
917                    constraint: constraint.map(Box::new),
918                    default: default_type.map(Box::new),
919                });
920
921                if self.current_token() == &Token::Comma {
922                    self.advance();
923                }
924            }
925
926            self.expect_token(&Token::GreaterThan)?;
927            Ok(type_parameters)
928        } else {
929            Ok(Vec::new())
930        }
931    }
932
933    fn parse_parameters(&mut self) -> Result<Vec<Parameter>> {
934        println!("Current token: {:?}", self.current_token());
935        self.expect_token(&Token::LeftParen)?;
936        let mut parameters = Vec::new();
937
938        while self.current_token() != &Token::RightParen {
939            let name = self.expect_identifier()?;
940            let optional = if self.current_token() == &Token::QuestionMark {
941                self.advance();
942                true
943            } else {
944                false
945            };
946
947            let type_annotation = if self.current_token() == &Token::Colon {
948                self.advance();
949                Some(self.parse_type()?)
950            } else {
951                None
952            };
953
954            let initializer = if self.current_token() == &Token::Assign {
955                self.advance();
956                Some(self.parse_expression()?)
957            } else {
958                None
959            };
960
961            parameters.push(Parameter {
962                name,
963                optional,
964                type_: type_annotation.map(Box::new),
965                initializer,
966                rest: false,
967            });
968
969            if self.current_token() == &Token::Comma {
970                self.advance();
971            }
972        }
973
974        self.expect_token(&Token::RightParen)?;
975        Ok(parameters)
976    }
977
978    fn parse_implements(&mut self) -> Result<Vec<Type>> {
979        if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Implements) {
980            self.advance();
981            let mut types = Vec::new();
982
983            loop {
984                let type_ = self.parse_type()?;
985                types.push(type_);
986
987                if self.current_token() == &Token::Comma {
988                    self.advance();
989                } else {
990                    break;
991                }
992            }
993
994            Ok(types)
995        } else {
996            Ok(Vec::new())
997        }
998    }
999
1000    fn parse_extends(&mut self) -> Result<Vec<Type>> {
1001        // TODO: Implement extends parsing
1002        Ok(Vec::new())
1003    }
1004
1005    fn parse_class_body(&mut self) -> Result<ClassBody> {
1006        self.expect_token(&Token::LeftBrace)?;
1007        let mut members = Vec::new();
1008
1009        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1010            let member = self.parse_class_member()?;
1011            members.push(member);
1012        }
1013
1014        self.expect_token(&Token::RightBrace)?;
1015        Ok(ClassBody { members })
1016    }
1017
1018    fn parse_interface_body(&mut self) -> Result<InterfaceBody> {
1019        self.expect_token(&Token::LeftBrace)?;
1020        let mut members = Vec::new();
1021
1022        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1023            let member = self.parse_interface_member()?;
1024            members.push(member);
1025        }
1026
1027        self.expect_token(&Token::RightBrace)?;
1028        Ok(InterfaceBody { members })
1029    }
1030
1031    fn parse_enum_members(&mut self) -> Result<Vec<EnumMember>> {
1032        self.expect_token(&Token::LeftBrace)?;
1033        let mut members = Vec::new();
1034
1035        while self.current_token() != &Token::RightBrace && self.current_token() != &Token::EOF {
1036            let member = self.parse_enum_member()?;
1037            members.push(member);
1038
1039            if self.current_token() == &Token::Comma {
1040                self.advance();
1041            }
1042        }
1043
1044        self.expect_token(&Token::RightBrace)?;
1045        Ok(members)
1046    }
1047
1048    fn parse_import_specifiers(&mut self) -> Result<Vec<ImportSpecifier>> {
1049        let mut specifiers = Vec::new();
1050
1051        if self.current_token() == &Token::LeftBrace {
1052            self.advance(); // consume '{'
1053
1054            while self.current_token() != &Token::RightBrace {
1055                let name = self.expect_identifier()?;
1056                specifiers.push(ImportSpecifier::Named(NamedImportSpecifier {
1057                    imported: name.clone(),
1058                    name,
1059                }));
1060
1061                if self.current_token() == &Token::Comma {
1062                    self.advance();
1063                }
1064            }
1065
1066            self.expect_token(&Token::RightBrace)?; // consume '}'
1067        } else {
1068            // Default import
1069            let name = self.expect_identifier()?;
1070            specifiers.push(ImportSpecifier::Default(DefaultImportSpecifier { name }));
1071        }
1072
1073        Ok(specifiers)
1074    }
1075
1076    fn parse_arguments(&mut self) -> Result<Vec<Expression>> {
1077        let mut arguments = Vec::new();
1078
1079        while self.current_token() != &Token::RightParen {
1080            let argument = self.parse_expression()?;
1081            arguments.push(argument);
1082
1083            if self.current_token() == &Token::Comma {
1084                self.advance();
1085            } else if self.current_token() != &Token::RightParen {
1086                return Err(CompilerError::parse_error(
1087                    1,
1088                    1,
1089                    "Expected comma or closing parenthesis".to_string(),
1090                ));
1091            }
1092        }
1093
1094        Ok(arguments)
1095    }
1096
1097    fn parse_class_member(&mut self) -> Result<ClassMember> {
1098        let token = self.current_token().clone();
1099
1100        match token {
1101            Token::Identifier(name) => {
1102                self.advance();
1103
1104                // Check if it's a method or property
1105                if self.current_token() == &Token::LeftParen {
1106                    // It's a method
1107                    let parameters = self.parse_parameters()?;
1108                    let return_type = if self.current_token() == &Token::Colon {
1109                        self.advance();
1110                        Some(self.parse_type()?)
1111                    } else {
1112                        None
1113                    };
1114                    let body = self.parse_block_statement()?;
1115
1116                    Ok(ClassMember::Method(MethodDeclaration {
1117                        name,
1118                        optional: false,
1119                        type_parameters: Vec::new(),
1120                        parameters,
1121                        return_type,
1122                        body: Some(body),
1123                        modifiers: Vec::new(),
1124                    }))
1125                } else if self.current_token() == &Token::Colon {
1126                    // It's a property
1127                    self.advance();
1128                    let type_annotation = self.parse_type()?;
1129                    self.expect_token(&Token::Semicolon)?;
1130
1131                    Ok(ClassMember::Property(PropertyDeclaration {
1132                        name,
1133                        optional: false,
1134                        type_: Some(type_annotation),
1135                        initializer: None,
1136                        modifiers: Vec::new(),
1137                    }))
1138                } else {
1139                    // It's a constructor
1140                    if name == "constructor" {
1141                        let parameters = self.parse_parameters()?;
1142                        let body = self.parse_block_statement()?;
1143
1144                        Ok(ClassMember::Constructor(ConstructorDeclaration {
1145                            parameters,
1146                            body: Some(body),
1147                            modifiers: Vec::new(),
1148                        }))
1149                    } else {
1150                        Err(CompilerError::parse_error(
1151                            1,
1152                            1,
1153                            "Unexpected class member".to_string(),
1154                        ))
1155                    }
1156                }
1157            }
1158            _ => Err(CompilerError::parse_error(
1159                1,
1160                1,
1161                "Expected class member".to_string(),
1162            )),
1163        }
1164    }
1165
1166    fn parse_interface_member(&mut self) -> Result<ObjectTypeMember> {
1167        let token = self.current_token().clone();
1168
1169        match token {
1170            Token::Identifier(name) => {
1171                self.advance();
1172
1173                if self.current_token() == &Token::LeftParen {
1174                    // It's a method signature
1175                    let parameters = self.parse_parameters()?;
1176                    let return_type = if self.current_token() == &Token::Colon {
1177                        self.advance();
1178                        Some(self.parse_type()?)
1179                    } else {
1180                        None
1181                    };
1182                    self.expect_token(&Token::Semicolon)?;
1183
1184                    Ok(ObjectTypeMember::Method(MethodSignature {
1185                        name,
1186                        optional: false,
1187                        type_parameters: Vec::new(),
1188                        parameters,
1189                        return_type,
1190                    }))
1191                } else if self.current_token() == &Token::Colon {
1192                    // It's a property signature
1193                    self.advance();
1194                    let type_annotation = self.parse_type()?;
1195                    self.expect_token(&Token::Semicolon)?;
1196
1197                    Ok(ObjectTypeMember::Property(PropertySignature {
1198                        name,
1199                        optional: false,
1200                        type_: Some(type_annotation),
1201                        readonly: false,
1202                    }))
1203                } else {
1204                    Err(CompilerError::parse_error(
1205                        1,
1206                        1,
1207                        "Expected method or property signature".to_string(),
1208                    ))
1209                }
1210            }
1211            _ => Err(CompilerError::parse_error(
1212                1,
1213                1,
1214                "Expected interface member".to_string(),
1215            )),
1216        }
1217    }
1218
1219    fn parse_enum_member(&mut self) -> Result<EnumMember> {
1220        let name = self.expect_identifier()?;
1221
1222        let initializer = if self.current_token() == &Token::Assign {
1223            self.advance();
1224            Some(self.parse_expression()?)
1225        } else {
1226            None
1227        };
1228
1229        Ok(EnumMember { name, initializer })
1230    }
1231
1232    fn parse_if_statement(&mut self) -> Result<Statement> {
1233        self.expect_keyword()?; // if
1234
1235        self.expect_token(&Token::LeftParen)?;
1236        let test = self.parse_expression()?;
1237        self.expect_token(&Token::RightParen)?;
1238
1239        let consequent = self.parse_statement()?.unwrap();
1240
1241        let alternate = if self.current_token() == &Token::Keyword(crate::lexer::Keyword::Else) {
1242            self.advance();
1243            Some(self.parse_statement()?.unwrap())
1244        } else {
1245            None
1246        };
1247
1248        Ok(Statement::IfStatement(Box::new(IfStatement {
1249            condition: test,
1250            consequent: Box::new(consequent),
1251            alternate,
1252        })))
1253    }
1254
1255    fn parse_property_key(&mut self) -> Result<Expression> {
1256        // TODO: Implement property key parsing
1257        self.parse_expression()
1258    }
1259}
TypeScript_Rust_Compiler/parser.rs

TypeScript_Rust_Compiler/
parser.rs
