fix: remaining _unnamed_N variable references and missing Animation handler_ops

- Add 7 missing expression types (Not, Unary, Typeof, Void,
  ResolvedTemplateLiteral, ArrowFunction, Parenthesized) to
  visit_all_expressions in variable_optimization.rs, fixing incorrect
  context variable inlining when expressions like `!(x)` wrapped
  ReadVariable references
- Add CreateOp::Animation handler_ops traversal to resolve_contexts,
  next_context_merging, allocate_slots, strip_nonrequired_parentheses,
  and regular_expression_optimization phases
- Add TwoWayListener/AnimationListener to regular_expression_optimization

Eliminates all _unnamed_N occurrences across 5846 compiled ClickUp files.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/pipeline/phases/allocate_slots.rs

@@ -802,6 +802,11 @@ fn propagate_slots_to_expressions(
                     update_op_expression_slots(handler_op, slot_map);
                 }
             }
+            CreateOp::Animation(animation) => {
+                for handler_op in animation.handler_ops.iter_mut() {
+                    update_op_expression_slots(handler_op, slot_map);
+                }
+            }
             _ => {}
         }
     }
@@ -825,6 +830,11 @@ fn propagate_slots_to_expressions(
                         update_op_expression_slots(handler_op, slot_map);
                     }
                 }
+                CreateOp::Animation(animation) => {
+                    for handler_op in animation.handler_ops.iter_mut() {
+                        update_op_expression_slots(handler_op, slot_map);
+                    }
+                }
                 _ => {}
             }
         }

crates/oxc_angular_compiler/src/pipeline/phases/next_context_merging.rs

@@ -42,6 +42,9 @@ pub fn merge_next_context_expressions(job: &mut ComponentCompilationJob<'_>) {
                     CreateOp::AnimationListener(listener) => {
                         merge_next_contexts_in_handler_ops(&mut listener.handler_ops);
                     }
+                    CreateOp::Animation(animation) => {
+                        merge_next_contexts_in_handler_ops(&mut animation.handler_ops);
+                    }
                     _ => {}
                 }
             }

crates/oxc_angular_compiler/src/pipeline/phases/regular_expression_optimization.rs

@@ -110,6 +110,21 @@ fn collect_and_pool_regexes_from_create_op<'a>(
                 collect_and_pool_regexes_from_update_op(handler_op, pool, replacements);
             }
         }
+        CreateOp::TwoWayListener(listener) => {
+            for handler_op in listener.handler_ops.iter() {
+                collect_and_pool_regexes_from_update_op(handler_op, pool, replacements);
+            }
+        }
+        CreateOp::AnimationListener(listener) => {
+            for handler_op in listener.handler_ops.iter() {
+                collect_and_pool_regexes_from_update_op(handler_op, pool, replacements);
+            }
+        }
+        CreateOp::Animation(animation) => {
+            for handler_op in animation.handler_ops.iter() {
+                collect_and_pool_regexes_from_update_op(handler_op, pool, replacements);
+            }
+        }
         _ => {}
     }
 }
@@ -187,6 +202,21 @@ fn transform_regexes_in_create_op<'a>(
                 transform_regexes_in_update_op(handler_op, allocator, replacements);
             }
         }
+        CreateOp::TwoWayListener(listener) => {
+            for handler_op in listener.handler_ops.iter_mut() {
+                transform_regexes_in_update_op(handler_op, allocator, replacements);
+            }
+        }
+        CreateOp::AnimationListener(listener) => {
+            for handler_op in listener.handler_ops.iter_mut() {
+                transform_regexes_in_update_op(handler_op, allocator, replacements);
+            }
+        }
+        CreateOp::Animation(animation) => {
+            for handler_op in animation.handler_ops.iter_mut() {
+                transform_regexes_in_update_op(handler_op, allocator, replacements);
+            }
+        }
         _ => {}
     }
 }

crates/oxc_angular_compiler/src/pipeline/phases/resolve_contexts.rs

@@ -112,6 +112,16 @@ fn process_lexical_scope_create<'a>(
                     &mut None,
                 );
             }
+            CreateOp::Animation(animation) => {
+                // Animation has no handler_expression
+                process_listener_handler_ops(
+                    allocator,
+                    view_xref,
+                    is_root,
+                    &mut animation.handler_ops,
+                    &mut None,
+                );
+            }
             _ => {
                 transform_expressions_in_create_op(
                     op,

crates/oxc_angular_compiler/src/pipeline/phases/strip_nonrequired_parentheses.rs

@@ -120,6 +120,11 @@ fn visit_expressions_for_required_parens(
                 visit_update_expressions_for_required_parens(handler_op, required);
             }
         }
+        CreateOp::Animation(a) => {
+            for handler_op in a.handler_ops.iter() {
+                visit_update_expressions_for_required_parens(handler_op, required);
+            }
+        }
         CreateOp::AnimationString(a) => {
             check_ir_expression_for_required_parens(&a.expression, required);
         }

crates/oxc_angular_compiler/src/pipeline/phases/variable_optimization.rs

@@ -362,6 +362,13 @@ fn collect_create_op_fences(op: &CreateOp<'_>) -> Fence {
             }
             fences
         }
+        CreateOp::Animation(animation) => {
+            let mut fences = Fence::NONE;
+            for handler_op in animation.handler_ops.iter() {
+                fences |= collect_op_fences(handler_op);
+            }
+            fences
+        }
         // DeclareLet doesn't have expressions at the create phase
         CreateOp::DeclareLet(_) => Fence::NONE,
         _ => Fence::NONE,
@@ -522,6 +529,13 @@ fn inline_always_inline_in_listener_handler_ops<'a>(
                     allocator,
                 );
             }
+            CreateOp::Animation(animation) => {
+                inline_always_inline_in_handler_ops_and_expr(
+                    &mut animation.handler_ops,
+                    None, // Animation doesn't have handler_expression
+                    allocator,
+                );
+            }
             CreateOp::RepeaterCreate(repeater) => {
                 if let Some(track_by_ops) = &mut repeater.track_by_ops {
                     inline_always_inline_in_handler_ops_and_expr(track_by_ops, None, allocator);
@@ -1408,6 +1422,29 @@ where
                 visit_all_expressions(value, visitor);
             }
         }
+        IrExpression::Not(n) => {
+            visit_all_expressions(&n.expr, visitor);
+        }
+        IrExpression::Unary(u) => {
+            visit_all_expressions(&u.expr, visitor);
+        }
+        IrExpression::Typeof(t) => {
+            visit_all_expressions(&t.expr, visitor);
+        }
+        IrExpression::Void(v) => {
+            visit_all_expressions(&v.expr, visitor);
+        }
+        IrExpression::ResolvedTemplateLiteral(rtl) => {
+            for e in rtl.expressions.iter() {
+                visit_all_expressions(e, visitor);
+            }
+        }
+        IrExpression::ArrowFunction(arrow_fn) => {
+            visit_all_expressions(&arrow_fn.body, visitor);
+        }
+        IrExpression::Parenthesized(paren) => {
+            visit_all_expressions(&paren.expr, visitor);
+        }
         // Leaf expressions
         _ => {}
     }
@@ -2215,6 +2252,11 @@ fn count_in_create_op(op: &CreateOp<'_>, counts: &mut HashMap<XrefId, usize>) {
                 count_in_update_op(handler_op, counts);
             }
         }
+        CreateOp::Animation(animation) => {
+            for handler_op in animation.handler_ops.iter() {
+                count_in_update_op(handler_op, counts);
+            }
+        }
         CreateOp::Conditional(_cond) => {
             // ConditionalOp (CREATE) no longer has test/branches/processed_expression.
             // Those are now on ConditionalUpdateOp (UPDATE) and handled in count_in_update_op.
@@ -2994,6 +3036,11 @@ fn transform_expressions_in_create_op<'a, F>(
                 transform_expressions_in_update_op(handler_op, allocator, &mut transform);
             }
         }
+        CreateOp::Animation(animation) => {
+            for handler_op in animation.handler_ops.iter_mut() {
+                transform_expressions_in_update_op(handler_op, allocator, &mut transform);
+            }
+        }
         CreateOp::RepeaterCreate(rep) => {
             let new_expr = transform_expression(&rep.track, allocator, &mut transform);
             *rep.track = new_expr;