Skip to main content

jsx_generator/
code_emitter.rs

1use crate::error::{GeneratorError, GeneratorResult};
2use jsxbin_parser::types::{Block, Token, CatchClause};
3use log::{debug, trace};
4
5/// Configuration for code emission
6#[derive(Debug, Clone)]
7pub struct EmitterConfig {
8    pub indent_width: usize,
9    pub use_tabs: bool,
10    pub semicolons: bool,
11    pub arrow_functions: bool,
12}
13
14impl Default for EmitterConfig {
15    fn default() -> Self {
16        EmitterConfig {
17            indent_width: 2,
18            use_tabs: false,
19            semicolons: true,
20            arrow_functions: true,
21        }
22    }
23}
24
25/// Emits JSX code from an AST
26pub struct CodeEmitter {
27    config: EmitterConfig,
28    indent_level: usize,
29    output: String,
30}
31
32impl CodeEmitter {
33    /// Create a new code emitter
34    pub fn new(config: EmitterConfig) -> Self {
35        CodeEmitter {
36            config,
37            indent_level: 0,
38            output: String::new(),
39        }
40    }
41
42    /// Create with default config
43    pub fn default() -> Self {
44        Self::new(EmitterConfig::default())
45    }
46
47    /// Emit code for a token
48    pub fn emit_token(&mut self, token: &Token) -> GeneratorResult<String> {
49        self.output.clear();
50        self.emit_token_internal(token)?;
51        Ok(self.output.clone())
52    }
53
54    /// Emit code for a block of tokens
55    pub fn emit_block(&mut self, tokens: &[Token]) -> GeneratorResult<String> {
56        self.output.clear();
57        self.indent_level = 0;
58
59        for token in tokens {
60            self.emit_token_internal(token)?;
61            if self.config.semicolons && self.should_add_semicolon(token) {
62                self.output.push(';');
63            }
64            self.output.push('\n');
65        }
66
67        Ok(self.output.clone())
68    }
69
70    fn emit_token_internal(&mut self, token: &Token) -> GeneratorResult<()> {
71        match token {
72            Token::Null => {
73                self.output.push_str("null");
74            }
75
76            Token::Undefined => {
77                self.output.push_str("undefined");
78            }
79
80            Token::NumberLiteral(num) => {
81                if num.is_nan() {
82                    self.output.push_str("NaN");
83                } else if num.is_infinite() {
84                    if num.is_sign_positive() {
85                        self.output.push_str("Infinity");
86                    } else {
87                        self.output.push_str("-Infinity");
88                    }
89                } else if num.fract() == 0.0 && *num >= 0.0 && *num <= 1e10 {
90                    self.output.push_str(&format!("{}", *num as i64));
91                } else {
92                    self.output.push_str(&num.to_string());
93                }
94            }
95
96            Token::StringLiteral(s) => {
97                self.output.push('"');
98                for ch in s.chars() {
99                    match ch {
100                        '"' => self.output.push_str("\\\""),
101                        '\\' => self.output.push_str("\\\\"),
102                        '\n' => self.output.push_str("\\n"),
103                        '\r' => self.output.push_str("\\r"),
104                        '\t' => self.output.push_str("\\t"),
105                        _ => self.output.push(ch),
106                    }
107                }
108                self.output.push('"');
109            }
110
111            Token::BooleanLiteral(b) => {
112                self.output.push_str(if *b { "true" } else { "false" });
113            }
114
115            Token::Identifier(name) => {
116                self.output.push_str(name);
117            }
118
119            Token::VariableDeclaration { name, value } => {
120                self.output.push_str("var ");
121                self.output.push_str(name);
122                if let Some(v) = value {
123                    self.output.push_str(" = ");
124                    self.emit_token_internal(&v.token)?;
125                }
126            }
127
128            Token::Function {
129                name,
130                params,
131                body,
132            } => {
133                self.output.push_str("function ");
134                self.output.push_str(name);
135                self.output.push('(');
136                self.output.push_str(&params.join(", "));
137                self.output.push_str(") ");
138                self.emit_block_internal(body)?;
139            }
140
141            Token::FunctionCall { callee, arguments } => {
142                self.emit_token_internal(&callee.token)?;
143                self.output.push('(');
144                for (i, arg) in arguments.iter().enumerate() {
145                    if i > 0 {
146                        self.output.push_str(", ");
147                    }
148                    self.emit_token_internal(&arg.token)?;
149                }
150                self.output.push(')');
151            }
152
153            Token::BinaryOperation {
154                left,
155                operator,
156                right,
157            } => {
158                self.output.push('(');
159                self.emit_token_internal(&left.token)?;
160                self.output.push(' ');
161                self.output.push_str(operator);
162                self.output.push(' ');
163                self.emit_token_internal(&right.token)?;
164                self.output.push(')');
165            }
166
167            Token::UnaryOperation { operator, operand } => {
168                self.output.push_str(operator);
169                if !operator.ends_with('+') && !operator.ends_with('-') {
170                    self.output.push(' ');
171                }
172                self.emit_token_internal(&operand.token)?;
173            }
174
175            Token::Assignment { target, value } => {
176                self.emit_token_internal(&target.token)?;
177                self.output.push_str(" = ");
178                self.emit_token_internal(&value.token)?;
179            }
180
181            Token::MemberAccess {
182                object,
183                property,
184                computed,
185            } => {
186                self.emit_token_internal(&object.token)?;
187                if *computed {
188                    self.output.push('[');
189                    self.emit_token_internal(&property.token)?;
190                    self.output.push(']');
191                } else {
192                    self.output.push('.');
193                    self.emit_token_internal(&property.token)?;
194                }
195            }
196
197            Token::ArrayLiteral(elements) => {
198                self.output.push('[');
199                for (i, elem) in elements.iter().enumerate() {
200                    if i > 0 {
201                        self.output.push_str(", ");
202                    }
203                    self.emit_token_internal(&elem.token)?;
204                }
205                self.output.push(']');
206            }
207
208            Token::ObjectLiteral(properties) => {
209                self.output.push('{');
210                self.indent_level += 1;
211                for (i, (key, value)) in properties.iter().enumerate() {
212                    if i > 0 {
213                        self.output.push(',');
214                    }
215                    self.output.push('\n');
216                    self.output.push_str(&self.indent_str());
217                    self.output.push_str(key);
218                    self.output.push_str(": ");
219                    self.emit_token_internal(&value.token)?;
220                }
221                self.indent_level -= 1;
222                self.output.push('\n');
223                self.output.push_str(&self.indent_str());
224                self.output.push('}');
225            }
226
227            Token::IfStatement {
228                condition,
229                consequent,
230                alternate,
231            } => {
232                self.output.push_str("if (");
233                self.emit_token_internal(&condition.token)?;
234                self.output.push_str(") ");
235                self.emit_block_internal(consequent)?;
236                if let Some(alt) = alternate {
237                    self.output.push_str(" else ");
238                    self.emit_block_internal(alt)?;
239                }
240            }
241
242            Token::WhileLoop { condition, body } => {
243                self.output.push_str("while (");
244                self.emit_token_internal(&condition.token)?;
245                self.output.push_str(") ");
246                self.emit_block_internal(body)?;
247            }
248
249            Token::ForLoop {
250                init,
251                condition,
252                update,
253                body,
254            } => {
255                self.output.push_str("for (");
256                if let Some(i) = init {
257                    self.emit_token_internal(i)?;
258                }
259                self.output.push(';');
260                if let Some(c) = condition {
261                    self.output.push(' ');
262                    self.emit_token_internal(&c.token)?;
263                }
264                self.output.push(';');
265                if let Some(u) = update {
266                    self.output.push(' ');
267                    self.emit_token_internal(&u.token)?;
268                }
269                self.output.push_str(") ");
270                self.emit_block_internal(body)?;
271            }
272
273            Token::TryCatch {
274                body,
275                handler,
276                finalizer,
277            } => {
278                self.output.push_str("try ");
279                self.emit_block_internal(body)?;
280                if let Some(h) = handler {
281                    self.output.push_str(" catch");
282                    if let Some(param) = &h.param {
283                        self.output.push('(');
284                        self.output.push_str(param);
285                        self.output.push(')');
286                    }
287                    self.output.push(' ');
288                    self.emit_block_internal(&h.body)?;
289                }
290                if let Some(f) = finalizer {
291                    self.output.push_str(" finally ");
292                    self.emit_block_internal(f)?;
293                }
294            }
295
296            Token::ThrowStatement(expr) => {
297                self.output.push_str("throw ");
298                self.emit_token_internal(&expr.token)?;
299            }
300
301            Token::ReturnStatement(expr) => {
302                self.output.push_str("return");
303                if let Some(e) = expr {
304                    self.output.push(' ');
305                    self.emit_token_internal(&e.token)?;
306                }
307            }
308
309            Token::BreakStatement => {
310                self.output.push_str("break");
311            }
312
313            Token::ContinueStatement => {
314                self.output.push_str("continue");
315            }
316
317            Token::Block(block) => {
318                self.emit_block_internal(block)?;
319            }
320
321            Token::ExpressionStatement(expr) => {
322                self.emit_token_internal(&expr.token)?;
323            }
324
325            Token::Conditional {
326                condition,
327                consequent,
328                alternate,
329            } => {
330                self.emit_token_internal(&condition.token)?;
331                self.output.push_str(" ? ");
332                self.emit_token_internal(&consequent.token)?;
333                self.output.push_str(" : ");
334                self.emit_token_internal(&alternate.token)?;
335            }
336
337            Token::Unknown(bytes) => {
338                debug!("Emitting unknown token: {:?}", bytes);
339                self.output.push_str(&format!("/* unknown: 0x{:02x?} */", bytes));
340            }
341        }
342
343        Ok(())
344    }
345
346    fn emit_block_internal(&mut self, block: &Block) -> GeneratorResult<()> {
347        self.output.push('{');
348        if !block.statements.is_empty() {
349            self.indent_level += 1;
350            for stmt in &block.statements {
351                self.output.push('\n');
352                self.output.push_str(&self.indent_str());
353                self.emit_token_internal(stmt)?;
354                if self.config.semicolons && self.should_add_semicolon(stmt) {
355                    self.output.push(';');
356                }
357            }
358            self.indent_level -= 1;
359            self.output.push('\n');
360            self.output.push_str(&self.indent_str());
361        }
362        self.output.push('}');
363        Ok(())
364    }
365
366    fn indent_str(&self) -> String {
367        if self.config.use_tabs {
368            "\t".repeat(self.indent_level)
369        } else {
370            " ".repeat(self.indent_level * self.config.indent_width)
371        }
372    }
373
374    fn should_add_semicolon(&self, token: &Token) -> bool {
375        matches!(
376            token,
377            Token::ExpressionStatement(_)
378                | Token::VariableDeclaration { .. }
379                | Token::ReturnStatement(_)
380                | Token::ThrowStatement(_)
381                | Token::BreakStatement
382                | Token::ContinueStatement
383        )
384    }
385}
386
387#[cfg(test)]
388mod tests {
389    use super::*;
390
391    #[test]
392    fn test_emit_literals() {
393        let mut emitter = CodeEmitter::default();
394
395        assert_eq!(
396            emitter.emit_token(&Token::Null).unwrap(),
397            "null"
398        );
399        assert_eq!(
400            emitter.emit_token(&Token::BooleanLiteral(true)).unwrap(),
401            "true"
402        );
403        assert_eq!(
404            emitter.emit_token(&Token::NumberLiteral(42.0)).unwrap(),
405            "42"
406        );
407    }
408
409    #[test]
410    fn test_emit_string_with_escapes() {
411        let mut emitter = CodeEmitter::default();
412        let token = Token::StringLiteral("hello\nworld".to_string());
413        let result = emitter.emit_token(&token).unwrap();
414        assert_eq!(result, "\"hello\\nworld\"");
415    }
416}