jsx-generator 1.0.0

JSX code generator with formatting, optimization, and minification capabilities
Documentation
use crate::error::{GeneratorError, GeneratorResult};
use jsxbin_parser::types::Token;
use log::{debug, trace};

/// Configuration for code optimization
#[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,
        }
    }
}

/// Optimizes JSX AST
pub struct CodeOptimizer {
    config: OptimizerConfig,
}

impl CodeOptimizer {
    /// Create a new code optimizer
    pub fn new(config: OptimizerConfig) -> Self {
        CodeOptimizer { config }
    }

    /// Create with default config
    pub fn default() -> Self {
        Self::new(OptimizerConfig::default())
    }

    /// Optimize a token
    pub fn optimize_token(&self, token: &Token) -> GeneratorResult<Token> {
        match token {
            // Constant folding for simple operations
            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())
            }

            // Optimize function calls
            Token::FunctionCall { .. } => {
                // TODO: Inline simple functions if config enabled
                Ok(token.clone())
            }

            // Optimize conditionals
            Token::IfStatement {
                condition,
                consequent,
                alternate,
            } => {
                if self.config.dead_code_elimination {
                    // Check if condition is a constant
                    if let Token::BooleanLiteral(b) = &*condition.token {
                        if *b {
                            // Condition always true - return consequent only
                            return Ok(Token::Block(*consequent.clone()));
                        } else if let Some(alt) = alternate {
                            // Condition always false - return alternate
                            return Ok(Token::Block(*alt.clone()));
                        }
                    }
                }
                Ok(token.clone())
            }

            // Default: no optimization
            _ => Ok(token.clone()),
        }
    }

    /// Optimize a token stream
    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 {
                // Skip dead code after return/break/continue
                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;
                    }
                }

                // Optimize and keep other tokens
                _ => {
                    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)
    }
}

/// Analysis results from code optimizer
#[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 {
    /// Analyze code for optimization opportunities
    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), // Dead code
        ];

        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);
    }
}