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 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 }
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 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 }
289 }
290 }
291
292 Ok(format!("pub trait {} {{\n{}\n}}", name, methods.join("\n")))
293 }
294
295 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 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 = ¶m.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 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 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 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 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 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 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 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 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 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 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(), }
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 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 fn generate_export(&mut self, _export: &ExportDeclaration) -> Result<String> {
498 Ok(String::new())
501 }
502
503 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 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 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 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 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 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 Ok(format!("{};", expr))
589 }
590 Statement::ReturnStatement(ret) => {
591 if let Some(ref arg) = ret.argument {
592 let expr = self.generate_expression(arg)?;
593 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 Ok("// TODO: Implement statement".to_string())
608 }
609 }
610 }
611
612 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 Ok("// TODO: Implement expression".to_string())
629 }
630 }
631 }
632
633 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 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 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 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 _ => "=", };
668 Ok(format!("{} {} {}", left, operator, right))
669 }
670
671 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 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 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 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 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 fn generate_template_literal(&mut self, template: &TemplateLiteral) -> Result<String> {
730 if template.expressions.is_empty() && !template.quasis.is_empty() {
732 let raw_string = &template.quasis[0].value;
733 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 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 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 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 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}