fix(compiler): dedupe generated i0 namespace imports against all file identifiers

crates/oxc_angular_compiler/src/class_debug_info/compiler.rs

@@ -33,9 +33,10 @@ use crate::r3::Identifiers;
 /// Ported from Angular's `compileClassDebugInfo` function.
 pub fn compile_class_debug_info<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     debug_info: &R3ClassDebugInfo<'a>,
 ) -> OutputExpression<'a> {
-    let fn_call = internal_compile_class_debug_info(allocator, debug_info);
+    let fn_call = internal_compile_class_debug_info(allocator, core_namespace, debug_info);
     let guarded = dev_only_guarded_expression(allocator, fn_call);
     let stmt = expr_stmt(allocator, guarded);
     create_arrow_iife(allocator, stmt)
@@ -44,9 +45,10 @@ pub fn compile_class_debug_info<'a>(
 /// Compiles the internal `setClassDebugInfo` call without wrappers.
 fn internal_compile_class_debug_info<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     debug_info: &R3ClassDebugInfo<'a>,
 ) -> OutputExpression<'a> {
-    let import = import_expr(allocator, Identifiers::SET_CLASS_DEBUG_INFO);
+    let import = import_expr(allocator, core_namespace, Identifiers::SET_CLASS_DEBUG_INFO);
 
     // Build the debug info object
     // Always include className
@@ -161,13 +163,17 @@ fn dev_only_guarded_expression<'a>(
     ))
 }
 
-/// Creates an import expression: i0.identifier
-fn import_expr<'a>(allocator: &'a Allocator, identifier: &'static str) -> OutputExpression<'a> {
+/// Creates an import expression: ns.identifier
+fn import_expr<'a>(
+    allocator: &'a Allocator,
+    core_namespace: &'a str,
+    identifier: &'static str,
+) -> OutputExpression<'a> {
     OutputExpression::ReadProp(Box::new_in(
         ReadPropExpr {
             receiver: Box::new_in(
                 OutputExpression::ReadVar(Box::new_in(
-                    ReadVarExpr { name: Ident::from("i0"), source_span: None },
+                    ReadVarExpr { name: Ident::from(core_namespace), source_span: None },
                     &allocator,
                 )),
                 &allocator,

crates/oxc_angular_compiler/src/class_metadata/builders.rs

@@ -803,7 +803,7 @@ fn build_core_decorator<'a>(
     decorator_name: &'static str,
     args: AllocVec<'a, OutputExpression<'a>>,
 ) -> OutputExpression<'a> {
-    let core_namespace = namespace_registry.get_or_assign(&Ident::from("@angular/core"));
+    let core_namespace = namespace_registry.get_or_assign(&Ident::from(crate::r3::CORE));
     let type_expr = OutputExpression::ReadProp(Box::new_in(
         ReadPropExpr {
             receiver: Box::new_in(

crates/oxc_angular_compiler/src/class_metadata/compiler.rs

@@ -31,9 +31,10 @@ use crate::r3::Identifiers;
 /// Ported from Angular's `compileClassMetadata` function.
 pub fn compile_class_metadata<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     metadata: &R3ClassMetadata<'a>,
 ) -> OutputExpression<'a> {
-    let fn_call = internal_compile_class_metadata(allocator, metadata);
+    let fn_call = internal_compile_class_metadata(allocator, core_namespace, metadata);
     let guarded = dev_only_guarded_expression(allocator, fn_call);
     let stmt = expr_stmt(allocator, guarded);
     let arrow = create_arrow_iife(allocator, stmt);
@@ -48,13 +49,14 @@ pub fn compile_class_metadata<'a>(
 /// Ported from Angular's `compileComponentClassMetadata` function.
 pub fn compile_component_class_metadata<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     metadata: &R3ClassMetadata<'a>,
     dependencies: Option<&[R3DeferPerComponentDependency<'a>]>,
 ) -> OutputExpression<'a> {
     match dependencies {
         None | Some([]) => {
             // No deferred dependencies - use regular setClassMetadata
-            compile_class_metadata(allocator, metadata)
+            compile_class_metadata(allocator, core_namespace, metadata)
         }
         Some(deps) => {
             // Has deferred dependencies - use setClassMetadataAsync
@@ -63,7 +65,13 @@ pub fn compile_component_class_metadata<'a>(
                 params.push(FnParam { name: dep.param_name.clone() });
             }
             let resolver = compile_component_metadata_async_resolver(allocator, deps);
-            internal_compile_set_class_metadata_async(allocator, metadata, params, resolver)
+            internal_compile_set_class_metadata_async(
+                allocator,
+                core_namespace,
+                metadata,
+                params,
+                resolver,
+            )
         }
     }
 }
@@ -75,6 +83,7 @@ pub fn compile_component_class_metadata<'a>(
 /// Ported from Angular's `compileOpaqueAsyncClassMetadata` function.
 pub fn compile_opaque_async_class_metadata<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     metadata: &R3ClassMetadata<'a>,
     defer_resolver: OutputExpression<'a>,
     deferred_dependency_names: &[Ident<'a>],
@@ -83,7 +92,13 @@ pub fn compile_opaque_async_class_metadata<'a>(
     for name in deferred_dependency_names {
         params.push(FnParam { name: name.clone() });
     }
-    internal_compile_set_class_metadata_async(allocator, metadata, params, defer_resolver)
+    internal_compile_set_class_metadata_async(
+        allocator,
+        core_namespace,
+        metadata,
+        params,
+        defer_resolver,
+    )
 }
 
 /// Compiles the dependency resolver function for `setClassMetadataAsync`.
@@ -197,9 +212,10 @@ pub fn compile_component_metadata_async_resolver<'a>(
 /// Compiles the internal `setClassMetadata` call without wrappers.
 fn internal_compile_class_metadata<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     metadata: &R3ClassMetadata<'a>,
 ) -> OutputExpression<'a> {
-    let import = import_expr(allocator, Identifiers::SET_CLASS_METADATA);
+    let import = import_expr(allocator, core_namespace, Identifiers::SET_CLASS_METADATA);
 
     let mut args = Vec::new_in(&allocator);
     args.push(metadata.r#type.clone_in(allocator));
@@ -234,12 +250,14 @@ fn internal_compile_class_metadata<'a>(
 /// Compiles `setClassMetadataAsync` with wrapper params and resolver.
 fn internal_compile_set_class_metadata_async<'a>(
     allocator: &'a Allocator,
+    core_namespace: &'a str,
     metadata: &R3ClassMetadata<'a>,
     wrapper_params: Vec<'a, FnParam<'a>>,
     dependency_resolver_fn: OutputExpression<'a>,
 ) -> OutputExpression<'a> {
     // Create the inner setClassMetadata call
-    let set_class_metadata_call = internal_compile_class_metadata(allocator, metadata);
+    let set_class_metadata_call =
+        internal_compile_class_metadata(allocator, core_namespace, metadata);
 
     // Create wrapper: (deps...) => { setClassMetadata(...); }
     let mut wrapper_stmts = Vec::new_in(&allocator);
@@ -255,7 +273,7 @@ fn internal_compile_set_class_metadata_async<'a>(
     ));
 
     // Create: setClassMetadataAsync(type, resolver, wrapper)
-    let import = import_expr(allocator, Identifiers::SET_CLASS_METADATA_ASYNC);
+    let import = import_expr(allocator, core_namespace, Identifiers::SET_CLASS_METADATA_ASYNC);
 
     let mut args = Vec::new_in(&allocator);
     args.push(metadata.r#type.clone_in(allocator));
@@ -343,13 +361,17 @@ fn guarded_expression<'a>(
     ))
 }
 
-/// Creates an import expression: i0.identifier
-fn import_expr<'a>(allocator: &'a Allocator, identifier: &'static str) -> OutputExpression<'a> {
+/// Creates an import expression: ns.identifier
+fn import_expr<'a>(
+    allocator: &'a Allocator,
+    core_namespace: &'a str,
+    identifier: &'static str,
+) -> OutputExpression<'a> {
     OutputExpression::ReadProp(Box::new_in(
         ReadPropExpr {
             receiver: Box::new_in(
                 OutputExpression::ReadVar(Box::new_in(
-                    ReadVarExpr { name: Ident::from("i0"), source_span: None },
+                    ReadVarExpr { name: Ident::from(core_namespace), source_span: None },
                     &allocator,
                 )),
                 &allocator,