Angular compiler alignment: 90.2% match rate (587/651 components)

Phase 37: Safe Navigation ResolvedCall Temp Caching
- Fixed `needs_temporary_in_safe_access` to handle `ResolvedCall` expressions
- Added handling for `ResolvedPropertyRead` and `ResolvedKeyedRead` receivers
- Match rate: 83.6% → 84.2% (+4 components)

Phase 38: Pipe Slot Propagation to All Expressions
- Fixed `propagate_slots_to_expressions` to handle DomProperty, TwoWayProperty,
  I18nExpression, Animation, AnimationBinding update ops
- Added Not, Unary, Typeof, Void expression handlers
- Match rate: 84.2% → 87.7% (+23 components)

Phase 39: ResetView Wrapper for TwoWayListener/AnimationListener
- Fixed `add_restore_view_ops_only()` to wrap return statements in `ResetViewExpr`
- Added `wrap_return_statements_in_reset_view()` function
- Match rate: 87.7% → 90.2% (+16 components)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: Brooooooklyn

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

@@ -416,6 +416,18 @@ fn propagate_slots_to_expressions(
                 update_expression_slots(&mut tbs.target, slot_map);
                 update_expression_slots(&mut tbs.value, slot_map);
             }
+            IrExpression::Not(not) => {
+                update_expression_slots(&mut not.expr, slot_map);
+            }
+            IrExpression::Unary(unary) => {
+                update_expression_slots(&mut unary.expr, slot_map);
+            }
+            IrExpression::Typeof(type_of) => {
+                update_expression_slots(&mut type_of.expr, slot_map);
+            }
+            IrExpression::Void(void) => {
+                update_expression_slots(&mut void.expr, slot_map);
+            }
             _ => {}
         }
     }
@@ -502,6 +514,21 @@ fn propagate_slots_to_expressions(
             UpdateOp::StoreLet(store) => {
                 update_expression_slots(&mut store.value, slot_map);
             }
+            UpdateOp::DomProperty(prop) => {
+                update_expression_slots(&mut prop.expression, slot_map);
+            }
+            UpdateOp::TwoWayProperty(prop) => {
+                update_expression_slots(&mut prop.expression, slot_map);
+            }
+            UpdateOp::I18nExpression(expr) => {
+                update_expression_slots(&mut expr.expression, slot_map);
+            }
+            UpdateOp::Animation(anim) => {
+                update_expression_slots(&mut anim.expression, slot_map);
+            }
+            UpdateOp::AnimationBinding(anim) => {
+                update_expression_slots(&mut anim.expression, slot_map);
+            }
             _ => {}
         }
     }

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

@@ -133,6 +133,8 @@ pub fn expand_safe_reads(job: &mut ComponentCompilationJob<'_>) {
 /// - Safe function invocations
 fn needs_temporary_in_safe_access(expr: &IrExpression<'_>) -> bool {
     match expr {
+        // Function calls always need temporaries (they may have side effects)
+        IrExpression::ResolvedCall(_) => true,
         // Safe function invocations always need temporaries
         IrExpression::SafeInvokeFunction(_) => true,
         // Pipe bindings need temporaries (they may have side effects)
@@ -146,6 +148,12 @@ fn needs_temporary_in_safe_access(expr: &IrExpression<'_>) -> bool {
             needs_temporary_in_safe_access(&keyed.receiver)
                 || needs_temporary_in_safe_access(&keyed.index)
         }
+        // Resolved property/keyed reads need to check their receiver
+        IrExpression::ResolvedPropertyRead(prop) => needs_temporary_in_safe_access(&prop.receiver),
+        IrExpression::ResolvedKeyedRead(keyed) => {
+            needs_temporary_in_safe_access(&keyed.receiver)
+                || needs_temporary_in_safe_access(&keyed.key)
+        }
         // Check AST expressions for function calls
         IrExpression::Ast(ast_expr) => needs_temporary_in_ast_expression(ast_expr),
         // Simple expressions don't need temporaries