save

Author: Brooooooklyn

crates/oxc_angular_compiler/src/ir/list.rs

@@ -276,6 +276,15 @@ impl<'a, T: Op> OpList<'a, T> {
     /// # Safety
     /// The `old` pointer must point to a valid operation in this list.
     pub unsafe fn replace(&mut self, old: NonNull<T>, new_op: T) {
+        // SAFETY: Same preconditions apply to both functions
+        let _ = unsafe { self.replace_returning_new(old, new_op) };
+    }
+
+    /// Replaces an operation with another operation and returns a pointer to the new operation.
+    ///
+    /// # Safety
+    /// The `old` pointer must point to a valid operation in this list.
+    pub unsafe fn replace_returning_new(&mut self, old: NonNull<T>, new_op: T) -> NonNull<T> {
         let new_ptr = self.alloc_op(new_op);
 
         // SAFETY: old is a valid pointer in this list
@@ -302,6 +311,8 @@ impl<'a, T: Op> OpList<'a, T> {
             (*old.as_ptr()).set_prev(None);
             (*old.as_ptr()).set_next(None);
         }
+
+        new_ptr
     }
 
     /// Prepends all operations from another list to the front of this list.
@@ -516,7 +527,11 @@ impl<'b, 'a, T: Op> OpListCursor<'b, 'a, T> {
     pub fn replace_current(&mut self, op: T) {
         if let Some(current) = self.current {
             // SAFETY: current is valid as it was obtained from the list
-            unsafe { self.list.replace(current, op) };
+            // We need to update self.current to point to the new node, since
+            // the old node's next/prev pointers are cleared by replace().
+            // This ensures move_next() works correctly after replacement.
+            let new_ptr = unsafe { self.list.replace_returning_new(current, op) };
+            self.current = Some(new_ptr);
         }
     }
 }

crates/oxc_angular_compiler/src/ir/ops.rs

@@ -667,6 +667,9 @@ pub struct ElementStartOp<'a> {
     pub attribute_namespace: Option<Atom<'a>>,
     /// Local references attached to this element.
     pub local_refs: Vec<'a, LocalRef<'a>>,
+    /// Index into the consts array for local refs.
+    /// Set by local_refs phase.
+    pub local_refs_index: Option<u32>,
     /// Non-bindable element.
     pub non_bindable: bool,
     /// I18n placeholder data (start_name and close_name for paired tags).
@@ -692,6 +695,9 @@ pub struct ElementOp<'a> {
     pub attribute_namespace: Option<Atom<'a>>,
     /// Local references.
     pub local_refs: Vec<'a, LocalRef<'a>>,
+    /// Index into the consts array for local refs.
+    /// Set by local_refs phase.
+    pub local_refs_index: Option<u32>,
     /// Non-bindable element.
     pub non_bindable: bool,
     /// I18n placeholder data (start_name and close_name for paired tags).
@@ -757,6 +763,9 @@ pub struct ContainerStartOp<'a> {
     pub xref: XrefId,
     /// Assigned slot.
     pub slot: Option<SlotId>,
+    /// Index into the consts array for attributes.
+    /// Set by const_collection phase.
+    pub attributes: Option<u32>,
     /// Local references.
     pub local_refs: Vec<'a, LocalRef<'a>>,
     /// Non-bindable container.
@@ -774,6 +783,9 @@ pub struct ContainerOp<'a> {
     pub xref: XrefId,
     /// Assigned slot.
     pub slot: Option<SlotId>,
+    /// Index into the consts array for attributes.
+    /// Set by const_collection phase.
+    pub attributes: Option<u32>,
     /// Local references.
     pub local_refs: Vec<'a, LocalRef<'a>>,
     /// Non-bindable container.
@@ -840,6 +852,9 @@ pub struct ConditionalOp<'a> {
     pub vars: Option<u32>,
     /// Local references on this element.
     pub local_refs: Vec<'a, LocalRef<'a>>,
+    /// Index into the consts array for local refs.
+    /// Set by local_refs phase.
+    pub local_refs_index: Option<u32>,
     /// I18n placeholder data (start_name and close_name for @if/@switch blocks).
     pub i18n_placeholder: Option<I18nPlaceholder<'a>>,
     /// Index into the consts array for element attributes.
@@ -868,6 +883,8 @@ pub struct ConditionalBranchCreateOp<'a> {
     pub template_kind: TemplateKind,
     /// Function name suffix.
     pub fn_name_suffix: Atom<'a>,
+    /// HTML tag name (for content projection).
+    pub tag: Option<Atom<'a>>,
     /// The number of declaration slots used by this branch.
     /// Set by allocate_slots phase.
     pub decls: Option<u32>,
@@ -876,6 +893,9 @@ pub struct ConditionalBranchCreateOp<'a> {
     pub vars: Option<u32>,
     /// Local references on this branch.
     pub local_refs: Vec<'a, LocalRef<'a>>,
+    /// Index into the consts array for local refs.
+    /// Set by local_refs phase.
+    pub local_refs_index: Option<u32>,
     /// I18n placeholder data (start_name and close_name for paired tags).
     pub i18n_placeholder: Option<I18nPlaceholder<'a>>,
     /// Index into the consts array for element attributes.
@@ -1165,8 +1185,14 @@ pub struct RepeaterCreateOp<'a> {
     pub var_names: RepeaterVarNames<'a>,
     /// HTML tag name (for content projection).
     pub tag: Option<Atom<'a>>,
+    /// Const index for attributes (for content projection).
+    /// Set by const_collection phase.
+    pub attributes: Option<u32>,
     /// HTML tag name for empty view (for content projection).
     pub empty_tag: Option<Atom<'a>>,
+    /// Const index for empty view attributes (for content projection).
+    /// Set by const_collection phase.
+    pub empty_attributes: Option<u32>,
     /// I18n placeholder data (start_name and close_name for @for block).
     pub i18n_placeholder: Option<I18nPlaceholder<'a>>,
     /// I18n placeholder data for @empty view.

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

@@ -175,7 +175,9 @@ impl<'a> BindingParser<'a> {
         start_delimiter: &str,
         end_delimiter: &str,
     ) -> Option<ParseResult<'a>> {
-        let parser = Parser::with_offset(self.allocator, value, span.start);
+        // Use for_interpolation to avoid tokenizing the full input including
+        // literal text like "/ " before interpolations.
+        let parser = Parser::for_interpolation(self.allocator, value, span.start);
         parser.parse_interpolation(start_delimiter, end_delimiter)
     }
 

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

@@ -142,6 +142,27 @@ impl<'a> Parser<'a> {
         parser
     }
 
+    /// Creates a parser for interpolation parsing without tokenizing.
+    ///
+    /// Interpolation parsing doesn't need tokenization of the full input because
+    /// it manually splits the text to find `{{` and `}}` boundaries, then creates
+    /// sub-parsers for each expression part.
+    pub fn for_interpolation(allocator: &'a Allocator, source: &'a str, offset: u32) -> Self {
+        Self {
+            allocator,
+            tokens: std::vec::Vec::new(),
+            index: 0,
+            source,
+            errors: std::vec::Vec::new(),
+            absolute_offset: offset,
+            rparens_expected: 0,
+            rbrackets_expected: 0,
+            rbraces_expected: 0,
+            context: ParseContextFlags::NONE,
+            action_mode: false,
+        }
+    }
+
     /// Strips single-line comments (`//`) from the input.
     ///
     /// Comments are only recognized outside of quoted strings.

crates/oxc_angular_compiler/src/pipeline/constant_pool.rs

@@ -195,7 +195,7 @@ impl<'a> ConstantPool<'a> {
         }
 
         let index = self.values.len() as u32;
-        let name = self.generate_name("_pf");
+        let name = self.generate_name("_c");
 
         // Generate parameter names: a0, a1, a2, ...
         let mut params = Vec::with_capacity_in(num_args as usize, self.allocator);