pass all tests

Author: Brooooooklyn

Cargo.lock

@@ -47,6 +47,8 @@ pub struct HtmlElement<'a> {
     pub name: Atom<'a>,
     /// The element attributes.
     pub attrs: Vec<'a, HtmlAttribute<'a>>,
+    /// Selectorless directives (e.g., @Dir, @Dir(attr="value")).
+    pub directives: Vec<'a, HtmlDirective<'a>>,
     /// The child nodes.
     pub children: Vec<'a, HtmlNode<'a>>,
     /// The source span.
@@ -59,6 +61,23 @@ pub struct HtmlElement<'a> {
     pub is_self_closing: bool,
 }
 
+/// A selectorless directive in the HTML AST (e.g., @Dir or @Dir(attr="value")).
+#[derive(Debug)]
+pub struct HtmlDirective<'a> {
+    /// The directive name (without the @ prefix).
+    pub name: Atom<'a>,
+    /// The directive attributes (inside parentheses, if any).
+    pub attrs: Vec<'a, HtmlAttribute<'a>>,
+    /// The source span for the entire directive.
+    pub span: Span,
+    /// The span for @DirectiveName.
+    pub name_span: Span,
+    /// The span for the opening paren (if present).
+    pub start_paren_span: Option<Span>,
+    /// The span for the closing paren (if present).
+    pub end_paren_span: Option<Span>,
+}
+
 /// An attribute node in the HTML AST.
 #[derive(Debug)]
 pub struct HtmlAttribute<'a> {
@@ -372,6 +391,7 @@ mod tests {
         let child1 = HtmlElement {
             name: Atom::from("span"),
             attrs: Vec::new_in(&allocator),
+            directives: Vec::new_in(&allocator),
             children: Vec::new_in(&allocator),
             span: Span::default(),
             start_span: Span::default(),
@@ -382,6 +402,7 @@ mod tests {
         let child2 = HtmlElement {
             name: Atom::from("p"),
             attrs: Vec::new_in(&allocator),
+            directives: Vec::new_in(&allocator),
             children: Vec::new_in(&allocator),
             span: Span::default(),
             start_span: Span::default(),
@@ -396,6 +417,7 @@ mod tests {
         let root = HtmlElement {
             name: Atom::from("div"),
             attrs: Vec::new_in(&allocator),
+            directives: Vec::new_in(&allocator),
             children,
             span: Span::default(),
             start_span: Span::default(),

crates/oxc_angular_compiler/src/ast/html.rs

@@ -1464,7 +1464,7 @@ impl<'a> Lexer<'a> {
             };
 
             if seen[idx] {
-                self.error(start, &format!("Duplicate regular expression flag '{ch}'"));
+                self.error(start, &format!("Duplicate regular expression flag \"{ch}\""));
                 return false;
             }
             seen[idx] = true;

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

@@ -463,10 +463,12 @@ impl<'a> Parser<'a> {
             // Parse the primary expression (e.g., `condition` in `*ngIf="condition"`)
             let start = self.peek().map(|t| t.index).unwrap_or(0);
             let value = self.parse_pipe_for_template_binding();
-            // For template bindings, source includes trailing content up to end of next token
-            let end = self.peek().map(|t| t.end).unwrap_or(self.source.len() as u32);
+            // Value source is just the expression (up to current_end_index)
+            let value_end = self.current_end_index();
+            // Source span extends to start of next token (includes trailing whitespace)
+            let source_end = self.peek().map(|t| t.index).unwrap_or(self.source.len() as u32);
 
-            let value_source = &self.source[start as usize..end as usize];
+            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)),
@@ -480,13 +482,17 @@ impl<'a> Parser<'a> {
                 template_key.span.end,
             );
             let source_span =
-                AbsoluteSourceSpan::new(template_key.span.start, self.absolute_offset + end);
+                AbsoluteSourceSpan::new(template_key.span.start, self.absolute_offset + source_end);
             let expr_binding = ExpressionBinding { source_span, key, value: Some(ast_with_source) };
             bindings.push(TemplateBinding::Expression(expr_binding));
 
             // Check for `as` binding after the primary expression (e.g., `*ngIf="cond | async as result"`)
             if self.optional_keyword("as") {
-                let as_binding = self.parse_as_binding(&template_key.source);
+                let as_binding = self.parse_as_binding(
+                    &template_key.source,
+                    template_key.span.start,
+                    template_key.span,
+                );
                 if let Some(binding) = as_binding {
                     bindings.push(binding);
                 }
@@ -567,7 +573,11 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses a `let` binding: `let item` or `let i = index`.
-    fn parse_let_binding(&mut self, template_key: &str) -> Option<TemplateBinding<'a>> {
+    fn parse_let_binding(&mut self, _template_key: &str) -> Option<TemplateBinding<'a>> {
+        // Record the position of 'let' keyword before consuming it
+        let let_token = self.peek()?.clone();
+        let let_start = self.absolute_offset + let_token.index;
+
         // Consume `let` keyword
         if !self.optional_keyword("let") {
             return None;
@@ -587,7 +597,7 @@ impl<'a> Parser<'a> {
         let key = self.make_template_binding_identifier(key_source.as_str(), key_start, key_end);
 
         // Check for `=` (e.g., `let i = index`)
-        let value = if self.optional_operator("=") {
+        let (value, source_end) = if self.optional_operator("=") {
             let value_token = self.peek()?.clone();
             if !value_token.is_identifier() && !value_token.is_keyword() {
                 self.error("Expected identifier after '='");
@@ -596,20 +606,25 @@ impl<'a> Parser<'a> {
             let value_start = self.absolute_offset + value_token.index;
             let value_end = self.absolute_offset + value_token.end;
 
-            // For `let i = index`, the value becomes `ngForIndex` (templateKey + capitalized value)
-            let value_source =
-                format!("{}{}", template_key, capitalize_first(value_token.str_value.as_str()));
+            // Use the value as-is (e.g., `let i = index` -> value is "index")
+            let value_source = value_token.str_value.as_str();
             self.advance();
-            Some(self.make_template_binding_identifier(&value_source, value_start, value_end))
+            // Source span extends to include the value
+            (
+                Some(self.make_template_binding_identifier(value_source, value_start, value_end)),
+                value_end,
+            )
         } else {
             // For bare `let item`, value is `$implicit`
-            Some(self.make_template_binding_identifier("$implicit", key_start, key_start))
+            // Source span includes trailing space after the variable name
+            (
+                Some(self.make_template_binding_identifier("$implicit", key_start, key_start)),
+                key_end + 1,
+            )
         };
 
-        let source_span = AbsoluteSourceSpan::new(
-            key_start,
-            value.as_ref().map(|v| v.span.end).unwrap_or(key_end),
-        );
+        // Source span starts from 'let' keyword
+        let source_span = AbsoluteSourceSpan::new(let_start, source_end);
         Some(TemplateBinding::Variable(VariableBinding { source_span, key, value }))
     }
 
@@ -655,17 +670,31 @@ impl<'a> Parser<'a> {
         }
 
         let value = self.parse_pipe_for_template_binding();
-        let expr_end = self.peek().map(|t| t.end).unwrap_or(self.source.len() as u32);
+        // Value source is just the expression (up to current_end_index)
+        let value_end = self.current_end_index();
+
+        // Source span extends to start of next binding (includes trailing separator and whitespace)
+        // If the next token is `;` or `,`, consume it and use the start of the following token
+        let source_end =
+            if self.peek().map(|t| t.is_character(';') || t.is_character(',')).unwrap_or(false) {
+                // Consume the separator
+                self.advance();
+                // Source span extends to start of next token (after separator)
+                self.peek().map(|t| t.index).unwrap_or(self.source.len() as u32)
+            } else {
+                // No separator, source span extends to start of next token
+                self.peek().map(|t| t.index).unwrap_or(self.source.len() as u32)
+            };
 
-        let value_source = &self.source[expr_start as usize..expr_end as usize];
+        let value_source = &self.source[expr_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 + expr_start,
         };
 
-        let source_span = AbsoluteSourceSpan::new(keyword_start, self.absolute_offset + expr_end);
+        let source_span = AbsoluteSourceSpan::new(keyword_start, self.absolute_offset + source_end);
         result.push(TemplateBinding::Expression(ExpressionBinding {
             source_span,
             key,
@@ -674,7 +703,9 @@ impl<'a> Parser<'a> {
 
         // Check for `as` binding after the expression
         if self.optional_keyword("as") {
-            let as_binding = self.parse_as_binding(&full_key);
+            // The value_key_span points to the keyword (e.g., "of" in "of items")
+            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);
             }
@@ -684,7 +715,14 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses an `as` binding: `... as alias`.
-    fn parse_as_binding(&mut self, value_key: &str) -> Option<TemplateBinding<'a>> {
+    /// `source_span_start` is the start of the source span (directive name start).
+    /// `value_key_span` is the span of the directive name for the value.
+    fn parse_as_binding(
+        &mut self,
+        value_key: &str,
+        source_span_start: u32,
+        value_key_span: AbsoluteSourceSpan,
+    ) -> Option<TemplateBinding<'a>> {
         // Get alias name
         let alias_token = self.peek()?.clone();
         if !alias_token.is_identifier() && !alias_token.is_keyword() {
@@ -698,9 +736,15 @@ impl<'a> Parser<'a> {
 
         let key =
             self.make_template_binding_identifier(alias_source.as_str(), alias_start, alias_end);
-        let value = self.make_template_binding_identifier(value_key, alias_start, alias_end);
+        // The value's span should point to the directive name, not the alias
+        let value = self.make_template_binding_identifier(
+            value_key,
+            value_key_span.start,
+            value_key_span.end,
+        );
 
-        let source_span = AbsoluteSourceSpan::new(alias_start, alias_end);
+        // Source span extends from directive name start to alias end
+        let source_span = AbsoluteSourceSpan::new(source_span_start, alias_end);
         Some(TemplateBinding::Variable(VariableBinding { source_span, key, value: Some(value) }))
     }
 
@@ -1855,11 +1899,23 @@ impl<'a> Parser<'a> {
             }
         }
 
-        // No identifier found after dot - emit error but preserve the incomplete access
+        // No identifier found after dot - emit errors but preserve the incomplete access
         // Set WRITABLE context so skip() will stop at assignment operators
         // Report error at the receiver's span end (right after the dot)
         let receiver_end = receiver.span().end;
         self.context |= ParseContextFlags::WRITABLE;
+
+        // First, emit error about what unexpected token was found (matches Angular's expectIdentifierOrKeyword)
+        if let Some(token) = self.peek() {
+            self.error(&format!(
+                "Unexpected token {}, expected identifier or keyword",
+                token.str_value
+            ));
+        } else {
+            self.error("Unexpected end of input, expected identifier or keyword");
+        }
+
+        // Then emit the "Expected identifier for property access" error
         self.error_at("Expected identifier for property access", receiver_end);
         self.context ^= ParseContextFlags::WRITABLE;
 
@@ -3043,12 +3099,12 @@ mod tests {
             _ => panic!("Expected expression binding"),
         }
 
-        // Fourth: let i = ngForIndex
+        // Fourth: let i = index (value as-is, not prefixed with directive name)
         match &result.bindings[3] {
             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");
+                assert_eq!(var.value.as_ref().unwrap().source.as_str(), "index");
             }
             _ => panic!("Expected variable binding"),
         }