TypeScript_Rust_Compiler/
generator.rs

1//! Rust code generator for TypeScript AST
2
3use crate::ast::*;
4use crate::error::{CompilerError, Result};
5use crate::types::TypeMapper;
6
7/// Rust code generator
8pub struct CodeGenerator {
9    type_mapper: TypeMapper,
10    imports: Vec<String>,
11    structs: Vec<String>,
12    traits: Vec<String>,
13    functions: Vec<String>,
14    enums: Vec<String>,
15    modules: Vec<String>,
16    runtime_support: bool,
17}
18
19impl CodeGenerator {
20    /// Create a new code generator
21    pub fn new(runtime: bool) -> Self {
22        Self {
23            type_mapper: TypeMapper::new(runtime),
24            imports: Vec::new(),
25            structs: Vec::new(),
26            traits: Vec::new(),
27            functions: Vec::new(),
28            enums: Vec::new(),
29            modules: Vec::new(),
30            runtime_support: runtime,
31        }
32    }
33
34    /// Generate Rust code from TypeScript program
35    pub fn generate(&mut self, program: &Program) -> Result<String> {
36        let mut rust_code = String::new();
37
38        // Generate imports
39        rust_code.push_str(&self.generate_imports());
40        rust_code.push('\n');
41
42        // Generate runtime support if needed
43        if self.runtime_support {
44            rust_code.push_str(&self.generate_runtime_support());
45            rust_code.push('\n');
46        }
47
48        // Process all statements
49        for statement in &program.statements {
50            match statement {
51                Statement::FunctionDeclaration(func) => {
52                    let func_code = self.generate_function(func)?;
53                    self.functions.push(func_code);
54                }
55                Statement::ClassDeclaration(class) => {
56                    let (struct_code, impl_code) = self.generate_class(class)?;
57                    self.structs.push(struct_code);
58                    self.functions.push(impl_code);
59                }
60                Statement::InterfaceDeclaration(interface) => {
61                    let trait_code = self.generate_interface(interface)?;
62                    self.traits.push(trait_code);
63                }
64                Statement::TypeAlias(type_alias) => {
65                    let type_code = self.generate_type_alias(type_alias)?;
66                    self.structs.push(type_code);
67                }
68                Statement::EnumDeclaration(enum_decl) => {
69                    let enum_code = self.generate_enum(enum_decl)?;
70                    self.enums.push(enum_code);
71                }
72                Statement::VariableDeclaration(var) => {
73                    let var_code = self.generate_variable(var)?;
74                    self.functions.push(var_code);
75                }
76                Statement::ImportDeclaration(import) => {
77                    let import_code = self.generate_import(import)?;
78                    self.imports.push(import_code);
79                }
80                Statement::ExportDeclaration(export) => {
81                    let export_code = self.generate_export(export)?;
82                    self.functions.push(export_code);
83                }
84                Statement::NamespaceDeclaration(namespace) => {
85                    let module_code = self.generate_namespace(namespace)?;
86                    self.modules.push(module_code);
87                }
88                Statement::ModuleDeclaration(module) => {
89                    let module_code = self.generate_module(module)?;
90                    self.modules.push(module_code);
91                }
92                Statement::ExpressionStatement(expr_stmt) => {
93                    let expr_code = self.generate_expression(&expr_stmt.expression)?;
94                    self.functions.push(expr_code);
95                }
96                _ => {
97                    // Handle other statement types
98                }
99            }
100        }
101
102        // Combine all generated code in proper order
103        rust_code.push_str(&self.structs.join("\n\n"));
104        rust_code.push('\n');
105        rust_code.push_str(&self.traits.join("\n\n"));
106        rust_code.push('\n');
107        rust_code.push_str(&self.enums.join("\n\n"));
108        rust_code.push('\n');
109        rust_code.push_str(&self.functions.join("\n\n"));
110        rust_code.push('\n');
111        rust_code.push_str(&self.modules.join("\n\n"));
112
113        Ok(rust_code)
114    }
115
116    /// Generate imports
117    fn generate_imports(&self) -> String {
118        let mut imports = vec![
119            "use std::collections::HashMap;".to_string(),
120            "use serde::{Deserialize, Serialize};".to_string(),
121        ];
122
123        if self.runtime_support {
124            imports.push("use std::any::Any;".to_string());
125            imports.push("use std::boxed::Box;".to_string());
126            imports.push("use std::rc::Rc;".to_string());
127            imports.push("use std::sync::Arc;".to_string());
128        }
129
130        imports.extend(self.imports.clone());
131        imports.join("\n")
132    }
133
134    /// Generate runtime support code
135    fn generate_runtime_support(&self) -> String {
136        r#"
137// Runtime support for TypeScript semantics
138pub type Any = Box<dyn Any>;
139pub type Unknown = Box<dyn Any>;
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
142pub struct Symbol {
143    description: Option<String>,
144}
145
146impl Symbol {
147    pub fn new(description: Option<String>) -> Self {
148        Self { description }
149    }
150}
151
152#[derive(Debug, Clone, Serialize, Deserialize)]
153pub enum UnionType<T> {
154    Variant1(T),
155    Variant2(T),
156    Variant3(T),
157}
158
159pub trait TypeScriptObject {
160    fn get_property(&self, key: &str) -> Option<Any>;
161    fn set_property(&mut self, key: &str, value: Any);
162    fn has_property(&self, key: &str) -> bool;
163    fn delete_property(&mut self, key: &str) -> bool;
164}
165
166impl TypeScriptObject for HashMap<String, Any> {
167    fn get_property(&self, key: &str) -> Option<Any> {
168        self.get(key).cloned()
169    }
170
171    fn set_property(&mut self, key: &str, value: Any) {
172        self.insert(key.to_string(), value);
173    }
174
175    fn has_property(&self, key: &str) -> bool {
176        self.contains_key(key)
177    }
178
179    fn delete_property(&mut self, key: &str) -> bool {
180        self.remove(key).is_some()
181    }
182}
183"#
184        .to_string()
185    }
186
187    /// Generate function
188    fn generate_function(&mut self, func: &FunctionDeclaration) -> Result<String> {
189        let name = &func.name;
190        let params = self.generate_parameters(&func.parameters)?;
191        let return_type = if let Some(ref t) = func.return_type {
192            format!(" -> {}", self.type_mapper.map_type(t)?)
193        } else {
194            " -> ()".to_string()
195        };
196
197        let body = self.generate_statement(&func.body)?;
198
199        Ok(format!(
200            "pub fn {}({}){}{{\n    {}\n}}",
201            name, params, return_type, body
202        ))
203    }
204
205    /// Generate class
206    fn generate_class(&mut self, class: &ClassDeclaration) -> Result<(String, String)> {
207        let name = &class.name;
208        let mut fields = Vec::new();
209        let mut methods = Vec::new();
210
211        // Process class body
212        for member in &class.body.members {
213            match member {
214                ClassMember::Property(prop) => {
215                    let field_type = if let Some(ref t) = prop.type_ {
216                        self.type_mapper.map_type(t)?
217                    } else {
218                        "Box<dyn Any>".to_string()
219                    };
220
221                    let field_name = &prop.name;
222                    let field_def = if prop.optional {
223                        format!("    pub {}: Option<{}>", field_name, field_type)
224                    } else {
225                        format!("    pub {}: {}", field_name, field_type)
226                    };
227                    fields.push(field_def);
228                }
229                ClassMember::Method(method) => {
230                    let method_code = self.generate_method(method)?;
231                    methods.push(method_code);
232                }
233                _ => {
234                    // Handle other member types
235                }
236            }
237        }
238
239        let struct_code = format!(
240            "#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct {} {{\n{}\n}}",
241            name,
242            fields.join(",\n")
243        );
244
245        let impl_code = format!("impl {} {{\n{}\n}}", name, methods.join("\n"));
246
247        Ok((struct_code, impl_code))
248    }
249
250    /// Generate interface as trait
251    fn generate_interface(&mut self, interface: &InterfaceDeclaration) -> Result<String> {
252        let name = &interface.name;
253        let mut methods = Vec::new();
254
255        for member in &interface.body.members {
256            match member {
257                ObjectTypeMember::Property(prop) => {
258                    let prop_type = if let Some(ref t) = prop.type_ {
259                        self.type_mapper.map_type(t)?
260                    } else {
261                        "Box<dyn Any>".to_string()
262                    };
263
264                    let getter = format!("    fn get_{}(&self) -> {};", prop.name, prop_type);
265                    let setter =
266                        format!("    fn set_{}(&mut self, value: {});", prop.name, prop_type);
267                    methods.push(getter);
268                    methods.push(setter);
269                }
270                ObjectTypeMember::Method(method) => {
271                    let method_sig = self.generate_method_signature(method)?;
272                    methods.push(format!("    {};", method_sig));
273                }
274                _ => {
275                    // Handle other member types
276                }
277            }
278        }
279
280        Ok(format!("pub trait {} {{\n{}\n}}", name, methods.join("\n")))
281    }
282
283    /// Generate type alias
284    fn generate_type_alias(&mut self, type_alias: &TypeAlias) -> Result<String> {
285        let name = &type_alias.name;
286        let type_def = self.type_mapper.map_type(&type_alias.type_definition)?;
287        Ok(format!("pub type {} = {};", name, type_def))
288    }
289
290    /// Generate enum
291    fn generate_enum(&mut self, enum_decl: &EnumDeclaration) -> Result<String> {
292        let name = &enum_decl.name;
293        let mut variants = Vec::new();
294
295        for member in &enum_decl.members {
296            let variant_name = &member.name;
297            let variant_value = if let Some(ref init) = member.initializer {
298                match init {
299                    Expression::Literal(Literal::String(s)) => format!(" = \"{}\"", s),
300                    Expression::Literal(Literal::Number(n)) => format!(" = {}", n),
301                    _ => String::new(),
302                }
303            } else {
304                String::new()
305            };
306            variants.push(format!("    {}{}", variant_name, variant_value));
307        }
308
309        Ok(format!(
310            "#[derive(Debug, Clone, Serialize, Deserialize)]\npub enum {} {{\n{}\n}}",
311            name,
312            variants.join(",\n")
313        ))
314    }
315
316    /// Generate variable
317    fn generate_variable(&mut self, var: &VariableDeclaration) -> Result<String> {
318        let name = &var.name;
319        let var_type = if let Some(ref t) = var.type_annotation {
320            self.type_mapper.map_type(t)?
321        } else {
322            // Try to infer type from initializer
323            if let Some(ref init) = var.initializer {
324                match init {
325                    Expression::Literal(Literal::String(_)) => "String".to_string(),
326                    Expression::Literal(Literal::Number(_)) => "f64".to_string(),
327                    Expression::Literal(Literal::Boolean(_)) => "bool".to_string(),
328                    Expression::New(new_expr) => {
329                        // Try to get the type from the constructor
330                        if let Expression::Identifier(callee) = &*new_expr.callee {
331                            format!("Box<{}>", callee)
332                        } else {
333                            "Box<dyn Any>".to_string()
334                        }
335                    },
336                    Expression::Call(call) => {
337                        // Try to infer return type from function name
338                        if let Expression::Identifier(callee) = &*call.callee {
339                            match callee.as_str() {
340                                "greet" => "String".to_string(),
341                                "add" => "f64".to_string(),
342                                _ => "f64".to_string(), // Default to f64 for unknown functions
343                            }
344                        } else {
345                            "f64".to_string()
346                        }
347                    },
348                    _ => "Box<dyn Any>".to_string(),
349                }
350            } else {
351                "Box<dyn Any>".to_string()
352            }
353        };
354
355        let initializer = if let Some(ref init) = var.initializer {
356            format!(" = {}", self.generate_expression(init)?)
357        } else {
358            String::new()
359        };
360
361        Ok(format!("let {}: {}{};", name, var_type, initializer))
362    }
363
364    /// Generate import
365    fn generate_import(&mut self, import: &ImportDeclaration) -> Result<String> {
366        let source = &import.source;
367        let mut import_code = format!("use {}::", source);
368
369        for specifier in &import.specifiers {
370            match specifier {
371                ImportSpecifier::Named(named) => {
372                    import_code.push_str(&format!("{} as {}", named.imported, named.name));
373                }
374                ImportSpecifier::Default(default) => {
375                    import_code.push_str(&default.name);
376                }
377                ImportSpecifier::Namespace(namespace) => {
378                    import_code.push_str(&format!("* as {}", namespace.name));
379                }
380            }
381        }
382
383        Ok(import_code)
384    }
385
386    /// Generate export
387    fn generate_export(&mut self, _export: &ExportDeclaration) -> Result<String> {
388        // In Rust, everything is public by default in the module
389        // Exports are handled by the module system
390        Ok(String::new())
391    }
392
393    /// Generate namespace as module
394    fn generate_namespace(&mut self, namespace: &NamespaceDeclaration) -> Result<String> {
395        let name = &namespace.name;
396        let body = self.generate_statement(&namespace.body)?;
397        Ok(format!("pub mod {} {{\n{}\n}}", name, body))
398    }
399
400    /// Generate module
401    fn generate_module(&mut self, module: &ModuleDeclaration) -> Result<String> {
402        let name = &module.name;
403        let body = self.generate_statement(&module.body)?;
404        Ok(format!("pub mod {} {{\n{}\n}}", name, body))
405    }
406
407    /// Generate method
408    fn generate_method(&mut self, method: &MethodDeclaration) -> Result<String> {
409        let name = &method.name;
410        let params = self.generate_parameters(&method.parameters)?;
411        let return_type = if let Some(ref t) = method.return_type {
412            format!(" -> {}", self.type_mapper.map_type(t)?)
413        } else {
414            " -> ()".to_string()
415        };
416
417        let body = if let Some(ref b) = method.body {
418            self.generate_statement(b)?
419        } else {
420            "unimplemented!()".to_string()
421        };
422
423        Ok(format!(
424            "    pub fn {}(&self, {}){}{{\n        {}\n    }}",
425            name, params, return_type, body
426        ))
427    }
428
429    /// Generate method signature
430    fn generate_method_signature(&mut self, method: &MethodSignature) -> Result<String> {
431        let name = &method.name;
432        let params = self.generate_parameters(&method.parameters)?;
433        let return_type = if let Some(ref t) = method.return_type {
434            format!(" -> {}", self.type_mapper.map_type(t)?)
435        } else {
436            " -> ()".to_string()
437        };
438
439        Ok(format!("fn {}(&self, {}){}", name, params, return_type))
440    }
441
442    /// Generate parameters
443    fn generate_parameters(&mut self, parameters: &[Parameter]) -> Result<String> {
444        let mut param_strings = Vec::new();
445
446        for param in parameters {
447            let param_type = if let Some(ref t) = param.type_ {
448                self.type_mapper.map_type(t)?
449            } else {
450                "Box<dyn Any>".to_string()
451            };
452
453            let param_def = if param.optional {
454                format!("{}: Option<{}>", param.name, param_type)
455            } else {
456                format!("{}: {}", param.name, param_type)
457            };
458
459            param_strings.push(param_def);
460        }
461
462        Ok(param_strings.join(", "))
463    }
464
465    /// Generate statement
466    fn generate_statement(&mut self, statement: &Statement) -> Result<String> {
467        match statement {
468            Statement::BlockStatement(block) => {
469                let mut statements = Vec::new();
470                for stmt in &block.statements {
471                    statements.push(self.generate_statement(stmt)?);
472                }
473                Ok(statements.join("\n    "))
474            }
475            Statement::ExpressionStatement(expr_stmt) => {
476                let expr = self.generate_expression(&expr_stmt.expression)?;
477                // Add semicolon for all statements
478                Ok(format!("{};", expr))
479            }
480            Statement::ReturnStatement(ret) => {
481                if let Some(ref arg) = ret.argument {
482                    Ok(format!("return {};", self.generate_expression(arg)?))
483                } else {
484                    Ok("return;".to_string())
485                }
486            }
487            Statement::VariableDeclaration(var) => self.generate_variable(var),
488            _ => {
489                // Handle other statement types
490                Ok("// TODO: Implement statement".to_string())
491            }
492        }
493    }
494
495    /// Generate expression
496    fn generate_expression(&mut self, expression: &Expression) -> Result<String> {
497        match expression {
498            Expression::Literal(literal) => self.generate_literal(literal),
499            Expression::Identifier(ident) => Ok(ident.clone()),
500            Expression::Binary(binary) => self.generate_binary_expression(binary),
501            Expression::Unary(unary) => self.generate_unary_expression(unary),
502            Expression::Call(call) => self.generate_call_expression(call),
503            Expression::Member(member) => self.generate_member_expression(member),
504            Expression::Array(array) => self.generate_array_expression(array),
505            Expression::Object(object) => self.generate_object_expression(object),
506            Expression::Template(template) => self.generate_template_literal(template),
507            Expression::New(new_expr) => self.generate_new_expression(new_expr),
508            _ => {
509                // Handle other expression types
510                Ok("// TODO: Implement expression".to_string())
511            }
512        }
513    }
514
515    /// Generate literal
516    fn generate_literal(&self, literal: &Literal) -> Result<String> {
517        match literal {
518            Literal::String(s) => Ok(format!("\"{}\"", s)),
519            Literal::Number(n) => Ok(n.to_string()),
520            Literal::Boolean(b) => Ok(b.to_string()),
521            Literal::Null => Ok("None".to_string()),
522            Literal::Undefined => Ok("None".to_string()),
523            _ => Ok("// TODO: Implement literal".to_string()),
524        }
525    }
526
527    /// Generate binary expression
528    fn generate_binary_expression(&mut self, binary: &BinaryExpression) -> Result<String> {
529        let left = self.generate_expression(&binary.left)?;
530        let right = self.generate_expression(&binary.right)?;
531        let operator = self.map_operator(&binary.operator)?;
532        Ok(format!("({} {} {})", left, operator, right))
533    }
534
535    /// Generate unary expression
536    fn generate_unary_expression(&mut self, unary: &UnaryExpression) -> Result<String> {
537        let argument = self.generate_expression(&unary.argument)?;
538        let operator = self.map_operator(&unary.operator)?;
539        Ok(format!("{}{}", operator, argument))
540    }
541
542    /// Generate call expression
543    fn generate_call_expression(&mut self, call: &CallExpression) -> Result<String> {
544        let callee = self.generate_expression(&call.callee)?;
545        let mut args = Vec::new();
546        for arg in &call.arguments {
547            args.push(self.generate_expression(arg)?);
548        }
549        
550        // Special handling for console.log
551        if callee == "console.log" {
552            if args.len() == 1 {
553                Ok(format!("println!(\"{{}}\", {});", args[0]))
554            } else {
555                let format_string = args.iter().map(|_| "{}").collect::<Vec<_>>().join(" ");
556                Ok(format!("println!(\"{}\", {});", format_string, args.join(", ")))
557            }
558        } else {
559            Ok(format!("{}({})", callee, args.join(", ")))
560        }
561    }
562
563    /// Generate member expression
564    fn generate_member_expression(&mut self, member: &MemberExpression) -> Result<String> {
565        let object = self.generate_expression(&member.object)?;
566        let property = self.generate_expression(&member.property)?;
567
568        if member.computed {
569            Ok(format!("{}[{}]", object, property))
570        } else {
571            Ok(format!("{}.{}", object, property))
572        }
573    }
574
575    /// Generate array expression
576    fn generate_array_expression(&mut self, array: &ArrayExpression) -> Result<String> {
577        let mut elements = Vec::new();
578        for element in &array.elements {
579            if let Some(expr) = element {
580                elements.push(self.generate_expression(expr)?);
581            } else {
582                elements.push("None".to_string());
583            }
584        }
585        Ok(format!("vec![{}]", elements.join(", ")))
586    }
587
588    /// Generate object expression
589    fn generate_object_expression(&mut self, object: &ObjectExpression) -> Result<String> {
590        let mut fields = Vec::new();
591        for property in &object.properties {
592            let key = self.generate_expression(&property.key)?;
593            let value = self.generate_expression(&property.value)?;
594            fields.push(format!("{}: {}", key, value));
595        }
596        Ok(format!("{{\n        {}\n    }}", fields.join(",\n        ")))
597    }
598
599    /// Generate template literal
600    fn generate_template_literal(&mut self, template: &TemplateLiteral) -> Result<String> {
601        // For now, handle simple template literals without expressions
602        if template.expressions.is_empty() && !template.quasis.is_empty() {
603            let raw_string = &template.quasis[0].value;
604            // Simple string replacement for common patterns
605            if raw_string.contains("${name}") {
606                Ok(format!("format!(\"Hello, {{}}!\", name)"))
607            } else if raw_string == "Hello, ${name}!" {
608                Ok(format!("format!(\"Hello, {{}}!\", name)"))
609            } else {
610                Ok(format!("\"{}\"", raw_string))
611            }
612        } else {
613            // Generate format! macro for template literals with interpolation
614            let mut format_parts = Vec::new();
615            let mut args = Vec::new();
616            
617            for (i, quasi) in template.quasis.iter().enumerate() {
618                format_parts.push(quasi.value.clone());
619                
620                // Add expression if it exists
621                if i < template.expressions.len() {
622                    let expr = self.generate_expression(&template.expressions[i])?;
623                    args.push(expr);
624                    format_parts.push("{}".to_string());
625                }
626            }
627            
628            let format_string = format_parts.join("");
629            if args.is_empty() {
630                Ok(format!("\"{}\"", format_string))
631            } else {
632                Ok(format!("format!(\"{}\", {})", format_string, args.join(", ")))
633            }
634        }
635    }
636
637    /// Generate new expression
638    fn generate_new_expression(&mut self, new_expr: &NewExpression) -> Result<String> {
639        let callee = self.generate_expression(&new_expr.callee)?;
640        let mut args = Vec::new();
641        for arg in &new_expr.arguments {
642            args.push(self.generate_expression(arg)?);
643        }
644        Ok(format!("Box::new({}::new({}))", callee, args.join(", ")))
645    }
646
647    /// Map operator
648    fn map_operator(&self, token: &crate::lexer::Token) -> Result<String> {
649        match token {
650            crate::lexer::Token::Plus => Ok("+".to_string()),
651            crate::lexer::Token::Minus => Ok("-".to_string()),
652            crate::lexer::Token::Multiply => Ok("*".to_string()),
653            crate::lexer::Token::Divide => Ok("/".to_string()),
654            crate::lexer::Token::Equal => Ok("==".to_string()),
655            crate::lexer::Token::NotEqual => Ok("!=".to_string()),
656            crate::lexer::Token::LessThan => Ok("<".to_string()),
657            crate::lexer::Token::GreaterThan => Ok(">".to_string()),
658            crate::lexer::Token::LessEqual => Ok("<=".to_string()),
659            crate::lexer::Token::GreaterEqual => Ok(">=".to_string()),
660            crate::lexer::Token::And => Ok("&&".to_string()),
661            crate::lexer::Token::Or => Ok("||".to_string()),
662            crate::lexer::Token::Not => Ok("!".to_string()),
663            crate::lexer::Token::Assign => Ok("=".to_string()),
664            _ => Err(CompilerError::generation_error(format!(
665                "Unsupported operator: {:?}",
666                token
667            ))),
668        }
669    }
670}