Review 1

Author: Brooooooklyn

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

@@ -1272,7 +1272,6 @@ impl<'a> Lexer<'a> {
         len: u32,
         escape_start: u32,
     ) -> Result<char, (u32, u32, String)> {
-        let _start_pos = self.index;
         let mut value = 0u32;
         let mut count = 0u32;
 

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

@@ -469,12 +469,6 @@ impl<'a> Parser<'a> {
             let source_end = self.peek().map(|t| t.index).unwrap_or(self.source.len() as u32);
 
             let value_source = &self.source[start as usize..value_end as usize];
-            let ast_with_source = ASTWithSource {
-                ast: value,
-                source: Some(Atom::from_in(value_source, self.allocator)),
-                location: Atom::from_in("", self.allocator),
-                absolute_offset: self.absolute_offset + start,
-            };
 
             let key = self.make_template_binding_identifier(
                 &template_key.source,
@@ -483,7 +477,20 @@ impl<'a> Parser<'a> {
             );
             let source_span =
                 AbsoluteSourceSpan::new(template_key.span.start, self.absolute_offset + source_end);
-            let expr_binding = ExpressionBinding { source_span, key, value: Some(ast_with_source) };
+
+            // Angular expects None for empty values (e.g., `*a=""`)
+            let expr_value = if value_source.is_empty() {
+                None
+            } else {
+                Some(ASTWithSource {
+                    ast: value,
+                    source: Some(Atom::from_in(value_source, self.allocator)),
+                    location: Atom::from_in("", self.allocator),
+                    absolute_offset: self.absolute_offset + start,
+                })
+            };
+
+            let expr_binding = ExpressionBinding { source_span, key, value: expr_value };
             bindings.push(TemplateBinding::Expression(expr_binding));
 
             // Check for `as` binding after the primary expression (e.g., `*ngIf="cond | async as result"`)
@@ -615,12 +622,9 @@ impl<'a> Parser<'a> {
                 value_end,
             )
         } else {
-            // For bare `let item`, value is `$implicit`
+            // For bare `let item`, Angular expects no value (None)
             // Source span includes trailing space after the variable name
-            (
-                Some(self.make_template_binding_identifier("$implicit", key_start, key_start)),
-                key_end + 1,
-            )
+            (None, key_end + 1)
         };
 
         // Source span starts from 'let' keyword
@@ -3041,12 +3045,11 @@ mod tests {
             _ => panic!("Expected expression binding"),
         }
 
-        // Second binding: let item (variable binding with $implicit)
+        // Second binding: let item (variable binding with no value - Angular behavior)
         match &result.bindings[1] {
             TemplateBinding::Variable(var) => {
                 assert_eq!(var.key.source.as_str(), "item");
-                assert!(var.value.is_some());
-                assert_eq!(var.value.as_ref().unwrap().source.as_str(), "$implicit");
+                assert!(var.value.is_none());
             }
             _ => panic!("Expected variable binding"),
         }
@@ -3083,10 +3086,11 @@ mod tests {
             _ => panic!("Expected expression binding"),
         }
 
-        // Second: let item ($implicit)
+        // 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"),
         }

crates/oxc_angular_compiler/src/parser/html/entities.rs

@@ -45,6 +45,55 @@ pub fn decode_entity(entity: &str) -> Option<String> {
     }
 }
 
+/// Decodes all HTML entities in a string.
+///
+/// For backward compatibility (matching Angular's behavior), this decodes
+/// HTML entities that appear in interpolation expressions.
+///
+/// Pattern: `&entity;` where entity can be:
+/// - Named: `amp`, `lt`, `gt`, `quot`, etc.
+/// - Decimal: `#123`
+/// - Hex: `#x7B` or `#X7B`
+pub fn decode_entities_in_string(s: &str) -> String {
+    let mut result = String::with_capacity(s.len());
+    let mut chars = s.char_indices().peekable();
+
+    while let Some((i, ch)) = chars.next() {
+        if ch == '&' {
+            // Look for entity pattern: &...;
+            let mut entity_end = None;
+            let remaining = &s[i..];
+
+            // Find the semicolon
+            for (j, c) in remaining.char_indices() {
+                if c == ';' {
+                    entity_end = Some(j);
+                    break;
+                }
+                // Entities shouldn't be too long, and should contain valid chars
+                if j > 32 || (!c.is_ascii_alphanumeric() && c != '#' && c != '&') {
+                    break;
+                }
+            }
+
+            if let Some(end) = entity_end {
+                let entity = &remaining[..=end];
+                if let Some(decoded) = decode_entity(entity) {
+                    result.push_str(&decoded);
+                    // Skip past the entity in the input
+                    for _ in 0..end {
+                        chars.next();
+                    }
+                    continue;
+                }
+            }
+        }
+        result.push(ch);
+    }
+
+    result
+}
+
 /// Creates the named entities map.
 fn create_named_entities() -> FxHashMap<&'static str, &'static str> {
     let mut map = FxHashMap::default();