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

TypeScript_Rust_Compiler/
parser.rs
