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

TypeScript_Rust_Compiler/
parser.rs
