use crate::error::{GeneratorError, GeneratorResult};
use jsxbin_parser::types::Token;
use log::{debug, trace};
#[derive(Debug, Clone)]
pub struct OptimizerConfig {
pub dead_code_elimination: bool,
pub constant_folding: bool,
pub inline_simple_functions: bool,
pub remove_unused_vars: bool,
}
impl Default for OptimizerConfig {
fn default() -> Self {
OptimizerConfig {
dead_code_elimination: true,
constant_folding: true,
inline_simple_functions: false,
remove_unused_vars: false,
}
}
}
pub struct CodeOptimizer {
config: OptimizerConfig,
}
impl CodeOptimizer {
pub fn new(config: OptimizerConfig) -> Self {
CodeOptimizer { config }
}
pub fn default() -> Self {
Self::new(OptimizerConfig::default())
}
pub fn optimize_token(&self, token: &Token) -> GeneratorResult<Token> {
match token {
Token::BinaryOperation {
left,
operator,
right,
} => {
if self.config.constant_folding {
if let (
Token::NumberLiteral(l),
Token::NumberLiteral(r),
) = (&*left.token, &*right.token)
{
let result = self.fold_numeric_operation(*l, operator, *r)?;
return Ok(Token::NumberLiteral(result));
}
}
Ok(token.clone())
}
Token::FunctionCall { .. } => {
Ok(token.clone())
}
Token::IfStatement {
condition,
consequent,
alternate,
} => {
if self.config.dead_code_elimination {
if let Token::BooleanLiteral(b) = &*condition.token {
if *b {
return Ok(Token::Block(*consequent.clone()));
} else if let Some(alt) = alternate {
return Ok(Token::Block(*alt.clone()));
}
}
}
Ok(token.clone())
}
_ => Ok(token.clone()),
}
}
pub fn optimize_tokens(&self, tokens: &[Token]) -> GeneratorResult<Vec<Token>> {
debug!("Optimizing {} tokens", tokens.len());
let mut optimized = Vec::new();
for token in tokens {
match token {
Token::ReturnStatement(_) | Token::BreakStatement | Token::ContinueStatement => {
optimized.push(token.clone());
if self.config.dead_code_elimination {
trace!("Dead code after control flow statement will be removed");
break;
}
}
_ => {
let optimized_token = self.optimize_token(token)?;
optimized.push(optimized_token);
}
}
}
debug!("Optimization complete: {} -> {} tokens", tokens.len(), optimized.len());
Ok(optimized)
}
pub fn fold_numeric_operation(
&self,
left: f64,
operator: &str,
right: f64,
) -> GeneratorResult<f64> {
let result = match operator {
"+" => left + right,
"-" => left - right,
"*" => left * right,
"/" => {
if right != 0.0 {
left / right
} else {
f64::INFINITY
}
}
"%" => {
if right != 0.0 {
left % right
} else {
f64::NAN
}
}
_ => return Err(GeneratorError::CodeGenerationFailed(
format!("Unknown operator: {}", operator),
)),
};
Ok(result)
}
}
#[derive(Debug, Clone)]
pub struct AnalysisResult {
pub has_dead_code: bool,
pub unused_variables: Vec<String>,
pub function_calls: Vec<String>,
pub string_count: usize,
pub numeric_count: usize,
}
impl CodeOptimizer {
pub fn analyze(&self, tokens: &[Token]) -> AnalysisResult {
let mut result = AnalysisResult {
has_dead_code: false,
unused_variables: Vec::new(),
function_calls: Vec::new(),
string_count: 0,
numeric_count: 0,
};
let mut found_control_flow = false;
for token in tokens {
match token {
Token::StringLiteral(_) => result.string_count += 1,
Token::NumberLiteral(_) => result.numeric_count += 1,
Token::FunctionCall { callee, .. } => {
if let Token::Identifier(name) = &*callee.token {
result.function_calls.push(name.clone());
}
}
Token::ReturnStatement(_) | Token::BreakStatement | Token::ContinueStatement => {
found_control_flow = true;
}
_ => {}
}
}
result.has_dead_code = found_control_flow;
result
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_constant_folding() {
let optimizer = CodeOptimizer::default();
let result = optimizer
.fold_numeric_operation(2.0, "+", 3.0)
.unwrap();
assert_eq!(result, 5.0);
let result = optimizer
.fold_numeric_operation(10.0, "-", 3.0)
.unwrap();
assert_eq!(result, 7.0);
let result = optimizer
.fold_numeric_operation(4.0, "*", 5.0)
.unwrap();
assert_eq!(result, 20.0);
}
#[test]
fn test_dead_code_elimination() {
let optimizer = CodeOptimizer::default();
let tokens = vec![
Token::ReturnStatement(None),
Token::BooleanLiteral(true), ];
let optimized = optimizer.optimize_tokens(&tokens).unwrap();
assert_eq!(optimized.len(), 1);
}
#[test]
fn test_analysis() {
let optimizer = CodeOptimizer::default();
let tokens = vec![
Token::StringLiteral("hello".to_string()),
Token::NumberLiteral(42.0),
];
let analysis = optimizer.analyze(&tokens);
assert_eq!(analysis.string_count, 1);
assert_eq!(analysis.numeric_count, 1);
}
}