Fix an issue with types possibly being related to discriminated type despite of incompatible variance

src/compiler/checker.ts

@@ -22010,6 +22010,27 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // Compare the remaining non-discriminant properties of each match.
             let result = Ternary.True;
             for (const type of matchingTypes) {
+                if (getObjectFlags(source) & ObjectFlags.Reference && getObjectFlags(type) & ObjectFlags.Reference && (source as TypeReference).target === (type as TypeReference).target &&
+                    !isTupleType(source) && !(isMarkerType(source) || isMarkerType(type))) {
+                    // When strictNullChecks is disabled, the element type of the empty array literal is undefinedWideningType,
+                    // and an empty array literal wouldn't be assignable to a `never[]` without this check.
+                    if (isEmptyArrayLiteralType(source)) {
+                        return Ternary.True;
+                    }
+                    // We have type references to the same generic type, and the type references are not marker
+                    // type references (which are intended by be compared structurally). Obtain the variance
+                    // information for the type parameters and relate the type arguments accordingly.
+                    const variances = getVariances((source as TypeReference).target);
+                    // We return Ternary.Maybe for a recursive invocation of getVariances (signalled by emptyArray). This
+                    // effectively means we measure variance only from type parameter occurrences that aren't nested in
+                    // recursive instantiations of the generic type.
+                    if (variances === emptyArray) {
+                        return Ternary.Unknown;
+                    }
+                    if (!typeArgumentsRelatedTo(getTypeArguments(source as TypeReference), getTypeArguments(type as TypeReference), variances, /*reportErrors*/ false, IntersectionState.None)) {
+                        return Ternary.False;
+                    }
+                }
                 result &= propertiesRelatedTo(source, type, /*reportErrors*/ false, excludedProperties, /*optionalsOnly*/ false, IntersectionState.None);
                 if (result) {
                     result &= signaturesRelatedTo(source, type, SignatureKind.Call, /*reportErrors*/ false, IntersectionState.None);

tests/baselines/reference/discriminatedUnionWithFailedVarianceCheck.errors.txt

@@ -0,0 +1,57 @@
+tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts(20,3): error TS2322: Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G> | ResultTwo<G>'.
+  Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G>'.
+    Type 'StringType' is not assignable to type 'G'.
+      'StringType' is assignable to the constraint of type 'G', but 'G' could be instantiated with a different subtype of constraint 'UnknownType'.
+tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts(26,11): error TS2322: Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G>'.
+  Type 'StringType' is not assignable to type 'G'.
+    'StringType' is assignable to the constraint of type 'G', but 'G' could be instantiated with a different subtype of constraint 'UnknownType'.
+tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts(27,11): error TS2741: Property 'other' is missing in type 'ResultOne<StringType>' but required in type 'ResultTwo<G>'.
+tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts(28,11): error TS2322: Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G> | ResultTwo<G>'.
+  Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G>'.
+
+
+==== tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts (4 errors) ====
+    interface StringType { prop: string }
+    interface UnknownType { prop: unknown }
+    interface ResultOne<G extends UnknownType> {
+      type: "one";
+      value: G["prop"];
+    }
+    interface ResultTwo<G extends UnknownType> {
+      type: "two";
+      other: G["prop"];
+    }
+
+    // repro #51180
+
+    function callback<G extends UnknownType>(): ResultOne<G> | ResultTwo<G> {
+      const dt: ResultOne<StringType> = {
+        type: "one",
+        value: "abc",
+      };
+
+      return dt; // error
+      ~~~~~~~~~~
+!!! error TS2322: Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G> | ResultTwo<G>'.
+!!! error TS2322:   Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G>'.
+!!! error TS2322:     Type 'StringType' is not assignable to type 'G'.
+!!! error TS2322:       'StringType' is assignable to the constraint of type 'G', but 'G' could be instantiated with a different subtype of constraint 'UnknownType'.
+    }
+
+    // repro #51180#issuecomment-1279445430
+
+    function callback2<G extends UnknownType>(s: ResultOne<StringType>) {
+        const a1: ResultOne<G> = s; // error
+              ~~
+!!! error TS2322: Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G>'.
+!!! error TS2322:   Type 'StringType' is not assignable to type 'G'.
+!!! error TS2322:     'StringType' is assignable to the constraint of type 'G', but 'G' could be instantiated with a different subtype of constraint 'UnknownType'.
+        const a2: ResultTwo<G> = s; // error
+              ~~
+!!! error TS2741: Property 'other' is missing in type 'ResultOne<StringType>' but required in type 'ResultTwo<G>'.
+!!! related TS2728 tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts:9:3: 'other' is declared here.
+        const m: ResultOne<G> | ResultTwo<G> = s; // error
+              ~
+!!! error TS2322: Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G> | ResultTwo<G>'.
+!!! error TS2322:   Type 'ResultOne<StringType>' is not assignable to type 'ResultOne<G>'.
+    }

tests/baselines/reference/discriminatedUnionWithFailedVarianceCheck.symbols

@@ -0,0 +1,92 @@
+=== tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts ===
+interface StringType { prop: string }
+>StringType : Symbol(StringType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 0))
+>prop : Symbol(StringType.prop, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 22))
+
+interface UnknownType { prop: unknown }
+>UnknownType : Symbol(UnknownType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 37))
+>prop : Symbol(UnknownType.prop, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 23))
+
+interface ResultOne<G extends UnknownType> {
+>ResultOne : Symbol(ResultOne, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 39))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 2, 20))
+>UnknownType : Symbol(UnknownType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 37))
+
+  type: "one";
+>type : Symbol(ResultOne.type, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 2, 44))
+
+  value: G["prop"];
+>value : Symbol(ResultOne.value, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 3, 14))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 2, 20))
+}
+interface ResultTwo<G extends UnknownType> {
+>ResultTwo : Symbol(ResultTwo, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 5, 1))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 6, 20))
+>UnknownType : Symbol(UnknownType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 37))
+
+  type: "two";
+>type : Symbol(ResultTwo.type, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 6, 44))
+
+  other: G["prop"];
+>other : Symbol(ResultTwo.other, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 7, 14))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 6, 20))
+}
+
+// repro #51180
+
+function callback<G extends UnknownType>(): ResultOne<G> | ResultTwo<G> {
+>callback : Symbol(callback, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 9, 1))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 13, 18))
+>UnknownType : Symbol(UnknownType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 37))
+>ResultOne : Symbol(ResultOne, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 39))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 13, 18))
+>ResultTwo : Symbol(ResultTwo, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 5, 1))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 13, 18))
+
+  const dt: ResultOne<StringType> = {
+>dt : Symbol(dt, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 14, 7))
+>ResultOne : Symbol(ResultOne, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 39))
+>StringType : Symbol(StringType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 0))
+
+    type: "one",
+>type : Symbol(type, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 14, 37))
+
+    value: "abc",
+>value : Symbol(value, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 15, 16))
+
+  };
+
+  return dt; // error
+>dt : Symbol(dt, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 14, 7))
+}
+
+// repro #51180#issuecomment-1279445430
+
+function callback2<G extends UnknownType>(s: ResultOne<StringType>) {
+>callback2 : Symbol(callback2, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 20, 1))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 19))
+>UnknownType : Symbol(UnknownType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 37))
+>s : Symbol(s, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 42))
+>ResultOne : Symbol(ResultOne, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 39))
+>StringType : Symbol(StringType, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 0, 0))
+
+    const a1: ResultOne<G> = s; // error
+>a1 : Symbol(a1, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 25, 9))
+>ResultOne : Symbol(ResultOne, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 39))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 19))
+>s : Symbol(s, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 42))
+
+    const a2: ResultTwo<G> = s; // error
+>a2 : Symbol(a2, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 26, 9))
+>ResultTwo : Symbol(ResultTwo, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 5, 1))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 19))
+>s : Symbol(s, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 42))
+
+    const m: ResultOne<G> | ResultTwo<G> = s; // error
+>m : Symbol(m, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 27, 9))
+>ResultOne : Symbol(ResultOne, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 1, 39))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 19))
+>ResultTwo : Symbol(ResultTwo, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 5, 1))
+>G : Symbol(G, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 19))
+>s : Symbol(s, Decl(discriminatedUnionWithFailedVarianceCheck.ts, 24, 42))
+}

tests/baselines/reference/discriminatedUnionWithFailedVarianceCheck.types

@@ -0,0 +1,63 @@
+=== tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts ===
+interface StringType { prop: string }
+>prop : string
+
+interface UnknownType { prop: unknown }
+>prop : unknown
+
+interface ResultOne<G extends UnknownType> {
+  type: "one";
+>type : "one"
+
+  value: G["prop"];
+>value : G["prop"]
+}
+interface ResultTwo<G extends UnknownType> {
+  type: "two";
+>type : "two"
+
+  other: G["prop"];
+>other : G["prop"]
+}
+
+// repro #51180
+
+function callback<G extends UnknownType>(): ResultOne<G> | ResultTwo<G> {
+>callback : <G extends UnknownType>() => ResultOne<G> | ResultTwo<G>
+
+  const dt: ResultOne<StringType> = {
+>dt : ResultOne<StringType>
+>{    type: "one",    value: "abc",  } : { type: "one"; value: string; }
+
+    type: "one",
+>type : "one"
+>"one" : "one"
+
+    value: "abc",
+>value : string
+>"abc" : "abc"
+
+  };
+
+  return dt; // error
+>dt : ResultOne<StringType>
+}
+
+// repro #51180#issuecomment-1279445430
+
+function callback2<G extends UnknownType>(s: ResultOne<StringType>) {
+>callback2 : <G extends UnknownType>(s: ResultOne<StringType>) => void
+>s : ResultOne<StringType>
+
+    const a1: ResultOne<G> = s; // error
+>a1 : ResultOne<G>
+>s : ResultOne<StringType>
+
+    const a2: ResultTwo<G> = s; // error
+>a2 : ResultTwo<G>
+>s : ResultOne<StringType>
+
+    const m: ResultOne<G> | ResultTwo<G> = s; // error
+>m : ResultOne<G> | ResultTwo<G>
+>s : ResultOne<StringType>
+}

tests/cases/compiler/discriminatedUnionWithFailedVarianceCheck.ts

@@ -0,0 +1,32 @@
+// @strict: true
+// @noEmit: true
+
+interface StringType { prop: string }
+interface UnknownType { prop: unknown }
+interface ResultOne<G extends UnknownType> {
+  type: "one";
+  value: G["prop"];
+}
+interface ResultTwo<G extends UnknownType> {
+  type: "two";
+  other: G["prop"];
+}
+
+// repro #51180
+
+function callback<G extends UnknownType>(): ResultOne<G> | ResultTwo<G> {
+  const dt: ResultOne<StringType> = {
+    type: "one",
+    value: "abc",
+  };
+
+  return dt; // error
+}
+
+// repro #51180#issuecomment-1279445430
+
+function callback2<G extends UnknownType>(s: ResultOne<StringType>) {
+    const a1: ResultOne<G> = s; // error
+    const a2: ResultTwo<G> = s; // error
+    const m: ResultOne<G> | ResultTwo<G> = s; // error
+}