Recursive type references

src/compiler/symbolWalker.ts

@@ -10,7 +10,8 @@ namespace ts {
         getResolvedSymbol: (node: Node) => Symbol,
         getIndexTypeOfStructuredType: (type: Type, kind: IndexKind) => Type | undefined,
         getConstraintOfTypeParameter: (typeParameter: TypeParameter) => Type | undefined,
-        getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier) {
+        getFirstIdentifier: (node: EntityNameOrEntityNameExpression) => Identifier,
+        getTypeArguments: (type: TypeReference) => readonly Type[]) {
 
         return getSymbolWalker;
 
@@ -89,7 +90,7 @@ namespace ts {
 
             function visitTypeReference(type: TypeReference): void {
                 visitType(type.target);
-                forEach(type.typeArguments, visitType);
+                forEach(getTypeArguments(type), visitType);
             }
 
             function visitTypeParameter(type: TypeParameter): void {

src/compiler/types.ts

@@ -3191,6 +3191,7 @@ namespace ts {
         /* @internal */ getParameterType(signature: Signature, parameterIndex: number): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
+        getTypeArguments(type: TypeReference): readonly Type[];
 
         // TODO: GH#18217 `xToDeclaration` calls are frequently asserted as defined.
         /** Note that the resulting nodes cannot be checked. */
@@ -4025,6 +4026,8 @@ namespace ts {
         contextFreeType?: Type;          // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive
         deferredNodes?: Map<Node>; // Set of nodes whose checking has been deferred
         capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement
+        outerTypeParameters?: TypeParameter[];  // Outer type parameters of anonymous object type
+        instantiations?: Map<Type>;         // Instantiations of generic type alias (undefined if non-generic)
         isExhaustive?: boolean;           // Is node an exhaustive switch statement
     }
 
@@ -4272,11 +4275,22 @@ namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;    // Type reference target
-        typeArguments?: readonly Type[];  // Type reference type arguments (undefined if none)
+        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+        /* @internal */
+        mapper?: TypeMapper;
+        /* @internal */
+        resolvedTypeArguments?: readonly Type[];  // Resolved type reference type arguments
         /* @internal */
         literalType?: TypeReference;  // Clone of type with ObjectFlags.ArrayLiteral set
     }
 
+    export interface DeferredTypeReference extends TypeReference {
+        /* @internal */
+        node: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+        /* @internal */
+        mapper?: TypeMapper;
+    }
+
     /* @internal */
     export const enum VarianceFlags {
         Invariant     =      0,  // Neither covariant nor contravariant

src/services/codefixes/inferFromUsage.ts

@@ -993,8 +993,8 @@ namespace ts.codefix {
             }
             else if (getObjectFlags(genericType) & ObjectFlags.Reference && getObjectFlags(usageType) & ObjectFlags.Reference) {
                 // this is wrong because we need a reference to the targetType to, so we can check that it's also a reference
-                const genericArgs = (genericType as TypeReference).typeArguments;
-                const usageArgs = (usageType as TypeReference).typeArguments;
+                const genericArgs = checker.getTypeArguments(genericType as TypeReference);
+                const usageArgs = checker.getTypeArguments(usageType as TypeReference);
                 const types = [];
                 if (genericArgs && usageArgs) {
                     for (let i = 0; i < genericArgs.length; i++) {

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -1967,6 +1967,7 @@ declare namespace ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
+        getTypeArguments(type: TypeReference): readonly Type[];
         /** Note that the resulting nodes cannot be checked. */
         typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode | undefined;
         /** Note that the resulting nodes cannot be checked. */
@@ -2388,7 +2389,9 @@ declare namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;
-        typeArguments?: readonly Type[];
+        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+    }
+    export interface DeferredTypeReference extends TypeReference {
     }
     export interface GenericType extends InterfaceType, TypeReference {
     }

tests/baselines/reference/api/typescript.d.ts

@@ -1967,6 +1967,7 @@ declare namespace ts {
         getReturnTypeOfSignature(signature: Signature): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;
+        getTypeArguments(type: TypeReference): readonly Type[];
         /** Note that the resulting nodes cannot be checked. */
         typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode | undefined;
         /** Note that the resulting nodes cannot be checked. */
@@ -2388,7 +2389,9 @@ declare namespace ts {
      */
     export interface TypeReference extends ObjectType {
         target: GenericType;
-        typeArguments?: readonly Type[];
+        node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode;
+    }
+    export interface DeferredTypeReference extends TypeReference {
     }
     export interface GenericType extends InterfaceType, TypeReference {
     }

tests/baselines/reference/asyncAliasReturnType_es5.types

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es5/asyncAliasReturnType_es5.ts ===
 type PromiseAlias<T> = Promise<T>;
->PromiseAlias : Promise<T>
+>PromiseAlias : PromiseAlias<T>
 
 async function f(): PromiseAlias<void> {
->f : () => Promise<void>
+>f : () => PromiseAlias<void>
 }

tests/baselines/reference/asyncAliasReturnType_es6.types

@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts ===
 type PromiseAlias<T> = Promise<T>;
->PromiseAlias : Promise<T>
+>PromiseAlias : PromiseAlias<T>
 
 async function f(): PromiseAlias<void> {
->f : () => Promise<void>
+>f : () => PromiseAlias<void>
 }

tests/baselines/reference/asyncAwait_es2017.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es2017/asyncAwait_es2017.ts ===
 type MyPromise<T> = Promise<T>;
->MyPromise : Promise<T>
+>MyPromise : MyPromise<T>
 
 declare var MyPromise: typeof Promise;
 >MyPromise : PromiseConstructor
@@ -10,7 +10,7 @@ declare var p: Promise<number>;
 >p : Promise<number>
 
 declare var mp: MyPromise<number>;
->mp : Promise<number>
+>mp : MyPromise<number>
 
 async function f0() { }
 >f0 : () => Promise<void>
@@ -19,7 +19,7 @@ async function f1(): Promise<void> { }
 >f1 : () => Promise<void>
 
 async function f3(): MyPromise<void> { }
->f3 : () => Promise<void>
+>f3 : () => MyPromise<void>
 
 let f4 = async function() { }
 >f4 : () => Promise<void>
@@ -30,8 +30,8 @@ let f5 = async function(): Promise<void> { }
 >async function(): Promise<void> { } : () => Promise<void>
 
 let f6 = async function(): MyPromise<void> { }
->f6 : () => Promise<void>
->async function(): MyPromise<void> { } : () => Promise<void>
+>f6 : () => MyPromise<void>
+>async function(): MyPromise<void> { } : () => MyPromise<void>
 
 let f7 = async () => { };
 >f7 : () => Promise<void>
@@ -42,8 +42,8 @@ let f8 = async (): Promise<void> => { };
 >async (): Promise<void> => { } : () => Promise<void>
 
 let f9 = async (): MyPromise<void> => { };
->f9 : () => Promise<void>
->async (): MyPromise<void> => { } : () => Promise<void>
+>f9 : () => MyPromise<void>
+>async (): MyPromise<void> => { } : () => MyPromise<void>
 
 let f10 = async () => p;
 >f10 : () => Promise<number>
@@ -53,21 +53,21 @@ let f10 = async () => p;
 let f11 = async () => mp;
 >f11 : () => Promise<number>
 >async () => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f12 = async (): Promise<number> => mp;
 >f12 : () => Promise<number>
 >async (): Promise<number> => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f13 = async (): MyPromise<number> => p;
->f13 : () => Promise<number>
->async (): MyPromise<number> => p : () => Promise<number>
+>f13 : () => MyPromise<number>
+>async (): MyPromise<number> => p : () => MyPromise<number>
 >p : Promise<number>
 
 let o = {
->o : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
->{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
+>o : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
+>{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
 
 	async m1() { },
 >m1 : () => Promise<void>
@@ -76,7 +76,7 @@ let o = {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 };
 
@@ -90,7 +90,7 @@ class C {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 	static async m4() { }
 >m4 : () => Promise<void>
@@ -99,7 +99,7 @@ class C {
 >m5 : () => Promise<void>
 
 	static async m6(): MyPromise<void> { }
->m6 : () => Promise<void>
+>m6 : () => MyPromise<void>
 }
 
 module M {

tests/baselines/reference/asyncAwait_es5.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es5/asyncAwait_es5.ts ===
 type MyPromise<T> = Promise<T>;
->MyPromise : Promise<T>
+>MyPromise : MyPromise<T>
 
 declare var MyPromise: typeof Promise;
 >MyPromise : PromiseConstructor
@@ -10,7 +10,7 @@ declare var p: Promise<number>;
 >p : Promise<number>
 
 declare var mp: MyPromise<number>;
->mp : Promise<number>
+>mp : MyPromise<number>
 
 async function f0() { }
 >f0 : () => Promise<void>
@@ -19,7 +19,7 @@ async function f1(): Promise<void> { }
 >f1 : () => Promise<void>
 
 async function f3(): MyPromise<void> { }
->f3 : () => Promise<void>
+>f3 : () => MyPromise<void>
 
 let f4 = async function() { }
 >f4 : () => Promise<void>
@@ -30,8 +30,8 @@ let f5 = async function(): Promise<void> { }
 >async function(): Promise<void> { } : () => Promise<void>
 
 let f6 = async function(): MyPromise<void> { }
->f6 : () => Promise<void>
->async function(): MyPromise<void> { } : () => Promise<void>
+>f6 : () => MyPromise<void>
+>async function(): MyPromise<void> { } : () => MyPromise<void>
 
 let f7 = async () => { };
 >f7 : () => Promise<void>
@@ -42,8 +42,8 @@ let f8 = async (): Promise<void> => { };
 >async (): Promise<void> => { } : () => Promise<void>
 
 let f9 = async (): MyPromise<void> => { };
->f9 : () => Promise<void>
->async (): MyPromise<void> => { } : () => Promise<void>
+>f9 : () => MyPromise<void>
+>async (): MyPromise<void> => { } : () => MyPromise<void>
 
 let f10 = async () => p;
 >f10 : () => Promise<number>
@@ -53,21 +53,21 @@ let f10 = async () => p;
 let f11 = async () => mp;
 >f11 : () => Promise<number>
 >async () => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f12 = async (): Promise<number> => mp;
 >f12 : () => Promise<number>
 >async (): Promise<number> => mp : () => Promise<number>
->mp : Promise<number>
+>mp : MyPromise<number>
 
 let f13 = async (): MyPromise<number> => p;
->f13 : () => Promise<number>
->async (): MyPromise<number> => p : () => Promise<number>
+>f13 : () => MyPromise<number>
+>async (): MyPromise<number> => p : () => MyPromise<number>
 >p : Promise<number>
 
 let o = {
->o : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
->{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): Promise<void>; }
+>o : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
+>{	async m1() { },	async m2(): Promise<void> { },	async m3(): MyPromise<void> { }} : { m1(): Promise<void>; m2(): Promise<void>; m3(): MyPromise<void>; }
 
 	async m1() { },
 >m1 : () => Promise<void>
@@ -76,7 +76,7 @@ let o = {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 };
 
@@ -90,7 +90,7 @@ class C {
 >m2 : () => Promise<void>
 
 	async m3(): MyPromise<void> { }
->m3 : () => Promise<void>
+>m3 : () => MyPromise<void>
 
 	static async m4() { }
 >m4 : () => Promise<void>
@@ -99,7 +99,7 @@ class C {
 >m5 : () => Promise<void>
 
 	static async m6(): MyPromise<void> { }
->m6 : () => Promise<void>
+>m6 : () => MyPromise<void>
 }
 
 module M {