align r3 transformer

Author: Brooooooklyn

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

@@ -34,6 +34,55 @@ pub struct TemplateBindingParseResult<'a> {
     pub warnings: std::vec::Vec<String>,
 }
 
+/// Result of stripping comments from an expression.
+pub struct StripCommentsResult<'a> {
+    /// The stripped expression (without comment).
+    pub stripped: &'a str,
+    /// Whether a comment was found.
+    pub has_comments: bool,
+    /// The position where the comment starts (if any).
+    pub comment_start: Option<usize>,
+}
+
+/// Finds the start of a `//` comment, respecting string quotes.
+///
+/// Returns `None` if no comment is found, or the byte position of `//`.
+pub fn find_comment_start(input: &str) -> Option<usize> {
+    let bytes = input.as_bytes();
+    let mut outer_quote: Option<u8> = None;
+
+    for i in 0..bytes.len().saturating_sub(1) {
+        let ch = bytes[i];
+        let next_ch = bytes[i + 1];
+
+        // Check for // outside of quotes
+        if ch == b'/' && next_ch == b'/' && outer_quote.is_none() {
+            return Some(i);
+        }
+
+        // Track quote state
+        if outer_quote == Some(ch) {
+            outer_quote = None;
+        } else if outer_quote.is_none() && (ch == b'\'' || ch == b'"' || ch == b'`') {
+            outer_quote = Some(ch);
+        }
+    }
+
+    None
+}
+
+/// Strips `//` comments from an expression, respecting string quotes.
+pub fn strip_comments(input: &str) -> StripCommentsResult<'_> {
+    match find_comment_start(input) {
+        Some(pos) => StripCommentsResult {
+            stripped: &input[..pos],
+            has_comments: true,
+            comment_start: Some(pos),
+        },
+        None => StripCommentsResult { stripped: input, has_comments: false, comment_start: None },
+    }
+}
+
 /// A piece of text with start and end positions.
 #[derive(Debug, Clone)]
 pub struct InterpolationPiece {

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

@@ -160,21 +160,39 @@ impl<'a> HtmlParser<'a> {
             self.parse_and_add_node();
         }
 
-        // Report unclosed blocks and elements
-        // Components (uppercase first letter) are implicitly closed without error
-        for container in &self.container_stack {
+        // Close all remaining containers at EOF (error recovery)
+        // This ensures we still produce AST nodes even for unclosed elements
+        // Process from top of stack (innermost) to bottom (outermost)
+        while let Some(container) = self.container_stack.pop() {
             match container {
                 ContainerIndex::Block(idx) => {
-                    let block = &self.blocks[*idx];
+                    let block = &self.blocks[idx];
                     let err = self.make_error(
                         block.span.start,
                         format!("Unclosed block \"@{}\"", block.name),
                     );
                     self.errors.push(err);
+
+                    // Convert block to node and add to parent
+                    let block = std::mem::replace(
+                        &mut self.blocks[idx],
+                        HtmlBlock {
+                            block_type: BlockType::If,
+                            name: Atom::from(""),
+                            parameters: Vec::new_in(self.allocator),
+                            children: Vec::new_in(self.allocator),
+                            span: Span::new(0, 0),
+                            name_span: Span::new(0, 0),
+                            start_span: Span::new(0, 0),
+                            end_span: None,
+                        },
+                    );
+                    let node = HtmlNode::Block(Box::new_in(block, self.allocator));
+                    self.add_to_parent(node);
                 }
                 ContainerIndex::Element(idx) => {
-                    let element = &self.elements[*idx];
-                    // Components (first char is uppercase or underscore) are implicitly closed
+                    let element = &self.elements[idx];
+                    // Components (first char is uppercase or underscore) are implicitly closed without error
                     let first_char = element.name.chars().next().unwrap_or('a');
                     if !first_char.is_ascii_uppercase() && first_char != '_' {
                         let err = self.make_error(
@@ -183,6 +201,23 @@ impl<'a> HtmlParser<'a> {
                         );
                         self.errors.push(err);
                     }
+
+                    // Convert element to node and add to parent
+                    let element = std::mem::replace(
+                        &mut self.elements[idx],
+                        HtmlElement {
+                            name: Atom::from(""),
+                            attrs: Vec::new_in(self.allocator),
+                            directives: Vec::new_in(self.allocator),
+                            children: Vec::new_in(self.allocator),
+                            span: Span::new(0, 0),
+                            start_span: Span::new(0, 0),
+                            end_span: None,
+                            is_self_closing: false,
+                        },
+                    );
+                    let node = HtmlNode::Element(Box::new_in(element, self.allocator));
+                    self.add_to_parent(node);
                 }
             }
         }