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                ClassMember::Constructor(constructor) => {
234                    let constructor_code = self.generate_constructor(constructor, &class.body.members)?;
235                    methods.push(constructor_code);
236                }
237                ClassMember::Getter(getter) => {
238                    let getter_code = self.generate_getter(getter)?;
239                    methods.push(getter_code);
240                }
241                ClassMember::Setter(setter) => {
242                    let setter_code = self.generate_setter(setter)?;
243                    methods.push(setter_code);
244                }
245                _ => {
246                    // Handle other member types
247                }
248            }
249        }
250
251        let struct_code = format!(
252            "#[derive(Debug, Clone, Serialize, Deserialize)]\npub struct {} {{\n{}\n}}",
253            name,
254            fields.join(",\n")
255        );
256
257        let impl_code = format!("impl {} {{\n{}\n}}", name, methods.join("\n"));
258
259        Ok((struct_code, impl_code))
260    }
261
262    /// Generate interface as trait
263    fn generate_interface(&mut self, interface: &InterfaceDeclaration) -> Result<String> {
264        let name = &interface.name;
265        let mut methods = Vec::new();
266
267        for member in &interface.body.members {
268            match member {
269                ObjectTypeMember::Property(prop) => {
270                    let prop_type = if let Some(ref t) = prop.type_ {
271                        self.type_mapper.map_type(t)?
272                    } else {
273                        "Box<dyn Any>".to_string()
274                    };
275
276                    let getter = format!("    fn get_{}(&self) -> {};", prop.name, prop_type);
277                    let setter =
278                        format!("    fn set_{}(&mut self, value: {});", prop.name, prop_type);
279                    methods.push(getter);
280                    methods.push(setter);
281                }
282                ObjectTypeMember::Method(method) => {
283                    let method_sig = self.generate_method_signature(method)?;
284                    methods.push(format!("    {};", method_sig));
285                }
286                _ => {
287                    // Handle other member types
288                }
289            }
290        }
291
292        Ok(format!("pub trait {} {{\n{}\n}}", name, methods.join("\n")))
293    }
294
295    /// Generate type alias
296    fn generate_type_alias(&mut self, type_alias: &TypeAlias) -> Result<String> {
297        let name = &type_alias.name;
298        let type_def = self.type_mapper.map_type(&type_alias.type_definition)?;
299        Ok(format!("pub type {} = {};", name, type_def))
300    }
301
302    /// Generate constructor
303    fn generate_constructor(&mut self, constructor: &ConstructorDeclaration, class_members: &[ClassMember]) -> Result<String> {
304        let mut params = Vec::new();
305        for param in &constructor.parameters {
306            let param_type = if let Some(ref t) = param.type_ {
307                self.type_mapper.map_type(t)?
308            } else {
309                "Box<dyn Any>".to_string()
310            };
311            let param_name = &param.name;
312            params.push(format!("{}: {}", param_name, param_type));
313        }
314        
315        let body = if let Some(ref body) = constructor.body {
316            self.generate_statement(body)?
317        } else {
318            "// Empty constructor".to_string()
319        };
320        
321        // Generate struct initialization
322        let mut field_assignments = Vec::new();
323        for member in class_members {
324            if let ClassMember::Property(prop) = member {
325                if let Some(ref initializer) = prop.initializer {
326                    let init_value = self.generate_expression(initializer)?;
327                    field_assignments.push(format!("            {}: {}", prop.name, init_value));
328                } else {
329                    // Use default value based on type
330                    let default_value = match prop.type_.as_ref() {
331                        Some(t) => match t {
332                            Type::String => "\"\".to_string()".to_string(),
333                            Type::Number => "0".to_string(),
334                            Type::Boolean => "false".to_string(),
335                            _ => "Default::default()".to_string(),
336                        },
337                        None => "Default::default()".to_string(),
338                    };
339                    field_assignments.push(format!("            {}: {}", prop.name, default_value));
340                }
341            }
342        }
343        
344        let initialization = if field_assignments.is_empty() {
345            "        Self {}".to_string()
346        } else {
347            format!("        Self {{\n{}\n        }}", field_assignments.join(",\n"))
348        };
349        
350        Ok(format!("    pub fn new({}) -> Self {{\n{}\n    }}", params.join(", "), initialization))
351    }
352
353    /// Generate getter
354    fn generate_getter(&mut self, getter: &GetterDeclaration) -> Result<String> {
355        let name = &getter.name;
356        let return_type = if let Some(ref t) = getter.type_ {
357            self.type_mapper.map_type(t)?
358        } else {
359            "Box<dyn Any>".to_string()
360        };
361        
362        let body = if let Some(ref body) = getter.body {
363            self.generate_statement(body)?
364        } else {
365            "// Empty getter".to_string()
366        };
367        
368        Ok(format!("    pub fn {}(&self) -> {} {{\n{}\n    }}", name, return_type, body))
369    }
370
371    /// Generate setter
372    fn generate_setter(&mut self, setter: &SetterDeclaration) -> Result<String> {
373        let name = &setter.name;
374        let param_type = if let Some(ref t) = setter.parameter.type_ {
375            self.type_mapper.map_type(t)?
376        } else {
377            "Box<dyn Any>".to_string()
378        };
379        
380        let body = if let Some(ref body) = setter.body {
381            self.generate_statement(body)?
382        } else {
383            "// Empty setter".to_string()
384        };
385        
386        Ok(format!("    pub fn set_{}(&mut self, value: {}) {{\n{}\n    }}", name, param_type, body))
387    }
388
389    /// Generate block statement
390    fn generate_block_statement(&mut self, block: &BlockStatement) -> Result<String> {
391        let mut statements = Vec::new();
392        for stmt in &block.statements {
393            let stmt_code = self.generate_statement(stmt)?;
394            statements.push(stmt_code);
395        }
396        Ok(statements.join("\n"))
397    }
398
399
400    /// Generate enum
401    fn generate_enum(&mut self, enum_decl: &EnumDeclaration) -> Result<String> {
402        let name = &enum_decl.name;
403        let mut variants = Vec::new();
404
405        for member in &enum_decl.members {
406            let variant_name = &member.name;
407            let variant_value = if let Some(ref init) = member.initializer {
408                match init {
409                    Expression::Literal(Literal::String(s)) => format!(" = \"{}\"", s),
410                    Expression::Literal(Literal::Number(n)) => format!(" = {}", n),
411                    _ => String::new(),
412                }
413            } else {
414                String::new()
415            };
416            variants.push(format!("    {}{}", variant_name, variant_value));
417        }
418
419        Ok(format!(
420            "#[derive(Debug, Clone, Serialize, Deserialize)]\npub enum {} {{\n{}\n}}",
421            name,
422            variants.join(",\n")
423        ))
424    }
425
426    /// Generate variable
427    fn generate_variable(&mut self, var: &VariableDeclaration) -> Result<String> {
428        let name = &var.name;
429        let var_type = if let Some(ref t) = var.type_annotation {
430            self.type_mapper.map_type(t)?
431        } else {
432            // Try to infer type from initializer
433            if let Some(ref init) = var.initializer {
434                match init {
435                    Expression::Literal(Literal::String(_)) => "String".to_string(),
436                    Expression::Literal(Literal::Number(_)) => "f64".to_string(),
437                    Expression::Literal(Literal::Boolean(_)) => "bool".to_string(),
438                    Expression::New(new_expr) => {
439                        // Try to get the type from the constructor
440                        if let Expression::Identifier(callee) = &*new_expr.callee {
441                            format!("Box<{}>", callee)
442                        } else {
443                            "Box<dyn Any>".to_string()
444                        }
445                    },
446                    Expression::Call(call) => {
447                        // Try to infer return type from function name
448                        if let Expression::Identifier(callee) = &*call.callee {
449                            match callee.as_str() {
450                                "greet" => "String".to_string(),
451                                "add" => "f64".to_string(),
452                                _ => "f64".to_string(), // Default to f64 for unknown functions
453                            }
454                        } else {
455                            "f64".to_string()
456                        }
457                    },
458                    _ => "Box<dyn Any>".to_string(),
459                }
460            } else {
461                "Box<dyn Any>".to_string()
462            }
463        };
464
465        let initializer = if let Some(ref init) = var.initializer {
466            format!(" = {}", self.generate_expression(init)?)
467        } else {
468            String::new()
469        };
470
471        Ok(format!("let {}: {}{};", name, var_type, initializer))
472    }
473
474    /// Generate import
475    fn generate_import(&mut self, import: &ImportDeclaration) -> Result<String> {
476        let source = &import.source;
477        let mut import_code = format!("use {}::", source);
478
479        for specifier in &import.specifiers {
480            match specifier {
481                ImportSpecifier::Named(named) => {
482                    import_code.push_str(&format!("{} as {}", named.imported, named.name));
483                }
484                ImportSpecifier::Default(default) => {
485                    import_code.push_str(&default.name);
486                }
487                ImportSpecifier::Namespace(namespace) => {
488                    import_code.push_str(&format!("* as {}", namespace.name));
489                }
490            }
491        }
492
493        Ok(import_code)
494    }
495
496    /// Generate export
497    fn generate_export(&mut self, _export: &ExportDeclaration) -> Result<String> {
498        // In Rust, everything is public by default in the module
499        // Exports are handled by the module system
500        Ok(String::new())
501    }
502
503    /// Generate namespace as module
504    fn generate_namespace(&mut self, namespace: &NamespaceDeclaration) -> Result<String> {
505        let name = &namespace.name;
506        let body = self.generate_statement(&namespace.body)?;
507        Ok(format!("pub mod {} {{\n{}\n}}", name, body))
508    }
509
510    /// Generate module
511    fn generate_module(&mut self, module: &ModuleDeclaration) -> Result<String> {
512        let name = &module.name;
513        let body = self.generate_statement(&module.body)?;
514        Ok(format!("pub mod {} {{\n{}\n}}", name, body))
515    }
516
517    /// Generate method
518    fn generate_method(&mut self, method: &MethodDeclaration) -> Result<String> {
519        let name = &method.name;
520        let params = self.generate_parameters(&method.parameters)?;
521        let return_type = if let Some(ref t) = method.return_type {
522            format!(" -> {}", self.type_mapper.map_type(t)?)
523        } else {
524            " -> ()".to_string()
525        };
526
527        let body = if let Some(ref b) = method.body {
528            self.generate_statement(b)?
529        } else {
530            "unimplemented!()".to_string()
531        };
532
533        Ok(format!(
534            "    pub fn {}(&self, {}){}{{\n        {}\n    }}",
535            name, params, return_type, body
536        ))
537    }
538
539    /// Generate method signature
540    fn generate_method_signature(&mut self, method: &MethodSignature) -> Result<String> {
541        let name = &method.name;
542        let params = self.generate_parameters(&method.parameters)?;
543        let return_type = if let Some(ref t) = method.return_type {
544            format!(" -> {}", self.type_mapper.map_type(t)?)
545        } else {
546            " -> ()".to_string()
547        };
548
549        Ok(format!("fn {}(&self, {}){}", name, params, return_type))
550    }
551
552    /// Generate parameters
553    fn generate_parameters(&mut self, parameters: &[Parameter]) -> Result<String> {
554        let mut param_strings = Vec::new();
555
556        for param in parameters {
557            let param_type = if let Some(ref t) = param.type_ {
558                self.type_mapper.map_type(t)?
559            } else {
560                "Box<dyn Any>".to_string()
561            };
562
563            let param_def = if param.optional {
564                format!("{}: Option<{}>", param.name, param_type)
565            } else {
566                format!("{}: {}", param.name, param_type)
567            };
568
569            param_strings.push(param_def);
570        }
571
572        Ok(param_strings.join(", "))
573    }
574
575    /// Generate statement
576    fn generate_statement(&mut self, statement: &Statement) -> Result<String> {
577        match statement {
578            Statement::BlockStatement(block) => {
579                let mut statements = Vec::new();
580                for stmt in &block.statements {
581                    statements.push(self.generate_statement(stmt)?);
582                }
583                Ok(statements.join("\n    "))
584            }
585            Statement::ExpressionStatement(expr_stmt) => {
586                let expr = self.generate_expression(&expr_stmt.expression)?;
587                // Add semicolon for all statements
588                Ok(format!("{};", expr))
589            }
590            Statement::ReturnStatement(ret) => {
591                if let Some(ref arg) = ret.argument {
592                    let expr = self.generate_expression(arg)?;
593                    // Remove TODO comments and fix syntax
594                    let clean_expr = if expr.contains("TODO") {
595                        "unimplemented!()".to_string()
596                    } else {
597                        expr
598                    };
599                    Ok(format!("return {};", clean_expr))
600                } else {
601                    Ok("return;".to_string())
602                }
603            }
604            Statement::VariableDeclaration(var) => self.generate_variable(var),
605            _ => {
606                // Handle other statement types
607                Ok("// TODO: Implement statement".to_string())
608            }
609        }
610    }
611
612    /// Generate expression
613    fn generate_expression(&mut self, expression: &Expression) -> Result<String> {
614        match expression {
615            Expression::Literal(literal) => self.generate_literal(literal),
616            Expression::Identifier(ident) => Ok(ident.clone()),
617            Expression::Binary(binary) => self.generate_binary_expression(binary),
618            Expression::Unary(unary) => self.generate_unary_expression(unary),
619            Expression::Call(call) => self.generate_call_expression(call),
620            Expression::Member(member) => self.generate_member_expression(member),
621            Expression::Array(array) => self.generate_array_expression(array),
622            Expression::Object(object) => self.generate_object_expression(object),
623            Expression::Template(template) => self.generate_template_literal(template),
624            Expression::New(new_expr) => self.generate_new_expression(new_expr),
625            Expression::Assignment(assignment) => self.generate_assignment_expression(assignment),
626            _ => {
627                // Handle other expression types
628                Ok("// TODO: Implement expression".to_string())
629            }
630        }
631    }
632
633    /// Generate literal
634    fn generate_literal(&self, literal: &Literal) -> Result<String> {
635        match literal {
636            Literal::String(s) => Ok(format!("\"{}\"", s)),
637            Literal::Number(n) => Ok(n.to_string()),
638            Literal::Boolean(b) => Ok(b.to_string()),
639            Literal::Null => Ok("None".to_string()),
640            Literal::Undefined => Ok("None".to_string()),
641            _ => Ok("// TODO: Implement literal".to_string()),
642        }
643    }
644
645    /// Generate binary expression
646    fn generate_binary_expression(&mut self, binary: &BinaryExpression) -> Result<String> {
647        let left = self.generate_expression(&binary.left)?;
648        let right = self.generate_expression(&binary.right)?;
649        let operator = self.map_operator(&binary.operator)?;
650        Ok(format!("({} {} {})", left, operator, right))
651    }
652
653    /// Generate unary expression
654    fn generate_unary_expression(&mut self, unary: &UnaryExpression) -> Result<String> {
655        let argument = self.generate_expression(&unary.argument)?;
656        let operator = self.map_operator(&unary.operator)?;
657        Ok(format!("{}{}", operator, argument))
658    }
659
660    /// Generate assignment expression
661    fn generate_assignment_expression(&mut self, assignment: &AssignmentExpression) -> Result<String> {
662        let left = self.generate_expression(&assignment.left)?;
663        let right = self.generate_expression(&assignment.right)?;
664        let operator = match assignment.operator {
665            crate::lexer::Token::Assign => "=",
666            _ => "=", // Default to assignment
667        };
668        Ok(format!("{} {} {}", left, operator, right))
669    }
670
671    /// Generate call expression
672    fn generate_call_expression(&mut self, call: &CallExpression) -> Result<String> {
673        let callee = self.generate_expression(&call.callee)?;
674        let mut args = Vec::new();
675        for arg in &call.arguments {
676            args.push(self.generate_expression(arg)?);
677        }
678        
679        // Special handling for console.log
680        if callee == "console.log" {
681            if args.len() == 1 {
682                Ok(format!("println!(\"{{}}\", {});", args[0]))
683            } else {
684                let format_string = args.iter().map(|_| "{}").collect::<Vec<_>>().join(" ");
685                Ok(format!("println!(\"{}\", {});", format_string, args.join(", ")))
686            }
687        } else {
688            Ok(format!("{}({})", callee, args.join(", ")))
689        }
690    }
691
692    /// Generate member expression
693    fn generate_member_expression(&mut self, member: &MemberExpression) -> Result<String> {
694        let object = self.generate_expression(&member.object)?;
695        let property = self.generate_expression(&member.property)?;
696
697        if member.computed {
698            Ok(format!("{}[{}]", object, property))
699        } else {
700            Ok(format!("{}.{}", object, property))
701        }
702    }
703
704    /// Generate array expression
705    fn generate_array_expression(&mut self, array: &ArrayExpression) -> Result<String> {
706        let mut elements = Vec::new();
707        for element in &array.elements {
708            if let Some(expr) = element {
709                elements.push(self.generate_expression(expr)?);
710            } else {
711                elements.push("None".to_string());
712            }
713        }
714        Ok(format!("vec![{}]", elements.join(", ")))
715    }
716
717    /// Generate object expression
718    fn generate_object_expression(&mut self, object: &ObjectExpression) -> Result<String> {
719        let mut fields = Vec::new();
720        for property in &object.properties {
721            let key = self.generate_expression(&property.key)?;
722            let value = self.generate_expression(&property.value)?;
723            fields.push(format!("{}: {}", key, value));
724        }
725        Ok(format!("{{\n        {}\n    }}", fields.join(",\n        ")))
726    }
727
728    /// Generate template literal
729    fn generate_template_literal(&mut self, template: &TemplateLiteral) -> Result<String> {
730        // For now, handle simple template literals without expressions
731        if template.expressions.is_empty() && !template.quasis.is_empty() {
732            let raw_string = &template.quasis[0].value;
733            // Simple string replacement for common patterns
734            if raw_string.contains("${name}") {
735                Ok(format!("format!(\"Hello, {{}}!\", name)"))
736            } else if raw_string == "Hello, ${name}!" {
737                Ok(format!("format!(\"Hello, {{}}!\", name)"))
738            } else {
739                Ok(format!("\"{}\"", raw_string))
740            }
741        } else {
742            // Generate format! macro for template literals with interpolation
743            let mut format_parts = Vec::new();
744            let mut args = Vec::new();
745            
746            for (i, quasi) in template.quasis.iter().enumerate() {
747                format_parts.push(quasi.value.clone());
748                
749                // Add expression if it exists
750                if i < template.expressions.len() {
751                    let expr = self.generate_expression(&template.expressions[i])?;
752                    args.push(expr);
753                    format_parts.push("{}".to_string());
754                }
755            }
756            
757            let format_string = format_parts.join("");
758            if args.is_empty() {
759                Ok(format!("\"{}\"", format_string))
760            } else {
761                Ok(format!("format!(\"{}\", {})", format_string, args.join(", ")))
762            }
763        }
764    }
765
766    /// Generate new expression
767    fn generate_new_expression(&mut self, new_expr: &NewExpression) -> Result<String> {
768        let callee = self.generate_expression(&new_expr.callee)?;
769        let mut args = Vec::new();
770        for arg in &new_expr.arguments {
771            args.push(self.generate_expression(arg)?);
772        }
773        Ok(format!("Box::new({}::new({}))", callee, args.join(", ")))
774    }
775
776    /// Map operator
777    fn map_operator(&self, token: &crate::lexer::Token) -> Result<String> {
778        match token {
779            crate::lexer::Token::Plus => Ok("+".to_string()),
780            crate::lexer::Token::Minus => Ok("-".to_string()),
781            crate::lexer::Token::Multiply => Ok("*".to_string()),
782            crate::lexer::Token::Divide => Ok("/".to_string()),
783            crate::lexer::Token::Equal => Ok("==".to_string()),
784            crate::lexer::Token::NotEqual => Ok("!=".to_string()),
785            crate::lexer::Token::LessThan => Ok("<".to_string()),
786            crate::lexer::Token::GreaterThan => Ok(">".to_string()),
787            crate::lexer::Token::LessEqual => Ok("<=".to_string()),
788            crate::lexer::Token::GreaterEqual => Ok(">=".to_string()),
789            crate::lexer::Token::And => Ok("&&".to_string()),
790            crate::lexer::Token::Or => Ok("||".to_string()),
791            crate::lexer::Token::Not => Ok("!".to_string()),
792            crate::lexer::Token::Assign => Ok("=".to_string()),
793            _ => Err(CompilerError::generation_error(format!(
794                "Unsupported operator: {:?}",
795                token
796            ))),
797        }
798    }
799}