fix(jit): align union type resolution with Angular's typeReferenceToExpression

Angular's reference filters only `null` literal types from union types
and requires exactly one non-null type to remain. Previously we iterated
all union members and returned the first resolvable one, which is more
permissive than Angular's behavior.

With Angular-aligned semantics:
- `T | null` → resolves to T (1 non-null type remains)
- `undefined | T` → unresolvable (2 non-null types remain)
- `null | undefined | T` → unresolvable (2 non-null types remain)

Unresolvable types emit `{ type: undefined }` matching Angular's
`paramType || ts.factory.createIdentifier('undefined')` fallback.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/transform.rs

@@ -929,16 +929,20 @@ fn extract_type_name_from_annotation(type_annotation: &oxc_ast::ast::TSType<'_>)
             }
         }
         oxc_ast::ast::TSType::TSUnionType(union) => {
-            // For union types like `T | null`, `undefined | T`, `null | undefined | T`,
-            // iterate all members and return the first that resolves to a name.
-            // Using try-each-and-continue handles TSNullKeyword, TSUndefinedKeyword,
-            // and any other non-reference type gracefully.
-            for t in &union.types {
-                if let Some(name) = extract_type_name_from_annotation(t) {
-                    return Some(name);
-                }
+            // Match Angular's typeReferenceToExpression behavior:
+            // filter out only `null` literal types, and if exactly one type remains,
+            // resolve that type. Otherwise, return None (unresolvable).
+            // See: angular/packages/compiler-cli/src/ngtsc/transform/jit/src/downlevel_decorators_transform.ts
+            let non_null: std::vec::Vec<_> = union
+                .types
+                .iter()
+                .filter(|t| !matches!(t, oxc_ast::ast::TSType::TSNullKeyword(_)))
+                .collect();
+            if non_null.len() == 1 {
+                extract_type_name_from_annotation(non_null[0])
+            } else {
+                None
             }
-            None
         }
         _ => None,
     }

crates/oxc_angular_compiler/tests/integration_test.rs

@@ -6307,20 +6307,28 @@ export class HighlightDirective {
 
 #[test]
 fn test_jit_union_type_ctor_params() {
-    // Bug fix: union types like `undefined | SomeService` or `null | undefined | T`
-    // must correctly extract the type name for ctorParameters.
-    // Previously only TSNullKeyword was skipped, causing TSUndefinedKeyword to short-circuit.
+    // Angular-aligned union type behavior for ctorParameters.
+    // Angular's typeReferenceToExpression filters ONLY `null` literal types.
+    // If exactly one non-null type remains, it resolves; otherwise unresolvable.
+    //
+    // `T | null`                  → resolves to T   (1 non-null type)
+    // `undefined | T`             → unresolvable     (2 non-null types: undefined + T)
+    // `null | undefined | T`      → unresolvable     (2 non-null types: undefined + T)
+    //
+    // See: angular/packages/compiler-cli/src/ngtsc/transform/jit/src/downlevel_decorators_transform.ts
     let allocator = Allocator::default();
     let source = r#"
 import { Component } from '@angular/core';
 import { ServiceA } from './a.service';
 import { ServiceB } from './b.service';
+import { ServiceC } from './c.service';
 
 @Component({ selector: 'test', template: '' })
 export class TestComponent {
     constructor(
         svcA: undefined | ServiceA,
         svcB: null | undefined | ServiceB,
+        svcC: ServiceC | null,
     ) {}
 }
 "#;
@@ -6329,22 +6337,23 @@ export class TestComponent {
     let result = transform_angular_file(&allocator, "test.component.ts", source, &options, None);
     assert!(!result.has_errors(), "Should not have errors: {:?}", result.diagnostics);
 
-    // Both types must be correctly extracted despite union with undefined/null
+    // `ServiceC | null` resolves correctly (1 non-null type)
     assert!(
-        result.code.contains("type: ServiceA"),
-        "ctorParameters should resolve 'undefined | ServiceA' to ServiceA. Got:\n{}",
+        result.code.contains("type: ServiceC"),
+        "ctorParameters should resolve 'ServiceC | null' to ServiceC. Got:\n{}",
         result.code
     );
+
+    // `undefined | ServiceA` and `null | undefined | ServiceB` are unresolvable per Angular spec
+    // (2 non-null types remain after filtering null)
     assert!(
-        result.code.contains("type: ServiceB"),
-        "ctorParameters should resolve 'null | undefined | ServiceB' to ServiceB. Got:\n{}",
+        !result.code.contains("type: ServiceA"),
+        "ctorParameters must not resolve 'undefined | ServiceA' (2 non-null types). Got:\n{}",
         result.code
     );
-
-    // Should NOT emit 'type: undefined' for either
     assert!(
-        !result.code.contains("type: undefined"),
-        "ctorParameters must not emit 'type: undefined' for resolvable union types. Got:\n{}",
+        !result.code.contains("type: ServiceB"),
+        "ctorParameters must not resolve 'null | undefined | ServiceB' (2 non-null types). Got:\n{}",
         result.code
     );
 

crates/oxc_angular_compiler/tests/snapshots/integration_test__jit_union_type_ctor_params.snap

@@ -1,21 +1,26 @@
 ---
 source: crates/oxc_angular_compiler/tests/integration_test.rs
+assertion_line: 6360
 expression: result.code
 ---
+
 import { Component } from '@angular/core';
 import { ServiceA } from './a.service';
 import { ServiceB } from './b.service';
+import { ServiceC } from './c.service';
 import { __decorate } from "tslib";
 
 let TestComponent = class TestComponent {
     constructor(
         svcA: undefined | ServiceA,
         svcB: null | undefined | ServiceB,
+        svcC: ServiceC | null,
     ) {}
 
 static ctorParameters = () => [
-    { type: ServiceA },
-    { type: ServiceB }
+    { type: undefined },
+    { type: undefined },
+    { type: ServiceC }
 ];
 };
 TestComponent = __decorate([