Write more useful types in .types test outputs (#48578)

Author: rbuckton

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