Normalize type references before relating them (#35266)

* Normalize type references before relating them in isRelatedTo

* Add comments

* Accept new baselines

* Add regression tests

* Accept new baselines

* Use aliases when available in error reporting

* Accept new baselines

src/compiler/checker.ts

@@ -14250,6 +14250,14 @@ namespace ts {
             return getObjectFlags(source) & ObjectFlags.JsxAttributes && !isUnhyphenatedJsxName(sourceProp.escapedName);
         }
 
+        function getNormalizedType(type: Type, writing: boolean): Type {
+            return isFreshLiteralType(type) ? (<FreshableType>type).regularType :
+                getObjectFlags(type) & ObjectFlags.Reference && (<TypeReference>type).node ? createTypeReference((<TypeReference>type).target, getTypeArguments(<TypeReference>type)) :
+                type.flags & TypeFlags.Substitution ? writing ? (<SubstitutionType>type).typeVariable : (<SubstitutionType>type).substitute :
+                type.flags & TypeFlags.Simplifiable ? getSimplifiedType(type, writing) :
+                type;
+        }
+
         /**
          * Checks if 'source' is related to 'target' (e.g.: is a assignable to).
          * @param source The left-hand-side of the relation.
@@ -14555,25 +14563,13 @@ namespace ts {
              * * Ternary.Maybe if they are related with assumptions of other relationships, or
              * * Ternary.False if they are not related.
              */
-            function isRelatedTo(source: Type, target: Type, reportErrors = false, headMessage?: DiagnosticMessage, isApparentIntersectionConstituent?: boolean): Ternary {
-                if (isFreshLiteralType(source)) {
-                    source = (<FreshableType>source).regularType;
-                }
-                if (isFreshLiteralType(target)) {
-                    target = (<FreshableType>target).regularType;
-                }
-                if (source.flags & TypeFlags.Substitution) {
-                    source = (<SubstitutionType>source).substitute;
-                }
-                if (target.flags & TypeFlags.Substitution) {
-                    target = (<SubstitutionType>target).typeVariable;
-                }
-                if (source.flags & TypeFlags.Simplifiable) {
-                    source = getSimplifiedType(source, /*writing*/ false);
-                }
-                if (target.flags & TypeFlags.Simplifiable) {
-                    target = getSimplifiedType(target, /*writing*/ true);
-                }
+            function isRelatedTo(originalSource: Type, originalTarget: Type, reportErrors = false, headMessage?: DiagnosticMessage, isApparentIntersectionConstituent?: boolean): Ternary {
+                // Normalize the source and target types: Turn fresh literal types into regular literal types,
+                // turn deferred type references into regular type references, simplify indexed access and
+                // conditional types, and resolve substitution types to either the substitution (on the source
+                // side) or the type variable (on the target side).
+                let source = getNormalizedType(originalSource, /*writing*/ false);
+                let target = getNormalizedType(originalTarget, /*writing*/ true);
 
                 // Try to see if we're relating something like `Foo` -> `Bar | null | undefined`.
                 // If so, reporting the `null` and `undefined` in the type is hardly useful.
@@ -14706,6 +14702,8 @@ namespace ts {
                 }
 
                 if (!result && reportErrors) {
+                    source = originalSource.aliasSymbol ? originalSource : source;
+                    target = originalTarget.aliasSymbol ? originalTarget : target;
                     let maybeSuppress = overrideNextErrorInfo > 0;
                     if (maybeSuppress) {
                         overrideNextErrorInfo--;

tests/baselines/reference/unwitnessedTypeParameterVariance.js

@@ -0,0 +1,35 @@
+//// [unwitnessedTypeParameterVariance.ts]
+// Repros from #33872
+
+export interface CalcObj<O> {
+    read: (origin: O) => CalcValue<O>;
+}
+
+export type CalcValue<O> = CalcObj<O>;
+
+function foo<O>() {
+    const unk: CalcObj<unknown> = { read: (origin: unknown) => unk }
+    const x: CalcObj<O> = unk;
+}
+
+type A<T> = B<T>;
+
+interface B<T> {
+    prop: A<T>;
+}
+
+declare let a: A<number>;
+declare let b: A<3>;
+ 
+b = a;
+
+
+//// [unwitnessedTypeParameterVariance.js]
+"use strict";
+// Repros from #33872
+exports.__esModule = true;
+function foo() {
+    var unk = { read: function (origin) { return unk; } };
+    var x = unk;
+}
+b = a;

tests/baselines/reference/unwitnessedTypeParameterVariance.symbols

@@ -0,0 +1,67 @@
+=== tests/cases/compiler/unwitnessedTypeParameterVariance.ts ===
+// Repros from #33872
+
+export interface CalcObj<O> {
+>CalcObj : Symbol(CalcObj, Decl(unwitnessedTypeParameterVariance.ts, 0, 0))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 2, 25))
+
+    read: (origin: O) => CalcValue<O>;
+>read : Symbol(CalcObj.read, Decl(unwitnessedTypeParameterVariance.ts, 2, 29))
+>origin : Symbol(origin, Decl(unwitnessedTypeParameterVariance.ts, 3, 11))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 2, 25))
+>CalcValue : Symbol(CalcValue, Decl(unwitnessedTypeParameterVariance.ts, 4, 1))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 2, 25))
+}
+
+export type CalcValue<O> = CalcObj<O>;
+>CalcValue : Symbol(CalcValue, Decl(unwitnessedTypeParameterVariance.ts, 4, 1))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 6, 22))
+>CalcObj : Symbol(CalcObj, Decl(unwitnessedTypeParameterVariance.ts, 0, 0))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 6, 22))
+
+function foo<O>() {
+>foo : Symbol(foo, Decl(unwitnessedTypeParameterVariance.ts, 6, 38))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 8, 13))
+
+    const unk: CalcObj<unknown> = { read: (origin: unknown) => unk }
+>unk : Symbol(unk, Decl(unwitnessedTypeParameterVariance.ts, 9, 9))
+>CalcObj : Symbol(CalcObj, Decl(unwitnessedTypeParameterVariance.ts, 0, 0))
+>read : Symbol(read, Decl(unwitnessedTypeParameterVariance.ts, 9, 35))
+>origin : Symbol(origin, Decl(unwitnessedTypeParameterVariance.ts, 9, 43))
+>unk : Symbol(unk, Decl(unwitnessedTypeParameterVariance.ts, 9, 9))
+
+    const x: CalcObj<O> = unk;
+>x : Symbol(x, Decl(unwitnessedTypeParameterVariance.ts, 10, 9))
+>CalcObj : Symbol(CalcObj, Decl(unwitnessedTypeParameterVariance.ts, 0, 0))
+>O : Symbol(O, Decl(unwitnessedTypeParameterVariance.ts, 8, 13))
+>unk : Symbol(unk, Decl(unwitnessedTypeParameterVariance.ts, 9, 9))
+}
+
+type A<T> = B<T>;
+>A : Symbol(A, Decl(unwitnessedTypeParameterVariance.ts, 11, 1))
+>T : Symbol(T, Decl(unwitnessedTypeParameterVariance.ts, 13, 7))
+>B : Symbol(B, Decl(unwitnessedTypeParameterVariance.ts, 13, 17))
+>T : Symbol(T, Decl(unwitnessedTypeParameterVariance.ts, 13, 7))
+
+interface B<T> {
+>B : Symbol(B, Decl(unwitnessedTypeParameterVariance.ts, 13, 17))
+>T : Symbol(T, Decl(unwitnessedTypeParameterVariance.ts, 15, 12))
+
+    prop: A<T>;
+>prop : Symbol(B.prop, Decl(unwitnessedTypeParameterVariance.ts, 15, 16))
+>A : Symbol(A, Decl(unwitnessedTypeParameterVariance.ts, 11, 1))
+>T : Symbol(T, Decl(unwitnessedTypeParameterVariance.ts, 15, 12))
+}
+
+declare let a: A<number>;
+>a : Symbol(a, Decl(unwitnessedTypeParameterVariance.ts, 19, 11))
+>A : Symbol(A, Decl(unwitnessedTypeParameterVariance.ts, 11, 1))
+
+declare let b: A<3>;
+>b : Symbol(b, Decl(unwitnessedTypeParameterVariance.ts, 20, 11))
+>A : Symbol(A, Decl(unwitnessedTypeParameterVariance.ts, 11, 1))
+ 
+b = a;
+>b : Symbol(b, Decl(unwitnessedTypeParameterVariance.ts, 20, 11))
+>a : Symbol(a, Decl(unwitnessedTypeParameterVariance.ts, 19, 11))
+

tests/baselines/reference/unwitnessedTypeParameterVariance.types

@@ -0,0 +1,47 @@
+=== tests/cases/compiler/unwitnessedTypeParameterVariance.ts ===
+// Repros from #33872
+
+export interface CalcObj<O> {
+    read: (origin: O) => CalcValue<O>;
+>read : (origin: O) => CalcValue<O>
+>origin : O
+}
+
+export type CalcValue<O> = CalcObj<O>;
+>CalcValue : CalcValue<O>
+
+function foo<O>() {
+>foo : <O>() => void
+
+    const unk: CalcObj<unknown> = { read: (origin: unknown) => unk }
+>unk : CalcObj<unknown>
+>{ read: (origin: unknown) => unk } : { read: (origin: unknown) => CalcObj<unknown>; }
+>read : (origin: unknown) => CalcObj<unknown>
+>(origin: unknown) => unk : (origin: unknown) => CalcObj<unknown>
+>origin : unknown
+>unk : CalcObj<unknown>
+
+    const x: CalcObj<O> = unk;
+>x : CalcObj<O>
+>unk : CalcObj<unknown>
+}
+
+type A<T> = B<T>;
+>A : A<T>
+
+interface B<T> {
+    prop: A<T>;
+>prop : A<T>
+}
+
+declare let a: A<number>;
+>a : A<number>
+
+declare let b: A<3>;
+>b : A<3>
+ 
+b = a;
+>b = a : A<number>
+>b : A<3>
+>a : A<number>
+

tests/cases/compiler/unwitnessedTypeParameterVariance.ts

@@ -0,0 +1,25 @@
+// @strict: true
+
+// Repros from #33872
+
+export interface CalcObj<O> {
+    read: (origin: O) => CalcValue<O>;
+}
+
+export type CalcValue<O> = CalcObj<O>;
+
+function foo<O>() {
+    const unk: CalcObj<unknown> = { read: (origin: unknown) => unk }
+    const x: CalcObj<O> = unk;
+}
+
+type A<T> = B<T>;
+
+interface B<T> {
+    prop: A<T>;
+}
+
+declare let a: A<number>;
+declare let b: A<3>;
+ 
+b = a;