From 5581fece547239f1b45f43b53ca168be2d39d08a Mon Sep 17 00:00:00 2001
From: Pavel Piuro <piuro.pavel@gmail.com>
Date: Wed, 31 Dec 2025 00:01:51 +0400
Subject: [PATCH] Add failing test for variance measurement with nested generic
 type aliases (#60453)

This test demonstrates incorrect variance computation for type aliases
with deeply nested anonymous object types containing Arrays.

The variance is incorrectly measured as Independent (meaning the type
parameter is not used) instead of Covariant, causing type-unsafe
assignments to be allowed.
---
 .../varianceNestedGenericTypeAlias.ts         | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 tests/cases/compiler/varianceNestedGenericTypeAlias.ts

diff --git a/tests/cases/compiler/varianceNestedGenericTypeAlias.ts b/tests/cases/compiler/varianceNestedGenericTypeAlias.ts
new file mode 100644
index 0000000000000..28ff31cd05c11
--- /dev/null
+++ b/tests/cases/compiler/varianceNestedGenericTypeAlias.ts
@@ -0,0 +1,52 @@
+// @strict: true
+
+// Repro from #60453
+// Variance measurement fails for type aliases with deeply nested anonymous object types
+// containing Arrays, incorrectly computing variance as Independent instead of Covariant.
+
+type TypeA = number;
+type TypeB = boolean;
+
+// Two levels of nesting - should be covariant in T
+type DataTypeTwo<T extends TypeA | TypeB> = {
+  one: Array<{ two: Array<T> }>;
+};
+
+// Three levels of nesting - should be covariant in T
+type DataTypeThree<T extends TypeA | TypeB> = {
+  one: Array<{ two: Array<{ three: Array<T> }> }>;
+};
+
+// Inline literal assignments correctly error
+let testingThreeErr: DataTypeThree<TypeA> = {
+  one: [{ two: [{ three: [true] }] }]  // Error expected
+};
+
+let testingTwoErr: DataTypeTwo<TypeA> = {
+  one: [{ two: [false] }]  // Error expected
+};
+
+// Variable assignments should also error but currently don't due to
+// variance being incorrectly computed as Independent
+let testingThree: DataTypeThree<TypeA> = {
+  one: [{ two: [{ three: [5] }] }]
+};
+
+let t3a: DataTypeThree<TypeB> = testingThree;  // Error expected: number not assignable to boolean
+
+let testingTwo: DataTypeTwo<TypeA> = {
+  one: [{ two: [5] }]
+};
+
+let t2a: DataTypeTwo<TypeB> = testingTwo;  // Error expected: number not assignable to boolean
+
+// Workaround: explicit variance annotation fixes the issue
+type DataTypeThreeFixed<out T extends TypeA | TypeB> = {
+  one: Array<{ two: Array<{ three: Array<T> }> }>;
+};
+
+let testingThreeFixed: DataTypeThreeFixed<TypeA> = {
+  one: [{ two: [{ three: [5] }] }]
+};
+
+let t3aFixed: DataTypeThreeFixed<TypeB> = testingThreeFixed;  // Error expected and works correctly