Fix mutable variable tracking, throw in exceptional case, fix keyframes, fix css builders

Author: shanshrew

packages/swc-plugin/src/lib.rs

@@ -118,6 +118,72 @@ impl Default for CompiledOptions {
     }
 }
 
+
+
+/// Visitor for collecting variable information only (no CSS processing)
+struct VariableInfoCollector<'a> {
+    state: &'a mut TransformState,
+    current_var_decl_kind: Option<VarDeclKind>,
+}
+
+impl<'a> VariableInfoCollector<'a> {
+    fn new(state: &'a mut TransformState) -> Self {
+        Self {
+            state,
+            current_var_decl_kind: None,
+        }
+    }
+}
+
+impl<'a> VisitMut for VariableInfoCollector<'a> {
+    fn visit_mut_var_decl(&mut self, n: &mut VarDecl) {
+        // Set the current variable declaration kind
+        self.current_var_decl_kind = Some(n.kind);
+        
+        n.visit_mut_children_with(self);
+        
+        // Clear the current variable declaration kind
+        self.current_var_decl_kind = None;
+    }
+
+    fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator) {
+        // Track variable declarations
+        if let Pat::Ident(ident) = &n.name {
+            let var_name = ident.id.sym.to_string();
+            
+            // Track the declaration kind
+            if let Some(decl_kind) = self.current_var_decl_kind {
+                self.state.variable_declaration_kinds.insert(var_name.clone(), decl_kind);
+            }
+        }
+        
+        n.visit_mut_children_with(self);
+    }
+
+    fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr) {
+        // Track mutations
+        match &n.left {
+            AssignTarget::Simple(SimpleAssignTarget::Ident(ident)) => {
+                let var_name = ident.id.sym.to_string();
+                self.state.mutated_variables.insert(var_name);
+            }
+            _ => {}
+        }
+        
+        n.visit_mut_children_with(self);
+    }
+
+    fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr) {
+        // Track mutations
+        if let Expr::Ident(ident) = &*n.arg {
+            let var_name = ident.sym.to_string();
+            self.state.mutated_variables.insert(var_name);
+        }
+        
+        n.visit_mut_children_with(self);
+    }
+}
+
 /// Main transformation context for the Compiled SWC plugin.
 /// 
 /// This struct maintains the state throughout the transformation process,
@@ -133,6 +199,8 @@ pub struct CompiledTransform {
     pub state: TransformState,
     /// Whether any transformations were applied
     pub had_transformations: bool,
+    /// Current variable declaration kind (let, const, var) being processed
+    pub current_var_decl_kind: Option<VarDeclKind>,
 }
 
 impl CompiledTransform {
@@ -165,6 +233,12 @@ impl CompiledTransform {
         // For now, we rely on the string-based approach in the test infrastructure
     }
 
+    /// Collect variable declarations and mutations without processing CSS
+    fn collect_variable_info(&mut self, module: &mut Module) {
+        let mut collector = VariableInfoCollector::new(&mut self.state);
+        module.visit_mut_with(&mut collector);
+    }
+
     /// Process imports and pragmas from the module
     fn process_imports_and_pragmas(&mut self, module: &mut Module) {
         let mut imports_to_remove = Vec::new();
@@ -903,10 +977,16 @@ impl VisitMut for CompiledTransform {
     }
 
     fn visit_mut_module(&mut self, n: &mut Module) {
-        // First pass: Check for JSX pragmas and compiled imports
+        // Check for JSX pragmas and compiled imports
         self.process_imports_and_pragmas(n);
 
-        // Second pass: Process child nodes for transformations
+        // First pass: collect variable declarations and mutations without processing CSS
+        self.collect_variable_info(n);
+        
+        // Rebuild the variable context excluding mutated variables
+        self.state.variable_context = crate::utils::variable_context::build_variable_context_from_module_with_mutations(n, &self.state.mutated_variables);
+        
+        // Second pass: process child nodes for transformations with correct variable context
         n.visit_mut_children_with(self);
 
         // Finalize the module
@@ -932,7 +1012,7 @@ impl VisitMut for CompiledTransform {
         // Handle different types of tagged templates
         if visitors::styled::visit_styled_tagged_template(n, &mut self.state, &mut self.collected_css_sheets) {
             self.had_transformations = true;
-        } else if visitors::keyframes::visit_keyframes_tagged_template(n, &mut self.state) {
+        } else if visitors::keyframes::visit_keyframes_tagged_template(n, &mut self.state, &mut self.collected_css_sheets) {
             self.had_transformations = true;
         }
 
@@ -952,11 +1032,30 @@ impl VisitMut for CompiledTransform {
         n.visit_mut_children_with(self);
     }
 
+    fn visit_mut_var_decl(&mut self, n: &mut VarDecl) {
+        // Store the current variable declaration kind
+        self.current_var_decl_kind = Some(n.kind);
+        
+        // Visit children (including declarators)
+        n.visit_mut_children_with(self);
+        
+        // Clear the current variable declaration kind
+        self.current_var_decl_kind = None;
+    }
+
     fn visit_mut_var_declarator(&mut self, n: &mut VarDeclarator) {
         // Track local variables before visiting children
         if let Pat::Ident(ident) = &n.name {
             if let Some(init_expr) = &n.init {
                 let var_name = ident.id.sym.to_string();
+                
+                // Track the declaration kind
+                if let Some(decl_kind) = self.current_var_decl_kind {
+                    self.state.variable_declaration_kinds.insert(var_name.clone(), decl_kind);
+                }
+                
+                // Track all variables for static analysis initially
+                // We'll filter out actually mutated ones during evaluation
                 self.track_local_variable(&var_name, init_expr);
             }
         }
@@ -970,6 +1069,34 @@ impl VisitMut for CompiledTransform {
         }
     }
 
+    /// Track assignments to variables (mutations)
+    fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr) {
+        // Check if this is an assignment to a variable
+        match &n.left {
+            AssignTarget::Simple(SimpleAssignTarget::Ident(ident)) => {
+                let var_name = ident.id.sym.to_string();
+                // Mark this variable as mutated
+                self.state.mutated_variables.insert(var_name);
+            }
+            _ => {}
+        }
+        
+        n.visit_mut_children_with(self);
+    }
+
+    /// Track update expressions (mutations like var++, ++var, var--, --var)
+    fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr) {
+        if let Expr::Ident(ident) = &*n.arg {
+            let var_name = ident.sym.to_string();
+            // Mark this variable as mutated
+            self.state.mutated_variables.insert(var_name);
+        }
+        
+        n.visit_mut_children_with(self);
+    }
+
+
+
 
 }
 
@@ -989,6 +1116,7 @@ pub fn process_transform(program: Program, metadata: TransformPluginProgramMetad
         css_content_to_var: HashMap::new(),
         state,
         had_transformations: false,
+        current_var_decl_kind: None,
     };
 
     program.fold_with(&mut as_folder(&mut transform))

packages/swc-plugin/src/test_utils.rs

@@ -125,16 +125,14 @@ pub fn transform_with_compiled(code: &str, mut options: TestTransformOptions) ->
         state.compiled_imports = Some(crate::types::CompiledImports::new());
     }
 
-    // Build variable context from the module
-    state.variable_context = crate::utils::variable_context::build_variable_context_from_module(&module);
-
     // Create our Compiled transformation instance
     let mut compiled_transform = CompiledTransform {
         options: compiled_opts,
         collected_css_sheets: Vec::new(),
         css_content_to_var: HashMap::new(),
         state,
         had_transformations: false,
+        current_var_decl_kind: None,
     };
 
     // Apply our Compiled transformation

packages/swc-plugin/src/types.rs

@@ -1,5 +1,5 @@
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use crate::utils::module_resolver::{ModuleResolver, ExportValue};
 use crate::utils::variable_context::VariableContext;
 use swc_core::ecma::ast::*;
@@ -57,6 +57,12 @@ pub struct TransformState {
     /// Local variables in the current scope (for static analysis)
     pub local_variables: HashMap<String, ExportValue>,
 
+    /// Variable declaration kinds (let, const, var) for let variable detection
+    pub variable_declaration_kinds: HashMap<String, VarDeclKind>,
+    
+    /// Variables that have been actually mutated (assigned to after declaration)
+    pub mutated_variables: HashSet<String>,
+    
     /// Variable context for expression evaluation
     pub variable_context: VariableContext,
 
@@ -162,6 +168,8 @@ impl Default for TransformState {
             resolved_expressions: HashMap::new(),
             css_expressions_to_resolve: Vec::new(),
             local_variables: HashMap::new(),
+            variable_declaration_kinds: HashMap::new(),
+            mutated_variables: HashSet::new(),
             variable_context: VariableContext::new(),
             debug_messages: Vec::new(),
         }

packages/swc-plugin/src/utils/css_builder.rs

@@ -271,6 +271,15 @@ fn generate_css_variable_name(expr: &Expr) -> String {
     format!("--_{}", hash.chars().take(8).collect::<String>())
 }
 
+/// Converts a CSS object expression to CSS string with variable support and state (includes mutated let variable check)
+pub fn object_expression_to_css_with_state(obj_expr: &ObjectLit, state: &TransformState) -> (String, Vec<Variable>) {
+    // Check for actually mutated let variables first
+    crate::utils::expression_evaluator::check_for_mutated_let_variables(&Expr::Object(obj_expr.clone()), &state.variable_declaration_kinds, &state.mutated_variables);
+    
+    // If no mutated let variables found, proceed with normal processing
+    object_expression_to_css_with_variables_and_context(obj_expr, &state.variable_context)
+}
+
 /// Converts a CSS object expression to CSS string with variable support and context
 pub fn object_expression_to_css_with_variables_and_context(obj_expr: &ObjectLit, context: &VariableContext) -> (String, Vec<Variable>) {
     let mut css = String::new();
@@ -572,6 +581,15 @@ pub fn build_atomic_css_from_object(obj_expr: &ObjectLit) -> Option<AtomicCSSOut
     })
 }
 
+/// Builds CSS output from an expression with state (includes mutated let variable check)
+pub fn build_css_from_expression_with_state(expr: &Expr, state: &TransformState) -> Option<CSSOutput> {
+    // Check for actually mutated let variables first
+    crate::utils::expression_evaluator::check_for_mutated_let_variables(expr, &state.variable_declaration_kinds, &state.mutated_variables);
+    
+    // If no mutated let variables found, proceed with normal processing
+    build_css_from_expression_with_context(expr, &state.variable_context)
+}
+
 /// Builds CSS output from an expression with variable support (with context)
 pub fn build_css_from_expression_with_context(expr: &Expr, context: &VariableContext) -> Option<CSSOutput> {
     match expr {

packages/swc-plugin/src/utils/expression_evaluator.rs

@@ -1,12 +1,103 @@
 use swc_core::ecma::ast::*;
 use crate::utils::variable_context::VariableContext;
+use crate::types::TransformState;
+use std::collections::HashMap;
+
+/// Check if an expression contains any actually mutated let variables
+/// Panics with a helpful error message if a mutated let variable is found  
+pub fn check_for_mutated_let_variables(expr: &Expr, variable_declaration_kinds: &HashMap<String, VarDeclKind>, mutated_variables: &std::collections::HashSet<String>) {
+    match expr {
+        Expr::Ident(ident) => {
+            let var_name = ident.sym.to_string();
+            // Only panic if it's a let variable AND it has been mutated
+            if let Some(decl_kind) = variable_declaration_kinds.get(&var_name) {
+                if matches!(decl_kind, VarDeclKind::Let) && mutated_variables.contains(&var_name) {
+                    panic!("Mutable variable '{}' cannot be used in CSS expressions. Compiled only supports constant values in CSS at compile time. Consider using CSS variables or move the dynamic logic to a style prop.", var_name);
+                }
+            }
+        }
+        Expr::Bin(bin_expr) => {
+            check_for_mutated_let_variables(&bin_expr.left, variable_declaration_kinds, mutated_variables);
+            check_for_mutated_let_variables(&bin_expr.right, variable_declaration_kinds, mutated_variables);
+        }
+        Expr::Unary(unary_expr) => {
+            check_for_mutated_let_variables(&unary_expr.arg, variable_declaration_kinds, mutated_variables);
+        }
+        Expr::Cond(cond_expr) => {
+            check_for_mutated_let_variables(&cond_expr.test, variable_declaration_kinds, mutated_variables);
+            check_for_mutated_let_variables(&cond_expr.cons, variable_declaration_kinds, mutated_variables);
+            check_for_mutated_let_variables(&cond_expr.alt, variable_declaration_kinds, mutated_variables);
+        }
+        Expr::Member(member_expr) => {
+            check_for_mutated_let_variables(&member_expr.obj, variable_declaration_kinds, mutated_variables);
+            if let MemberProp::Computed(computed) = &member_expr.prop {
+                check_for_mutated_let_variables(&computed.expr, variable_declaration_kinds, mutated_variables);
+            }
+        }
+        Expr::Tpl(tpl) => {
+            for expr in &tpl.exprs {
+                check_for_mutated_let_variables(expr, variable_declaration_kinds, mutated_variables);
+            }
+        }
+        Expr::Call(call_expr) => {
+            if let Callee::Expr(expr) = &call_expr.callee {
+                check_for_mutated_let_variables(expr, variable_declaration_kinds, mutated_variables);
+            }
+            for arg in &call_expr.args {
+                check_for_mutated_let_variables(&arg.expr, variable_declaration_kinds, mutated_variables);
+            }
+        }
+        Expr::Object(obj_lit) => {
+            for prop in &obj_lit.props {
+                if let PropOrSpread::Prop(prop_box) = prop {
+                    match &**prop_box {
+                        Prop::KeyValue(kv) => {
+                            if let PropName::Computed(computed) = &kv.key {
+                                check_for_mutated_let_variables(&computed.expr, variable_declaration_kinds, mutated_variables);
+                            }
+                            check_for_mutated_let_variables(&kv.value, variable_declaration_kinds, mutated_variables);
+                        }
+                        Prop::Method(method) => {
+                            if let PropName::Computed(computed) = &method.key {
+                                check_for_mutated_let_variables(&computed.expr, variable_declaration_kinds, mutated_variables);
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+        Expr::Array(arr_lit) => {
+            for elem in &arr_lit.elems {
+                if let Some(expr_or_spread) = elem {
+                    check_for_mutated_let_variables(&expr_or_spread.expr, variable_declaration_kinds, mutated_variables);
+                }
+            }
+        }
+        // Literal values are safe
+        Expr::Lit(_) => {}
+        // Other expressions we don't need to check deeply
+        _ => {}
+    }
+}
 
 /// Attempts to statically evaluate an expression to a literal value
 /// Returns Some(Expr) if evaluation was successful, None otherwise
 pub fn evaluate_expression(expr: &Expr) -> Option<Expr> {
     evaluate_expression_with_context(expr, &VariableContext::new())
 }
 
+/// Attempts to statically evaluate an expression with a transform state
+/// Checks for mutated let variables first and panics if found
+/// Returns Some(Expr) if evaluation was successful, None otherwise
+pub fn evaluate_expression_with_state(expr: &Expr, state: &TransformState) -> Option<Expr> {
+    // Check for actually mutated let variables first and panic if found
+    check_for_mutated_let_variables(expr, &state.variable_declaration_kinds, &state.mutated_variables);
+    
+    // If no mutated let variables, proceed with normal evaluation
+    evaluate_expression_with_context(expr, &state.variable_context)
+}
+
 /// Attempts to statically evaluate an expression with a variable context
 /// Returns Some(Expr) if evaluation was successful, None otherwise
 pub fn evaluate_expression_with_context(expr: &Expr, context: &VariableContext) -> Option<Expr> {