refactor(compiler): remove expression count helpers

crates/oxide_compiler/src/expr/assignment.rs

@@ -1,121 +1,9 @@
 use crate::compiler::{CompileCtx, Compiler, Label};
 use oxide_bytecode::module::Constant;
 use oxide_bytecode::opcode::{self, OpCode};
-use oxide_parser::{AssignmentOperator, Expression, LogicalOperator};
+use oxide_parser::AssignmentOperator;
 
-impl Compiler {
-    fn count_assignment_expression(&self, expr: &Expression, ctx: &mut CompileCtx) {
-        let Expression::AssignmentExpression(assign) = expr else {
-            return;
-        };
-
-        if let oxide_parser::AssignmentTarget::StaticMemberExpression(member) = &assign.left {
-            if let Some(logical_op) = assign.operator.to_logical_operator() {
-                self.count_static_member_logical_assignment(member, logical_op, &assign.right, ctx);
-                return;
-            }
-            self.count_expression(&member.object, ctx);
-            self.count_expression(&assign.right, ctx);
-            // Both plain (IC_SET_PROP) and compound (COMPOUND_MEMBER_*) emit one opcode + 3 ext
-            // words after the key load — no extra instruction for the compound case.
-            ctx.count_load_const(); // key
-            ctx.count_ic_set_with_ext(); // IC_SET_PROP or COMPOUND_MEMBER_* + 3 ext words
-        } else if let oxide_parser::AssignmentTarget::ComputedMemberExpression(member) = &assign.left {
-            if let Some(logical_op) = assign.operator.to_logical_operator() {
-                self.count_computed_member_logical_assignment(member, logical_op, &assign.right, ctx);
-                return;
-            }
-            self.count_expression(&member.object, ctx);
-            self.count_expression(&member.expression, ctx);
-            self.count_expression(&assign.right, ctx);
-            ctx.projected_pc += 1; // SET_PROP_DYNAMIC
-        } else if let oxide_parser::AssignmentTarget::PrivateFieldExpression(member) = &assign.left {
-            self.count_expression(&member.object, ctx);
-            self.count_expression(&assign.right, ctx);
-            ctx.count_load_const(); // private id
-            ctx.count_instr(); // SET_PRIVATE
-        } else if let oxide_parser::AssignmentTarget::AssignmentTargetIdentifier(ati) = &assign.left {
-            let name = ati.name.as_str();
-            // Check if target is an upvalue or captured cell
-            let is_upvalue = ctx.current_upvalue_captures.iter().any(|u| u.name == name);
-            let is_captured = ctx.scopes.symbols.lookup_is_captured(name);
-            if let Some(logical_op) = assign.operator.to_logical_operator() {
-                self.count_identifier_logical_assignment(logical_op, &assign.right, ctx);
-            } else {
-                self.count_expression(&assign.right, ctx);
-                if assign.operator != AssignmentOperator::Assign {
-                    ctx.projected_pc += 1; // COMPOUND_* on var
-                } else if is_upvalue {
-                    ctx.count_instr(); // STORE_UPVALUE
-                } else if is_captured {
-                    ctx.count_instr(); // CELL_SET
-                } else {
-                    ctx.alloc_reg();
-                    ctx.projected_pc += 1; // STORE_VAR
-                }
-            }
-        } else if let oxide_parser::AssignmentTarget::ArrayAssignmentTarget(ap) = &assign.left {
-            self.count_expression(&assign.right, ctx);
-            self.count_array_assignment(ap, ctx);
-        } else if let oxide_parser::AssignmentTarget::ObjectAssignmentTarget(op) = &assign.left {
-            self.count_expression(&assign.right, ctx);
-            self.count_object_assignment(op, ctx);
-        } else {
-            self.count_expression(&assign.right, ctx);
-            ctx.alloc_reg();
-            ctx.projected_pc += 1;
-        }
-    }
-
-    fn count_static_member_logical_assignment(
-        &self, member: &oxide_parser::StaticMemberExpression<'_>, logical_op: LogicalOperator, right: &Expression,
-        ctx: &mut CompileCtx,
-    ) {
-        let id = ctx.next_label_id();
-        self.count_expression(&member.object, ctx);
-        ctx.count_load_const(); // key
-        ctx.count_load_var(); // current value copy
-        ctx.count_ic_instr_with_ext(); // IC_GET_PROP + 3 ext
-        self.count_logical_assign_test(logical_op, id, ctx);
-        self.count_expression(right, ctx);
-        ctx.count_ic_set_with_ext(); // IC_SET_PROP + 3 ext
-        ctx.projected_pc += 1; // LOAD_VAR result <- rhs
-        ctx.labels.label_map.insert(Label::TernaryEnd(id), ctx.projected_pc);
-    }
-
-    fn count_computed_member_logical_assignment(
-        &self, member: &oxide_parser::ComputedMemberExpression<'_>, logical_op: LogicalOperator, right: &Expression,
-        ctx: &mut CompileCtx,
-    ) {
-        let id = ctx.next_label_id();
-        self.count_expression(&member.object, ctx);
-        self.count_expression(&member.expression, ctx);
-        ctx.alloc_reg();
-        ctx.projected_pc += 1; // GET_PROP_DYNAMIC
-        self.count_logical_assign_test(logical_op, id, ctx);
-        self.count_expression(right, ctx);
-        ctx.projected_pc += 1; // SET_PROP_DYNAMIC
-        ctx.projected_pc += 1; // LOAD_VAR result <- rhs
-        ctx.labels.label_map.insert(Label::TernaryEnd(id), ctx.projected_pc);
-    }
-
-    fn count_identifier_logical_assignment(
-        &self, logical_op: LogicalOperator, right: &Expression, ctx: &mut CompileCtx,
-    ) {
-        let id = ctx.next_label_id();
-        ctx.alloc_reg();
-        ctx.projected_pc += 1; // LOAD_VAR result <- current var
-        self.count_logical_assign_test(logical_op, id, ctx);
-        self.count_expression(right, ctx);
-        ctx.projected_pc += 1; // STORE_VAR
-        ctx.projected_pc += 1; // LOAD_VAR result <- rhs
-        ctx.labels.label_map.insert(Label::TernaryEnd(id), ctx.projected_pc);
-    }
-
-    pub(crate) fn count_assignment(&self, expr: &Expression, ctx: &mut CompileCtx) {
-        self.count_assignment_expression(expr, ctx);
-    }
-}
+impl Compiler {}
 
 impl Compiler {
     pub(crate) fn emit_assignment_expression(