Write more useful types in .types test outputs

src/harness/typeWriter.ts

@@ -115,31 +115,39 @@ namespace Harness {
                 // let type = this.checker.getTypeAtLocation(node);
                 let type = ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) ? this.checker.getTypeAtLocation(node.parent) : undefined;
                 if (!type || type.flags & ts.TypeFlags.Any) type = this.checker.getTypeAtLocation(node);
-                const typeString =
-                    // Distinguish `errorType`s from `any`s; but only if the file has no errors.
-                    // Additionally,
-                    // * the LHS of a qualified name
-                    // * a binding pattern name
-                    // * labels
-                    // * the "global" in "declare global"
-                    // * the "target" in "new.target"
-                    // * names in import statements
-                    // * type-only names in export statements
-                    // * and intrinsic jsx tag names
-                    // return `error`s via `getTypeAtLocation`
-                    // But this is generally expected, so we don't call those out, either
-                    (!this.hadErrorBaseline &&
-                        type.flags & ts.TypeFlags.Any &&
-                        !ts.isBindingElement(node.parent) &&
-                        !ts.isPropertyAccessOrQualifiedName(node.parent) &&
-                        !ts.isLabelName(node) &&
-                        !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
-                        !ts.isMetaProperty(node.parent) &&
-                        !this.isImportStatementName(node) &&
-                        !this.isExportStatementName(node) &&
-                        !this.isIntrinsicJsxTag(node)) ?
-                        (type as ts.IntrinsicType).intrinsicName :
-                        this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+                // Distinguish `errorType`s from `any`s; but only if the file has no errors.
+                // Additionally,
+                // * the LHS of a qualified name
+                // * a binding pattern name
+                // * labels
+                // * the "global" in "declare global"
+                // * the "target" in "new.target"
+                // * names in import statements
+                // * type-only names in export statements
+                // * and intrinsic jsx tag names
+                // return `error`s via `getTypeAtLocation`
+                // But this is generally expected, so we don't call those out, either
+                let typeString: string;
+                if (!this.hadErrorBaseline &&
+                    type.flags & ts.TypeFlags.Any &&
+                    !ts.isBindingElement(node.parent) &&
+                    !ts.isPropertyAccessOrQualifiedName(node.parent) &&
+                    !ts.isLabelName(node) &&
+                    !(ts.isModuleDeclaration(node.parent) && ts.isGlobalScopeAugmentation(node.parent)) &&
+                    !ts.isMetaProperty(node.parent) &&
+                    !this.isImportStatementName(node) &&
+                    !this.isExportStatementName(node) &&
+                    !this.isIntrinsicJsxTag(node)) {
+                    typeString = (type as ts.IntrinsicType).intrinsicName;
+                }
+                else {
+                    typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType);
+                    if (ts.isIdentifier(node) && ts.isTypeAliasDeclaration(node.parent) && node.parent.name === node && typeString === ts.idText(node)) {
+                        // for a complex type alias `type T = ...`, showing "T : T" isn't very helpful for type tests. When the type produced is the same as
+                        // the name of the type alias, recreate the type string without reusing the alias name
+                        typeString = this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.AllowUniqueESSymbolType | ts.TypeFormatFlags.InTypeAlias);
+                    }
+                }
                 return {
                     line: lineAndCharacter.line,
                     syntaxKind: node.kind,

tests/baselines/reference/DeclarationErrorsNoEmitOnError.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/DeclarationErrorsNoEmitOnError.ts ===
 type T = { x : number }
->T : T
+>T : { x: number; }
 >x : number
 
 export interface I {

tests/baselines/reference/abstractClassUnionInstantiation.types

@@ -14,17 +14,17 @@ abstract class AbstractB { b: string; }
 >b : string
 
 type Abstracts = typeof AbstractA | typeof AbstractB;
->Abstracts : Abstracts
+>Abstracts : typeof AbstractA | typeof AbstractB
 >AbstractA : typeof AbstractA
 >AbstractB : typeof AbstractB
 
 type Concretes = typeof ConcreteA | typeof ConcreteB;
->Concretes : Concretes
+>Concretes : typeof ConcreteA | typeof ConcreteB
 >ConcreteA : typeof ConcreteA
 >ConcreteB : typeof ConcreteB
 
 type ConcretesOrAbstracts = Concretes | Abstracts;
->ConcretesOrAbstracts : ConcretesOrAbstracts
+>ConcretesOrAbstracts : Abstracts | Concretes
 
 declare const cls1: ConcretesOrAbstracts;
 >cls1 : ConcretesOrAbstracts

tests/baselines/reference/accessorBodyInTypeContext.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/accessorBodyInTypeContext.ts ===
 type A = {
->A : A
+>A : { readonly foo: number; }
 
     get foo() { return 0 }
 >foo : number
@@ -9,7 +9,7 @@ type A = {
 };
 
 type B = {
->B : B
+>B : { foo: any; }
 
     set foo(v: any) { }
 >foo : any

tests/baselines/reference/aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.types

@@ -8,10 +8,10 @@ type ExtendedMapper<HandledInputT, OutputT, ArgsT extends any[]> = (name : strin
 >args : ArgsT
 
 type a = ExtendedMapper<any, any, [any]>;
->a : a
+>a : (name: string, mixed: any, args_0: any) => any
 
 type b = ExtendedMapper<any, any, any[]>;
->b : b
+>b : (name: string, mixed: any, ...args: any[]) => any
 
 type test = a extends b ? "y" : "n"
 >test : "y"
@@ -32,10 +32,10 @@ type ExtendedMapper1<HandledInputT, OutputT, ArgsT extends any[]> = (
 );
 
 type a1 = ExtendedMapper1<any, any, [any]>;
->a1 : a1
+>a1 : (name: string, mixed: any, args_0: any) => any
 
 type b1 = ExtendedMapper1<any, any, any[]>;
->b1 : b1
+>b1 : (name: string, mixed: any, ...args: any[]) => any
 
 type test1 = a1 extends b1 ? "y" : "n"
 >test1 : "y"
@@ -56,10 +56,10 @@ type ExtendedMapper2<HandledInputT, OutputT, ArgsT extends any[]> = (
 );
 
 type a2 = ExtendedMapper2<any, any, [any]>;
->a2 : a2
+>a2 : (name: string, mixed: any, args_0: any) => any
 
 type b2 = ExtendedMapper2<any, any, any[]>;
->b2 : b2
+>b2 : (name: string, mixed: any, ...args: any[]) => any
 
 type test2 = a2 extends b2 ? "y" : "n"
 >test2 : "y"
@@ -69,13 +69,13 @@ let check2: test2 = "y";
 >"y" : "y"
 
 type a3 = (name: string, mixed: any, args_0: any) => any
->a3 : a3
+>a3 : (name: string, mixed: any, args_0: any) => any
 >name : string
 >mixed : any
 >args_0 : any
 
 type b3 = (name: string, mixed: any, ...args: any[]) => any
->b3 : b3
+>b3 : (name: string, mixed: any, ...args: any[]) => any
 >name : string
 >mixed : any
 >args : any[]

tests/baselines/reference/anyMappedTypesError.types

@@ -1,4 +1,4 @@
 === tests/cases/compiler/anyMappedTypesError.ts ===
 type Foo = {[P in "bar"]};
->Foo : Foo
+>Foo : { bar: any; }
 

tests/baselines/reference/argumentsAsPropertyName.types

@@ -1,7 +1,7 @@
 === tests/cases/compiler/argumentsAsPropertyName.ts ===
 // target: es5
 type MyType = {
->MyType : MyType
+>MyType : { arguments: Array<string>; }
 
     arguments: Array<string>
 >arguments : string[]

tests/baselines/reference/arrayDestructuringInSwitch1.types

@@ -1,9 +1,9 @@
 === tests/cases/compiler/arrayDestructuringInSwitch1.ts ===
 export type Expression = BooleanLogicExpression | 'true' | 'false';
->Expression : Expression
+>Expression : BooleanLogicExpression | "true" | "false"
 
 export type BooleanLogicExpression = ['and', ...Expression[]] | ['not', Expression];
->BooleanLogicExpression : BooleanLogicExpression
+>BooleanLogicExpression : ["and", ...Expression[]] | ["not", Expression]
 
 export function evaluate(expression: Expression): boolean {
 >evaluate : (expression: Expression) => boolean

tests/baselines/reference/arrayDestructuringInSwitch2.types

@@ -1,6 +1,6 @@
 === tests/cases/compiler/arrayDestructuringInSwitch2.ts ===
 type X = { kind: "a", a: [1] } | { kind: "b", a: [] }
->X : X
+>X : { kind: "a"; a: [1]; } | { kind: "b"; a: []; }
 >kind : "a"
 >a : [1]
 >kind : "b"

tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types

@@ -18,7 +18,7 @@ interface Dog {
 }
 
 type Animal = Cat | Dog;
->Animal : Animal
+>Animal : Cat | Dog
 
 declare function assertEqual<T>(value: any, type: T): asserts value is T;
 >assertEqual : <T>(value: any, type: T) => asserts value is T

tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.types

@@ -6,12 +6,12 @@ namespace Example1 {
 >Example1 : typeof Example1
 
     type S = { done: boolean, value: number };
->S : S
+>S : { done: boolean; value: number; }
 >done : boolean
 >value : number
 
     type T =
->T : T
+>T : { done: true; value: number; } | { done: false; value: number; }
 
         | { done: true, value: number }     // T0
 >done : true
@@ -42,12 +42,12 @@ namespace Example2 {
 >Example2 : typeof Example2
 
     type S = { a: 0 | 2, b: 4 };
->S : S
+>S : { a: 0 | 2; b: 4; }
 >a : 0 | 2
 >b : 4
 
     type T = { a: 0,     b: 1 | 4 }     // T0
->T : T
+>T : { a: 0; b: 1 | 4; } | { a: 1; b: 2; } | { a: 2; b: 3 | 4; }
 >a : 0
 >b : 4 | 1
 
@@ -78,12 +78,12 @@ namespace Example3 {
 >Example3 : typeof Example3
 
     type S = { a: 0 | 2, b: 4 };
->S : S
+>S : { a: 0 | 2; b: 4; }
 >a : 0 | 2
 >b : 4
 
     type T = { a: 0,     b: 1 | 4 }     // T0
->T : T
+>T : { a: 0; b: 1 | 4; } | { a: 1; b: 2 | 4; } | { a: 2; b: 3; }
 >a : 0
 >b : 4 | 1
 
@@ -115,12 +115,12 @@ namespace Example4 {
 >Example4 : typeof Example4
 
     type S = { a: 0 | 2, b: 4 };
->S : S
+>S : { a: 0 | 2; b: 4; }
 >a : 0 | 2
 >b : 4
 
     type T = { a: 0,     b: 1 | 4 }             // T0
->T : T
+>T : { a: 0; b: 1 | 4; } | { a: 1; b: 2; } | { a: 2; b: 3 | 4; c: string; }
 >a : 0
 >b : 4 | 1
 
@@ -155,16 +155,16 @@ namespace Example5 {
     //       3 discriminant properties with 3 types a piece
     //       is 27 possible combinations.
     type N = 0 | 1 | 2;
->N : N
+>N : 0 | 2 | 1
 
     type S = { a: N, b: N, c: N };
->S : S
+>S : { a: N; b: N; c: N; }
 >a : N
 >b : N
 >c : N
 
     type T = { a: 0, b: N, c: N }
->T : T
+>T : { a: 0; b: N; c: N; } | { a: 1; b: N; c: N; } | { a: 2; b: N; c: N; } | { a: N; b: 0; c: N; } | { a: N; b: 1; c: N; } | { a: N; b: 2; c: N; } | { a: N; b: N; c: 0; } | { a: N; b: N; c: 1; } | { a: N; b: N; c: 2; }
 >a : 0
 >b : N
 >c : N
@@ -228,7 +228,7 @@ namespace GH14865 {
 >GH14865 : typeof GH14865
 
     type Style1 = {
->Style1 : Style1
+>Style1 : { type: "A"; data: string; } | { type: "B"; data: string; }
 
         type: "A";
 >type : "A"
@@ -246,7 +246,7 @@ namespace GH14865 {
     };
 
     type Style2 = {
->Style2 : Style2
+>Style2 : { type: "A" | "B"; data: string; }
 
         type: "A" | "B";
 >type : "A" | "B"
@@ -322,10 +322,10 @@ namespace GH12052 {
 >type : "categorical"
 
     type IAxis = ILinearAxis | ICategoricalAxis;
->IAxis : IAxis
+>IAxis : ILinearAxis | ICategoricalAxis
 
     type IAxisType = "linear" | "categorical";
->IAxisType : IAxisType
+>IAxisType : "linear" | "categorical"
 
     function getAxisType(): IAxisType {
 >getAxisType : () => IAxisType
@@ -381,10 +381,10 @@ namespace GH18421 {
     }
 
     type ThingType = 'one' | 'two';
->ThingType : ThingType
+>ThingType : "one" | "two"
 
     type Thing = ThingTypeOne | ThingTypeTwo;
->Thing : Thing
+>Thing : ThingTypeOne | ThingTypeTwo
 
     function makeNewThing(thingType: ThingType): Thing {
 >makeNewThing : (thingType: ThingType) => Thing
@@ -406,7 +406,7 @@ namespace GH15907 {
 >GH15907 : typeof GH15907
 
     type Action = { type: 'activate' } | { type: 'disactivate' };
->Action : Action
+>Action : { type: 'activate'; } | { type: 'disactivate'; }
 >type : "activate"
 >type : "disactivate"
 
@@ -445,7 +445,7 @@ namespace GH20889 {
 >type : "A2"
     }
     type AU = A1 | A2;
->AU : AU
+>AU : A1 | A2
 
     function foo(obj1: AU) {
 >foo : (obj1: AU) => void
@@ -470,10 +470,10 @@ namespace GH39357 {
 >GH39357 : typeof GH39357
 
     type A = ["a", number] | ["b", number] | ["c", string];
->A : A
+>A : ["a", number] | ["b", number] | ["c", string]
 
     type B = "a" | "b" | "c";
->B : B
+>B : "a" | "b" | "c"
 
     declare const b: B;
 >b : B

tests/baselines/reference/asyncFunctionContextuallyTypedReturns.types

@@ -64,7 +64,7 @@ g(async v => v ? "contextuallyTypable" : Promise.reject());
 >reject : <T = never>(reason?: any) => Promise<T>
 
 type MyCallback = (thing: string) => void;
->MyCallback : MyCallback
+>MyCallback : (thing: string) => void
 >thing : string
 
 declare function h(cb: (v: boolean) => MyCallback | PromiseLike<MyCallback>): void;

tests/baselines/reference/awaitedType.types

@@ -9,7 +9,7 @@ type T3 = Awaited<number | Promise<number>>;
 >T3 : number
 
 type T4 = Awaited<number | Promise<string>>;
->T4 : T4
+>T4 : string | number
 
 type T5 = Awaited<{ then: number }>;
 >T5 : { then: number; }

tests/baselines/reference/awaitedTypeStrictNull.types

@@ -9,7 +9,7 @@ type T3 = Awaited<number | Promise<number>>;
 >T3 : number
 
 type T4 = Awaited<number | Promise<string>>;
->T4 : T4
+>T4 : string | number
 
 type T5 = Awaited<{ then: number }>;
 >T5 : { then: number; }