Angular compiler alignment: 79.3% match rate (516/651 components)

Major fixes in this session:
- Fix nextContext merging with cached steps bug (74.3% match)
- Add sanitizer argument to property/attribute bindings
- Fix *ngFor "index as i" parser handling
- Fix missing nextContext before reference() calls
- Add expression type handling in resolve_names (Ternary, SafePropertyRead, etc.)
- Fix this. prefix handling in listener expressions
- Fix TwoWayListener variable usage counting

🤖 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/ast/expression.rs

@@ -1024,7 +1024,7 @@ pub struct ExpressionBinding<'a> {
 }
 
 /// An identifier in a template binding.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct TemplateBindingIdentifier<'a> {
     /// The source text.
     pub source: Atom<'a>,

crates/oxc_angular_compiler/src/parser/expression/parser.rs

@@ -681,16 +681,34 @@ impl<'a> Parser<'a> {
         let expr_start = self.peek().map(|t| t.index).unwrap_or(0);
 
         // Check if there's actually an expression to parse
+        // Note: `as` keyword means this is a variable binding like `index as i`,
+        // where `index` is a context variable and `i` is the alias
         if self.at_end()
-            || self.peek().map(|t| t.is_character(';') || t.is_character(',')).unwrap_or(false)
+            || self
+                .peek()
+                .map(|t| t.is_character(';') || t.is_character(',') || t.is_keyword_value("as"))
+                .unwrap_or(false)
         {
-            // No value, like `*ngIf="cond; else elseBlock"` where `else` has no value
+            // No value - either:
+            // - `*ngIf="cond; else elseBlock"` where `else` has no value
+            // - `*ngFor="...; index as i"` where `index` is followed by `as`
             let source_span = AbsoluteSourceSpan::new(keyword_start, keyword_end);
             result.push(TemplateBinding::Expression(ExpressionBinding {
                 source_span,
-                key,
+                key: key.clone(),
                 value: None,
             }));
+
+            // Check for `as` binding after the keyword (e.g., `index as i`)
+            // The value_key_span points to the keyword (e.g., "index")
+            if self.optional_keyword("as") {
+                let value_key_span = AbsoluteSourceSpan::new(keyword_start, keyword_end);
+                let as_binding = self.parse_as_binding(&full_key, keyword_start, value_key_span);
+                if let Some(binding) = as_binding {
+                    result.push(binding);
+                }
+            }
+
             return result;
         }
 
@@ -3199,6 +3217,68 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_parse_template_bindings_ngfor_index_as_i() {
+        // *ngFor="let item of items; index as i"
+        // This tests the case where a context variable (index) uses "as" to create an alias
+        let allocator = Allocator::default();
+        let parser = Parser::new(&allocator, "let item of items; index as i");
+        let key = TemplateBindingIdentifier {
+            source: Atom::from("ngFor"),
+            span: AbsoluteSourceSpan::new(0, 5),
+        };
+        let result = parser.parse_template_bindings(key);
+
+        assert!(result.errors.is_empty(), "Errors: {:?}", result.errors);
+        assert_eq!(result.bindings.len(), 5, "Bindings: {:?}", result.bindings);
+
+        // First: ngFor (no value)
+        match &result.bindings[0] {
+            TemplateBinding::Expression(expr) => {
+                assert_eq!(expr.key.source.as_str(), "ngFor");
+                assert!(expr.value.is_none());
+            }
+            _ => panic!("Expected expression binding for ngFor"),
+        }
+
+        // Second: let item (no value)
+        match &result.bindings[1] {
+            TemplateBinding::Variable(var) => {
+                assert_eq!(var.key.source.as_str(), "item");
+                assert!(var.value.is_none());
+            }
+            _ => panic!("Expected variable binding for item"),
+        }
+
+        // Third: ngForOf = items
+        match &result.bindings[2] {
+            TemplateBinding::Expression(expr) => {
+                assert_eq!(expr.key.source.as_str(), "ngForOf");
+                assert!(expr.value.is_some());
+            }
+            _ => panic!("Expected expression binding for ngForOf"),
+        }
+
+        // Fourth: ngForIndex (no value - context variable reference)
+        match &result.bindings[3] {
+            TemplateBinding::Expression(expr) => {
+                assert_eq!(expr.key.source.as_str(), "ngForIndex");
+                assert!(expr.value.is_none());
+            }
+            _ => panic!("Expected expression binding for ngForIndex"),
+        }
+
+        // Fifth: i = ngForIndex (variable binding from 'as')
+        match &result.bindings[4] {
+            TemplateBinding::Variable(var) => {
+                assert_eq!(var.key.source.as_str(), "i");
+                assert!(var.value.is_some());
+                assert_eq!(var.value.as_ref().unwrap().source.as_str(), "ngForIndex");
+            }
+            _ => panic!("Expected variable binding for i"),
+        }
+    }
+
     // ========================================================================
     // Regex literal tests
     // ========================================================================

crates/oxc_angular_compiler/src/pipeline/conversion.rs

@@ -309,6 +309,9 @@ pub fn convert_ast<'a>(
                 matches!(&pr.receiver, AngularExpression::ImplicitReceiver(_))
                     && !matches!(&pr.receiver, AngularExpression::ThisReceiver(_));
 
+            // Check if the receiver is explicit `this`
+            let is_this_receiver = matches!(&pr.receiver, AngularExpression::ThisReceiver(_));
+
             if is_implicit_receiver {
                 // Implicit receiver property read becomes a lexical read
                 ConvertedExpression::ir(IrExpression::LexicalRead(Box::new_in(
@@ -318,6 +321,32 @@ pub fn convert_ast<'a>(
                     },
                     allocator,
                 )))
+            } else if is_this_receiver {
+                // Explicit `this` property read (e.g., `this.formGroup`) becomes a
+                // ResolvedPropertyRead with Context receiver. This is critical for embedded
+                // views because the resolve phases need to see the ContextExpr(root_xref)
+                // to properly generate nextContext() calls.
+                //
+                // Without this, `this.formGroup` would go directly to OutputExpression::ReadProp,
+                // bypassing the IR phases, and embedded views would incorrectly use `ctx.formGroup`
+                // instead of `ctx_r.formGroup` (after nextContext()).
+                ConvertedExpression::ir(IrExpression::ResolvedPropertyRead(Box::new_in(
+                    crate::ir::expression::ResolvedPropertyReadExpr {
+                        receiver: Box::new_in(
+                            IrExpression::Context(Box::new_in(
+                                ContextExpr {
+                                    view: root_xref,
+                                    source_span: convert_source_span(pr.source_span),
+                                },
+                                allocator,
+                            )),
+                            allocator,
+                        ),
+                        name: pr.name.clone(),
+                        source_span: convert_source_span(pr.source_span),
+                    },
+                    allocator,
+                )))
             } else {
                 // Explicit receiver property read becomes ReadPropExpr
                 let receiver = convert_ast(allocator, &pr.receiver, root_xref, allocate_xref_id);

crates/oxc_angular_compiler/src/pipeline/emit.rs

@@ -299,7 +299,7 @@ pub fn compile_template<'a>(
             DeclareVarStmt {
                 name: constant.name.clone(),
                 value: Some(value),
-                modifiers: StmtModifier::NONE,
+                modifiers: StmtModifier::FINAL, // TypeScript uses const for constant pool entries
                 leading_comment: None,
                 source_span: None,
             },