use crate::error::{GeneratorError, GeneratorResult};
use jsxbin_parser::types::{Block, Token, CatchClause};
use log::{debug, trace};
#[derive(Debug, Clone)]
pub struct EmitterConfig {
pub indent_width: usize,
pub use_tabs: bool,
pub semicolons: bool,
pub arrow_functions: bool,
}
impl Default for EmitterConfig {
fn default() -> Self {
EmitterConfig {
indent_width: 2,
use_tabs: false,
semicolons: true,
arrow_functions: true,
}
}
}
pub struct CodeEmitter {
config: EmitterConfig,
indent_level: usize,
output: String,
}
impl CodeEmitter {
pub fn new(config: EmitterConfig) -> Self {
CodeEmitter {
config,
indent_level: 0,
output: String::new(),
}
}
pub fn default() -> Self {
Self::new(EmitterConfig::default())
}
pub fn emit_token(&mut self, token: &Token) -> GeneratorResult<String> {
self.output.clear();
self.emit_token_internal(token)?;
Ok(self.output.clone())
}
pub fn emit_block(&mut self, tokens: &[Token]) -> GeneratorResult<String> {
self.output.clear();
self.indent_level = 0;
for token in tokens {
self.emit_token_internal(token)?;
if self.config.semicolons && self.should_add_semicolon(token) {
self.output.push(';');
}
self.output.push('\n');
}
Ok(self.output.clone())
}
fn emit_token_internal(&mut self, token: &Token) -> GeneratorResult<()> {
match token {
Token::Null => {
self.output.push_str("null");
}
Token::Undefined => {
self.output.push_str("undefined");
}
Token::NumberLiteral(num) => {
if num.is_nan() {
self.output.push_str("NaN");
} else if num.is_infinite() {
if num.is_sign_positive() {
self.output.push_str("Infinity");
} else {
self.output.push_str("-Infinity");
}
} else if num.fract() == 0.0 && *num >= 0.0 && *num <= 1e10 {
self.output.push_str(&format!("{}", *num as i64));
} else {
self.output.push_str(&num.to_string());
}
}
Token::StringLiteral(s) => {
self.output.push('"');
for ch in s.chars() {
match ch {
'"' => self.output.push_str("\\\""),
'\\' => self.output.push_str("\\\\"),
'\n' => self.output.push_str("\\n"),
'\r' => self.output.push_str("\\r"),
'\t' => self.output.push_str("\\t"),
_ => self.output.push(ch),
}
}
self.output.push('"');
}
Token::BooleanLiteral(b) => {
self.output.push_str(if *b { "true" } else { "false" });
}
Token::Identifier(name) => {
self.output.push_str(name);
}
Token::VariableDeclaration { name, value } => {
self.output.push_str("var ");
self.output.push_str(name);
if let Some(v) = value {
self.output.push_str(" = ");
self.emit_token_internal(&v.token)?;
}
}
Token::Function {
name,
params,
body,
} => {
self.output.push_str("function ");
self.output.push_str(name);
self.output.push('(');
self.output.push_str(¶ms.join(", "));
self.output.push_str(") ");
self.emit_block_internal(body)?;
}
Token::FunctionCall { callee, arguments } => {
self.emit_token_internal(&callee.token)?;
self.output.push('(');
for (i, arg) in arguments.iter().enumerate() {
if i > 0 {
self.output.push_str(", ");
}
self.emit_token_internal(&arg.token)?;
}
self.output.push(')');
}
Token::BinaryOperation {
left,
operator,
right,
} => {
self.output.push('(');
self.emit_token_internal(&left.token)?;
self.output.push(' ');
self.output.push_str(operator);
self.output.push(' ');
self.emit_token_internal(&right.token)?;
self.output.push(')');
}
Token::UnaryOperation { operator, operand } => {
self.output.push_str(operator);
if !operator.ends_with('+') && !operator.ends_with('-') {
self.output.push(' ');
}
self.emit_token_internal(&operand.token)?;
}
Token::Assignment { target, value } => {
self.emit_token_internal(&target.token)?;
self.output.push_str(" = ");
self.emit_token_internal(&value.token)?;
}
Token::MemberAccess {
object,
property,
computed,
} => {
self.emit_token_internal(&object.token)?;
if *computed {
self.output.push('[');
self.emit_token_internal(&property.token)?;
self.output.push(']');
} else {
self.output.push('.');
self.emit_token_internal(&property.token)?;
}
}
Token::ArrayLiteral(elements) => {
self.output.push('[');
for (i, elem) in elements.iter().enumerate() {
if i > 0 {
self.output.push_str(", ");
}
self.emit_token_internal(&elem.token)?;
}
self.output.push(']');
}
Token::ObjectLiteral(properties) => {
self.output.push('{');
self.indent_level += 1;
for (i, (key, value)) in properties.iter().enumerate() {
if i > 0 {
self.output.push(',');
}
self.output.push('\n');
self.output.push_str(&self.indent_str());
self.output.push_str(key);
self.output.push_str(": ");
self.emit_token_internal(&value.token)?;
}
self.indent_level -= 1;
self.output.push('\n');
self.output.push_str(&self.indent_str());
self.output.push('}');
}
Token::IfStatement {
condition,
consequent,
alternate,
} => {
self.output.push_str("if (");
self.emit_token_internal(&condition.token)?;
self.output.push_str(") ");
self.emit_block_internal(consequent)?;
if let Some(alt) = alternate {
self.output.push_str(" else ");
self.emit_block_internal(alt)?;
}
}
Token::WhileLoop { condition, body } => {
self.output.push_str("while (");
self.emit_token_internal(&condition.token)?;
self.output.push_str(") ");
self.emit_block_internal(body)?;
}
Token::ForLoop {
init,
condition,
update,
body,
} => {
self.output.push_str("for (");
if let Some(i) = init {
self.emit_token_internal(i)?;
}
self.output.push(';');
if let Some(c) = condition {
self.output.push(' ');
self.emit_token_internal(&c.token)?;
}
self.output.push(';');
if let Some(u) = update {
self.output.push(' ');
self.emit_token_internal(&u.token)?;
}
self.output.push_str(") ");
self.emit_block_internal(body)?;
}
Token::TryCatch {
body,
handler,
finalizer,
} => {
self.output.push_str("try ");
self.emit_block_internal(body)?;
if let Some(h) = handler {
self.output.push_str(" catch");
if let Some(param) = &h.param {
self.output.push('(');
self.output.push_str(param);
self.output.push(')');
}
self.output.push(' ');
self.emit_block_internal(&h.body)?;
}
if let Some(f) = finalizer {
self.output.push_str(" finally ");
self.emit_block_internal(f)?;
}
}
Token::ThrowStatement(expr) => {
self.output.push_str("throw ");
self.emit_token_internal(&expr.token)?;
}
Token::ReturnStatement(expr) => {
self.output.push_str("return");
if let Some(e) = expr {
self.output.push(' ');
self.emit_token_internal(&e.token)?;
}
}
Token::BreakStatement => {
self.output.push_str("break");
}
Token::ContinueStatement => {
self.output.push_str("continue");
}
Token::Block(block) => {
self.emit_block_internal(block)?;
}
Token::ExpressionStatement(expr) => {
self.emit_token_internal(&expr.token)?;
}
Token::Conditional {
condition,
consequent,
alternate,
} => {
self.emit_token_internal(&condition.token)?;
self.output.push_str(" ? ");
self.emit_token_internal(&consequent.token)?;
self.output.push_str(" : ");
self.emit_token_internal(&alternate.token)?;
}
Token::Unknown(bytes) => {
debug!("Emitting unknown token: {:?}", bytes);
self.output.push_str(&format!("/* unknown: 0x{:02x?} */", bytes));
}
}
Ok(())
}
fn emit_block_internal(&mut self, block: &Block) -> GeneratorResult<()> {
self.output.push('{');
if !block.statements.is_empty() {
self.indent_level += 1;
for stmt in &block.statements {
self.output.push('\n');
self.output.push_str(&self.indent_str());
self.emit_token_internal(stmt)?;
if self.config.semicolons && self.should_add_semicolon(stmt) {
self.output.push(';');
}
}
self.indent_level -= 1;
self.output.push('\n');
self.output.push_str(&self.indent_str());
}
self.output.push('}');
Ok(())
}
fn indent_str(&self) -> String {
if self.config.use_tabs {
"\t".repeat(self.indent_level)
} else {
" ".repeat(self.indent_level * self.config.indent_width)
}
}
fn should_add_semicolon(&self, token: &Token) -> bool {
matches!(
token,
Token::ExpressionStatement(_)
| Token::VariableDeclaration { .. }
| Token::ReturnStatement(_)
| Token::ThrowStatement(_)
| Token::BreakStatement
| Token::ContinueStatement
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_emit_literals() {
let mut emitter = CodeEmitter::default();
assert_eq!(
emitter.emit_token(&Token::Null).unwrap(),
"null"
);
assert_eq!(
emitter.emit_token(&Token::BooleanLiteral(true)).unwrap(),
"true"
);
assert_eq!(
emitter.emit_token(&Token::NumberLiteral(42.0)).unwrap(),
"42"
);
}
#[test]
fn test_emit_string_with_escapes() {
let mut emitter = CodeEmitter::default();
let token = Token::StringLiteral("hello\nworld".to_string());
let result = emitter.emit_token(&token).unwrap();
assert_eq!(result, "\"hello\\nworld\"");
}
}