save

Author: Brooooooklyn

crates/oxc_angular_compiler/src/ast/r3.rs

@@ -29,6 +29,16 @@ pub enum I18nMeta<'a> {
 /// An i18n message containing translatable content.
 #[derive(Debug)]
 pub struct I18nMessage<'a> {
+    /// Unique instance ID for this message.
+    ///
+    /// This ID is used to track message identity across moves/copies. It ensures that
+    /// when an i18n attribute is copied (e.g., from element to conditional via
+    /// `ingestControlFlowInsertionPoint`), both references can be linked to the same
+    /// i18n context. Without this, Rust's move semantics would cause pointer-based
+    /// identity checks to fail.
+    ///
+    /// Assigned during parsing and must be unique per compilation unit.
+    pub instance_id: u32,
     /// Message AST nodes.
     pub nodes: Vec<'a, I18nNode<'a>>,
     /// The meaning of the message (for disambiguation).
@@ -178,6 +188,9 @@ impl<'a> I18nMeta<'a> {
 
 impl<'a> I18nMessage<'a> {
     /// Creates a deep clone of this i18n message using the provided allocator.
+    ///
+    /// Note: This preserves the `instance_id` so that cloned messages maintain
+    /// their identity for i18n context sharing.
     pub fn clone_in(&self, allocator: &'a Allocator) -> Self {
         let mut nodes = Vec::new_in(allocator);
         for node in self.nodes.iter() {
@@ -188,6 +201,7 @@ impl<'a> I18nMessage<'a> {
             legacy_ids.push(id.clone());
         }
         I18nMessage {
+            instance_id: self.instance_id,
             nodes,
             meaning: self.meaning.clone(),
             description: self.description.clone(),

crates/oxc_angular_compiler/src/ir/ops.rs

@@ -1839,6 +1839,8 @@ pub struct AnimationStringOp<'a> {
     pub target: XrefId,
     /// Animation name.
     pub name: Atom<'a>,
+    /// Animation kind (enter or leave).
+    pub animation_kind: AnimationKind,
     /// Expression.
     pub expression: Box<'a, IrExpression<'a>>,
 }

crates/oxc_angular_compiler/src/pipeline/compilation.rs

@@ -138,6 +138,14 @@ pub struct ComponentCompilationJob<'a> {
     pub is_i18n_template: bool,
     /// Metadata for i18n messages keyed by xref.
     pub i18n_message_metadata: FxHashMap<XrefId, I18nMessageMetadata<'a>>,
+    /// Cache of i18n xrefs keyed by message identity (custom_id or computed id).
+    ///
+    /// This ensures that when the same i18n message is encountered multiple times
+    /// (e.g., when copying attributes from an element to its conditional), they
+    /// share the same xref. This is crucial for correct const deduplication because
+    /// the i18n_const_collection phase assigns i18n variable names (I18N_0, I18N_1)
+    /// based on the context xref, which in turn depends on the message xref.
+    pub i18n_xref_by_message_key: FxHashMap<String, XrefId>,
     /// Whether to use external message IDs in Closure Compiler variable names.
     ///
     /// When true, generates variable names like `MSG_EXTERNAL_abc123$$SUFFIX`.
@@ -216,6 +224,7 @@ impl<'a> ComponentCompilationJob<'a> {
             mode: TemplateCompilationMode::default(),
             is_i18n_template: false,
             i18n_message_metadata: FxHashMap::default(),
+            i18n_xref_by_message_key: FxHashMap::default(),
             i18n_use_external_ids: true, // Default matches Angular's JIT behavior
             relative_context_file_path: None,
             relocation_entries: Vec::new_in(allocator),
@@ -245,6 +254,23 @@ impl<'a> ComponentCompilationJob<'a> {
         id
     }
 
+    /// Gets or creates an i18n xref for a message with the given key.
+    ///
+    /// This ensures that when the same i18n message is encountered multiple times
+    /// (e.g., when copying attributes from an element to its conditional wrapper),
+    /// they share the same xref. This is crucial for correct const deduplication.
+    ///
+    /// The key should be derived from the message's identity (custom_id or computed id).
+    pub fn get_or_create_i18n_xref(&mut self, message_key: String) -> XrefId {
+        if let Some(&xref) = self.i18n_xref_by_message_key.get(&message_key) {
+            xref
+        } else {
+            let xref = self.allocate_xref_id();
+            self.i18n_xref_by_message_key.insert(message_key, xref);
+            xref
+        }
+    }
+
     /// Stores an expression and returns its ID.
     ///
     /// Use this instead of inline expressions to avoid cloning.

crates/oxc_angular_compiler/src/pipeline/ingest.rs

@@ -1084,10 +1084,9 @@ fn ingest_element<'a>(
     // Ingest static attributes (must happen BEFORE bound inputs for proper order)
     // Static attributes are ingested as BindingOp with BindingKind::Attribute
     // so that binding_specialization can detect ngNonBindable and other special attributes.
-    let static_attrs: std::vec::Vec<(Atom<'a>, Atom<'a>)> =
-        element.attributes.iter().map(|attr| (attr.name.clone(), attr.value.clone())).collect();
+    // Note: We preserve i18n metadata for i18n-marked text attributes (e.g., tooltip="text" i18n-tooltip)
     // Element attributes are not structural template attributes
-    ingest_static_attributes(job, view_xref, xref, static_attrs, false);
+    ingest_static_attributes_with_i18n(job, view_xref, xref, &element.attributes, false);
 
     // Ingest bindings BEFORE children to ensure update ops are in slot order.
     // This matches Angular's TypeScript implementation in ingest.ts.
@@ -1255,9 +1254,11 @@ fn ingest_static_attributes<'a>(
     let allocator = job.allocator;
 
     for (name, value) in attributes {
-        // ngNonBindable requires special handling: it must be added to the update list
-        // as a BindingOp so binding_specialization can detect it
-        if name.as_str() == "ngNonBindable" {
+        // ngNonBindable and animate.* require special handling: they must be added to the
+        // update list as BindingOp so binding_specialization can detect and process them.
+        // - ngNonBindable: marks element as non-bindable
+        // - animate.*: converts to AnimationBindingOp for animation instructions
+        if name.as_str() == "ngNonBindable" || name.as_str().starts_with("animate.") {
             let literal_expr = OutputExpression::Literal(Box::new_in(
                 LiteralExpr { value: LiteralValue::String(value), source_span: None },
                 allocator,
@@ -1316,6 +1317,146 @@ fn ingest_static_attributes<'a>(
     }
 }
 
+/// Ingests static attributes from R3TextAttribute, preserving i18n metadata.
+///
+/// This version takes R3TextAttribute directly so it can access the i18n field.
+/// For i18n-marked text attributes (e.g., `tooltip="text" i18n-tooltip="@@same-key"`),
+/// we create an i18n_message xref to ensure proper context assignment in later phases.
+///
+/// Ported from Angular's ingestElementBindings which passes attr.i18n to createBindingOp
+/// (ingest.ts lines 1315-1332).
+fn ingest_static_attributes_with_i18n<'a>(
+    job: &mut ComponentCompilationJob<'a>,
+    view_xref: XrefId,
+    element_xref: XrefId,
+    attributes: &[R3TextAttribute<'a>],
+    is_structural_template_attribute: bool,
+) {
+    use crate::output::ast::{LiteralExpr, LiteralValue, OutputExpression};
+
+    let allocator = job.allocator;
+
+    for attr in attributes {
+        let name = attr.name.clone();
+        let value = attr.value.clone();
+
+        // ngNonBindable and animate.* require special handling
+        if name.as_str() == "ngNonBindable" || name.as_str().starts_with("animate.") {
+            let literal_expr = OutputExpression::Literal(Box::new_in(
+                LiteralExpr { value: LiteralValue::String(value), source_span: None },
+                allocator,
+            ));
+            let value_expr = IrExpression::OutputExpr(Box::new_in(literal_expr, allocator));
+
+            let binding = BindingOp {
+                base: UpdateOpBase::default(),
+                target: element_xref,
+                kind: BindingKind::Attribute,
+                name,
+                expression: Box::new_in(value_expr, allocator),
+                unit: None,
+                security_context: SecurityContext::None,
+                i18n_message: None,
+                is_text_attribute: true,
+            };
+
+            if let Some(view) = job.view_mut(view_xref) {
+                view.update.push(UpdateOp::Binding(binding));
+            }
+            continue;
+        }
+
+        // Handle i18n message if present (for i18n-* attribute markers)
+        // This matches Angular's asMessage(attr.i18n) in ingest.ts line 1329
+        //
+        // IMPORTANT: Use a cached xref based on the message's instance_id to ensure
+        // that when the SAME attribute is encountered twice (once for the conditional via
+        // ingestControlFlowInsertionPoint, once for the element via this function), both
+        // uses share the same xref. This matches TypeScript's behavior where Map keys use
+        // object identity.
+        //
+        // Different attributes (even with the same content) should get DIFFERENT xrefs,
+        // which is crucial for correct const deduplication - each element with an i18n
+        // attribute should get its own const entry.
+        //
+        // We use instance_id rather than pointer address because Rust moves data around
+        // during iteration (e.g., `for child in branch.children` moves the children),
+        // which changes memory addresses. The instance_id is assigned during parsing
+        // and survives moves.
+        let i18n_message = if let Some(I18nMeta::Message(ref message)) = attr.i18n {
+            // Use the instance ID as the cache key (survives Rust moves unlike pointer)
+            let message_key = format!("i18n_instance_{}", message.instance_id);
+
+            let i18n_xref = job.get_or_create_i18n_xref(message_key);
+
+            // Store i18n message metadata for later phases (only if not already stored)
+            if !job.i18n_message_metadata.contains_key(&i18n_xref) {
+                let mut legacy_ids = Vec::new_in(allocator);
+                for id in message.legacy_ids.iter() {
+                    legacy_ids.push(id.clone());
+                }
+
+                let metadata = I18nMessageMetadata {
+                    message_id: if message.id.is_empty() { None } else { Some(message.id.clone()) },
+                    custom_id: if message.custom_id.is_empty() {
+                        None
+                    } else {
+                        Some(message.custom_id.clone())
+                    },
+                    meaning: if message.meaning.is_empty() {
+                        None
+                    } else {
+                        Some(message.meaning.clone())
+                    },
+                    description: if message.description.is_empty() {
+                        None
+                    } else {
+                        Some(message.description.clone())
+                    },
+                    legacy_ids,
+                };
+                job.i18n_message_metadata.insert(i18n_xref, metadata);
+            }
+
+            Some(i18n_xref)
+        } else {
+            None
+        };
+
+        // All other static attributes go to the create list as ExtractedAttributeOp
+        let literal_expr = OutputExpression::Literal(Box::new_in(
+            LiteralExpr { value: LiteralValue::String(value), source_span: None },
+            allocator,
+        ));
+        let value_expr = IrExpression::OutputExpr(Box::new_in(literal_expr, allocator));
+
+        // Use Template kind for structural template attributes, Attribute otherwise
+        let binding_kind = if is_structural_template_attribute {
+            BindingKind::Template
+        } else {
+            BindingKind::Attribute
+        };
+
+        let extracted = ExtractedAttributeOp {
+            base: CreateOpBase::default(),
+            target: element_xref,
+            binding_kind,
+            namespace: None,
+            name,
+            value: Some(Box::new_in(value_expr, allocator)),
+            security_context: SecurityContext::None,
+            truthy_expression: false,
+            i18n_context: None,
+            i18n_message,
+            trusted_value_fn: None,
+        };
+
+        if let Some(view) = job.view_mut(view_xref) {
+            view.create.push(CreateOp::ExtractedAttribute(extracted));
+        }
+    }
+}
+
 /// Ingests a single static attribute.
 ///
 /// This is used for processing template_attrs in order, where we need to handle
@@ -4066,6 +4207,62 @@ fn ingest_control_flow_insertion_point<'a, 'b>(
         let security_context = crate::schema::get_security_context(NG_TEMPLATE_TAG_NAME, attr_name);
         let value_expr = create_string_literal_atom(allocator, attr.value.clone());
 
+        // Handle i18n message if present (for i18n-* attribute markers)
+        // This matches Angular's asMessage(attr.i18n) in ingest.ts line 1879
+        //
+        // IMPORTANT: Use a cached xref based on MESSAGE INSTANCE ID to ensure that when
+        // the SAME attribute is encountered twice (once for the conditional via
+        // ingestControlFlowInsertionPoint, once for the element via ingestStaticAttributes),
+        // both uses share the same xref. This matches TypeScript's behavior where Map keys
+        // use object identity.
+        //
+        // Each i18n message has a unique instance_id assigned during parsing. This survives
+        // moves/copies and ensures correct identity tracking even after Rust's move semantics
+        // relocate the data.
+        //
+        // Different attributes (even with the same content) should get DIFFERENT xrefs,
+        // which is crucial for correct const deduplication - each element with an i18n
+        // attribute should get its own const entry.
+        let i18n_message = if let Some(I18nMeta::Message(ref message)) = attr.i18n {
+            // Use the instance ID as the cache key
+            let message_key = format!("i18n_instance_{}", message.instance_id);
+
+            let i18n_xref = job.get_or_create_i18n_xref(message_key);
+
+            // Store i18n message metadata for later phases (only if not already stored)
+            if !job.i18n_message_metadata.contains_key(&i18n_xref) {
+                let mut legacy_ids = Vec::new_in(allocator);
+                for id in message.legacy_ids.iter() {
+                    legacy_ids.push(id.clone());
+                }
+
+                let metadata = I18nMessageMetadata {
+                    message_id: if message.id.is_empty() { None } else { Some(message.id.clone()) },
+                    custom_id: if message.custom_id.is_empty() {
+                        None
+                    } else {
+                        Some(message.custom_id.clone())
+                    },
+                    meaning: if message.meaning.is_empty() {
+                        None
+                    } else {
+                        Some(message.meaning.clone())
+                    },
+                    description: if message.description.is_empty() {
+                        None
+                    } else {
+                        Some(message.description.clone())
+                    },
+                    legacy_ids,
+                };
+                job.i18n_message_metadata.insert(i18n_xref, metadata);
+            }
+
+            Some(i18n_xref)
+        } else {
+            None
+        };
+
         let binding_op = UpdateOp::Binding(BindingOp {
             base: UpdateOpBase { source_span: Some(attr.source_span), ..Default::default() },
             target: xref,
@@ -4074,7 +4271,7 @@ fn ingest_control_flow_insertion_point<'a, 'b>(
             expression: Box::new_in(value_expr, allocator),
             unit: None,
             security_context,
-            i18n_message: None,      // TODO: handle attr.i18n
+            i18n_message,
             is_text_attribute: true, // Static attributes are text attributes
         });
 

crates/oxc_angular_compiler/src/pipeline/phases/assign_i18n_slot_dependencies.rs

@@ -154,13 +154,16 @@ fn assign_i18n_slot_dependencies_in_view(job: &mut ComponentCompilationJob<'_>,
                     break;
                 }
 
-                // Check if there's a next op to advance to
+                // Advance to next update op (or None if this was the last)
+                // Unlike TypeScript which uses sentinel nodes, we use None to represent
+                // "past the end". When we insert at I18nEnd with cursor=None, we push
+                // to the end of the list, which is correct (after all matching ops).
+                update_op_ptr = next_ptr;
+
+                // If there's no next op, break after advancing the cursor
                 if next_ptr.is_none() {
                     break;
                 }
-
-                // Advance to next update op
-                update_op_ptr = next_ptr;
             }
         }
     }