1use crate::ast::*;
4use crate::error::{CompilerError, Result};
5use crate::types::TypeMapper;
6
7pub 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 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 pub fn generate(&mut self, program: &Program) -> Result<String> {
36 let mut rust_code = String::new();
37
38 rust_code.push_str(&self.generate_imports());
40 rust_code.push('\n');
41
42 if self.runtime_support {
44 rust_code.push_str(&self.generate_runtime_support());
45 rust_code.push('\n');
46 }
47
48 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 }
99 }
100 }
101
102 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 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 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 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 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 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 }
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 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 }
277 }
278 }
279
280 Ok(format!("pub trait {} {{\n{}\n}}", name, methods.join("\n")))
281 }
282
283 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 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 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 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 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 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(), }
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 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 fn generate_export(&mut self, _export: &ExportDeclaration) -> Result<String> {
388 Ok(String::new())
391 }
392
393 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 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 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 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 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 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 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 Ok("// TODO: Implement statement".to_string())
491 }
492 }
493 }
494
495 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 Ok("// TODO: Implement expression".to_string())
511 }
512 }
513 }
514
515 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 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 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 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 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 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 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 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 fn generate_template_literal(&mut self, template: &TemplateLiteral) -> Result<String> {
601 if template.expressions.is_empty() && !template.quasis.is_empty() {
603 let raw_string = &template.quasis[0].value;
604 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 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 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 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 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}