save

Author: Brooooooklyn

crates/oxc_angular_compiler/src/ir/ops.rs

@@ -1290,6 +1290,11 @@ pub struct I18nOp<'a> {
     pub message: Option<XrefId>,
     /// I18n placeholder data (start_name and close_name for i18n blocks).
     pub i18n_placeholder: Option<I18nPlaceholder<'a>>,
+    /// Sub-template index for nested templates inside i18n blocks.
+    /// None for root-level i18n blocks.
+    pub sub_template_index: Option<u32>,
+    /// Root i18n block reference (for nested i18n blocks).
+    pub root: Option<XrefId>,
     /// Index into the consts array for the i18n message.
     /// Set by the i18n_const_collection phase.
     pub message_index: Option<u32>,

crates/oxc_angular_compiler/src/output/emitter.rs

@@ -855,10 +855,6 @@ impl JsEmitter {
     fn visit_literal_array<'a>(&self, entries: &[OutputExpression<'a>], ctx: &mut EmitterContext) {
         ctx.print("[");
         self.visit_all_expressions(entries, ctx, ",");
-        // Add trailing comma for non-empty arrays to match Angular's output
-        if !entries.is_empty() {
-            ctx.print(",");
-        }
         ctx.print("]");
     }
 
@@ -896,10 +892,6 @@ impl JsEmitter {
             ctx.print(":");
             self.visit_expression(&entry.value, ctx);
         }
-        // Add trailing comma for non-empty object literals to match Angular's output
-        if !entries.is_empty() {
-            ctx.print(",");
-        }
         if incremented_indent {
             ctx.dec_indent();
             ctx.dec_indent();

crates/oxc_angular_compiler/src/pipeline/ingest.rs

@@ -22,6 +22,7 @@ use super::compilation::{
     CTX_REF, ComponentCompilationJob, DeferBlockDepsEmitMode, DeferMetadata,
     HostBindingCompilationJob, I18nMessageMetadata, TemplateCompilationMode,
 };
+use super::conversion::prefix_with_namespace;
 use crate::ast::expression::{AngularExpression, ParsedEventType};
 use crate::ast::r3::{
     I18nIcuPlaceholder, I18nMeta, I18nNode, R3BoundAttribute, R3BoundEvent, R3BoundText, R3Content,
@@ -1800,14 +1801,35 @@ fn ingest_template<'a>(
     // view's xref.
     let xref = job.allocate_view(Some(view_xref));
 
-    // Compute fn_name_suffix from tag name, matching TypeScript's behavior.
-    // TypeScript: functionNameSuffix = tagNameWithoutNamespace === null ? '' : prefixWithNamespace(tagName, namespace)
-    // prefixWithNamespace converts hyphens to underscores (e.g., "ng-template" → "ng_template")
-    let fn_name_suffix = tag_name.as_ref().map(|tag| {
-        let suffix = tag.as_str().replace('-', "_");
+    // Parse namespace from tag name (e.g., `:svg:path` → ("svg", "path")).
+    // Matches TypeScript's ingestTemplate (lines 351-358 in ingest.ts):
+    //   let tagNameWithoutNamespace = tmpl.tagName;
+    //   if (tmpl.tagName) {
+    //     [namespacePrefix, tagNameWithoutNamespace] = splitNsName(tmpl.tagName);
+    //   }
+    //   const namespace = namespaceForKey(namespacePrefix);
+    let (namespace_key, tag_name_without_namespace) =
+        tag_name.as_ref().map_or((None, None), |tag| {
+            let (ns, stripped) = split_ns_name(tag.as_str());
+            (ns, Some(stripped))
+        });
+    let namespace = namespace_for_key(namespace_key);
+
+    // Compute fn_name_suffix from stripped tag name, matching TypeScript's behavior.
+    // TypeScript (lines 359-360):
+    //   const functionNameSuffix = tagNameWithoutNamespace === null
+    //     ? '' : prefixWithNamespace(tagNameWithoutNamespace, namespace);
+    // prefixWithNamespace returns `:svg:tagName` for SVG, `:math:tagName` for Math, or just
+    // `tagName` for HTML. The sanitizeIdentifier function later replaces non-word chars with `_`.
+    let fn_name_suffix = tag_name_without_namespace.map(|stripped_tag| {
+        let suffix = prefix_with_namespace(stripped_tag, namespace);
         Atom::from(allocator.alloc_str(&suffix))
     });
 
+    // Build the tag atom from the stripped tag name (without namespace prefix).
+    // TypeScript passes `tagNameWithoutNamespace` to createTemplateOp (line 367).
+    let tag = tag_name_without_namespace.map(|s| Atom::from(allocator.alloc_str(s)));
+
     // Convert references to local refs - needed for template op creation
     let local_refs = ingest_references_owned(allocator, references);
 
@@ -1819,8 +1841,8 @@ fn ingest_template<'a>(
         xref,
         embedded_view: xref,
         slot: None,
-        tag: tag_name.clone(), // Use tag from template for content projection
-        namespace: Namespace::Html,
+        tag,
+        namespace,
         template_kind,
         fn_name_suffix,
         block: None,
@@ -2067,29 +2089,15 @@ fn ingest_template<'a>(
             xref: i18n_xref,
         };
 
-        // Insert the ops into the child view's create list
-        // TypeScript uses OpList.insertAfter(head) and OpList.insertBefore(tail)
+        // Insert the ops into the child view's create list.
+        // TypeScript uses OpList.insertAfter(head) and OpList.insertBefore(tail),
+        // but Angular's OpList has sentinel nodes at head/tail, so insertAfter(head)
+        // means "insert as first real element" and insertBefore(tail) means "insert
+        // as last real element". Our OpList doesn't have sentinels, so we use
+        // push_front for I18nStart (first element) and push for I18nEnd (last element).
         if let Some(view) = job.view_mut(xref) {
-            // Get the head and tail pointers for insertion
-            if let Some(head_ptr) = view.create.head_ptr() {
-                // SAFETY: head_ptr is a valid pointer from the list
-                unsafe {
-                    view.create.insert_after(head_ptr, CreateOp::I18nStart(i18n_start));
-                }
-            } else {
-                // List is empty, just push
-                view.create.push(CreateOp::I18nStart(i18n_start));
-            }
-
-            if let Some(tail_ptr) = view.create.tail_ptr() {
-                // SAFETY: tail_ptr is a valid pointer from the list
-                unsafe {
-                    view.create.insert_before(tail_ptr, CreateOp::I18nEnd(i18n_end));
-                }
-            } else {
-                // List is empty (shouldn't happen after push), just push
-                view.create.push(CreateOp::I18nEnd(i18n_end));
-            }
+            view.create.push_front(CreateOp::I18nStart(i18n_start));
+            view.create.push(CreateOp::I18nEnd(i18n_end));
         }
     }
 }
@@ -2455,17 +2463,52 @@ fn ingest_for_block<'a>(
     }
 
     // Handle @empty block if present
-    let (empty_view, empty_tag) = if let Some(empty) = for_block.empty {
+    let (empty_view, empty_tag, empty_i18n_placeholder) = if let Some(empty) = for_block.empty {
         let empty_xref = job.allocate_view(Some(view_xref));
         // Infer tag name from single root element for content projection (@empty)
         let empty_tag =
             ingest_control_flow_insertion_point(job, view_xref, empty_xref, &empty.children);
+
+        // Extract i18n placeholder from @empty block if present.
+        // Per Angular's ingest.ts lines 970-974, only BlockPlaceholder is valid for @empty.
+        let empty_i18n_placeholder = match empty.i18n {
+            Some(I18nMeta::BlockPlaceholder(ref placeholder)) => Some(I18nPlaceholder::new(
+                placeholder.start_name.clone(),
+                Some(placeholder.close_name.clone()),
+            )),
+            Some(_) => {
+                job.diagnostics.push(
+                    OxcDiagnostic::error("Unhandled i18n metadata type for @empty")
+                        .with_label(empty.source_span),
+                );
+                None
+            }
+            None => None,
+        };
+
         for child in empty.children {
             ingest_node(job, empty_xref, child);
         }
-        (Some(empty_xref), empty_tag)
+        (Some(empty_xref), empty_tag, empty_i18n_placeholder)
     } else {
-        (None, None)
+        (None, None, None)
+    };
+
+    // Extract i18n placeholder from @for block if present.
+    // Per Angular's ingest.ts lines 967-969, only BlockPlaceholder is valid for @for.
+    let i18n_placeholder = match for_block.i18n {
+        Some(I18nMeta::BlockPlaceholder(ref placeholder)) => Some(I18nPlaceholder::new(
+            placeholder.start_name.clone(),
+            Some(placeholder.close_name.clone()),
+        )),
+        Some(_) => {
+            job.diagnostics.push(
+                OxcDiagnostic::error("Unhandled i18n metadata type for @for")
+                    .with_label(for_block.source_span),
+            );
+            None
+        }
+        None => None,
     };
 
     // Convert the track expression from the for block.
@@ -2492,8 +2535,8 @@ fn ingest_for_block<'a>(
         attributes: None,
         empty_tag,
         empty_attributes: None,
-        i18n_placeholder: None,
-        empty_i18n_placeholder: None,
+        i18n_placeholder,
+        empty_i18n_placeholder,
     });
 
     if let Some(view) = job.view_mut(view_xref) {