jsx_generator/
code_emitter.rs1use crate::error::{GeneratorError, GeneratorResult};
2use jsxbin_parser::types::{Block, Token, CatchClause};
3use log::{debug, trace};
4
5#[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
25pub struct CodeEmitter {
27 config: EmitterConfig,
28 indent_level: usize,
29 output: String,
30}
31
32impl CodeEmitter {
33 pub fn new(config: EmitterConfig) -> Self {
35 CodeEmitter {
36 config,
37 indent_level: 0,
38 output: String::new(),
39 }
40 }
41
42 pub fn default() -> Self {
44 Self::new(EmitterConfig::default())
45 }
46
47 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 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(¶ms.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}