Cherry pick PR 57887 into release-5.4 (#57898)

Co-authored-by: Wesley Wigham <wewigham@microsoft.com>
2025-11-18 17:21:48 +00:00 · 2024-03-28 16:13:11 -07:00
parent 896947e393
commit 3caec2caef
160 changed files with 494 additions and 384 deletions
@@ -6306,7 +6306,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
        }
    }

-    function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
+    function getMeaningOfEntityNameReference(entityName: EntityNameOrEntityNameExpression): SymbolFlags {
        // get symbol of the first identifier of the entityName
        let meaning: SymbolFlags;
        if (
@@ -6319,7 +6319,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
        }
        else if (
            entityName.kind === SyntaxKind.QualifiedName || entityName.kind === SyntaxKind.PropertyAccessExpression ||
-            entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration
+            entityName.parent.kind === SyntaxKind.ImportEqualsDeclaration ||
+            (entityName.parent.kind === SyntaxKind.QualifiedName && (entityName.parent as QualifiedName).left === entityName) ||
+            (entityName.parent.kind === SyntaxKind.PropertyAccessExpression && (entityName.parent as PropertyAccessExpression).expression === entityName) ||
+            (entityName.parent.kind === SyntaxKind.ElementAccessExpression && (entityName.parent as ElementAccessExpression).expression === entityName)
        ) {
            // Left identifier from type reference or TypeAlias
            // Entity name of the import declaration
@@ -6329,7 +6332,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
            // Type Reference or TypeAlias entity = Identifier
            meaning = SymbolFlags.Type;
        }
+        return meaning;
+    }

+    function isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult {
+        const meaning = getMeaningOfEntityNameReference(entityName);
        const firstIdentifier = getFirstIdentifier(entityName);
        const symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false);
        if (symbol && symbol.flags & SymbolFlags.TypeParameter && meaning & SymbolFlags.Type) {
@@ -8512,13 +8519,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                introducesError = true;
                return { introducesError, node };
            }
-            const sym = resolveEntityName(leftmost, SymbolFlags.All, /*ignoreErrors*/ true, /*dontResolveAlias*/ true);
+            const meaning = getMeaningOfEntityNameReference(node);
+            const sym = resolveEntityName(leftmost, meaning, /*ignoreErrors*/ true, /*dontResolveAlias*/ true);
            if (sym) {
-                if (isSymbolAccessible(sym, context.enclosingDeclaration, SymbolFlags.All, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== SymbolAccessibility.Accessible) {
+                if (isSymbolAccessible(sym, context.enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== SymbolAccessibility.Accessible) {
                    introducesError = true;
                }
                else {
-                    context.tracker.trackSymbol(sym, context.enclosingDeclaration, SymbolFlags.All);
+                    context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
                    includePrivateSymbol?.(sym);
                }
                if (isIdentifier(node)) {
@@ -2,6 +2,6 @@

 === ParameterList5.ts ===
 function A(): (public B) => C {
->A : () => (B: any) => C
+>A : () => (public B) => C
 >B : any
 }
@@ -4,7 +4,7 @@
 // from webpack/lib/Compilation.js and filed at #26427
 /** @param {{ [s: string]: number }} map */
 function mappy(map) {}
->mappy : (map: { [s: string]: number; }) => void
+>mappy : (map: {    [s: string]: number;}) => void
 >map : { [s: string]: number; }

 export class C {
@@ -8,7 +8,7 @@ module M {
 >C : C

        m(fn:{ (n:number):string; },n2:number):string {
->m : (fn: (n: number) => string, n2: number) => string
+>m : (fn: {    (n: number): string;}, n2: number) => string
 >fn : (n: number) => string
 >n : number
 >n2 : number
@@ -168,7 +168,7 @@ var r3 = foo3(a); // any
 >a : any

 declare function foo12(x: (x) => number): (x) => number;
->foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
+>foo12 : { (x: (x) => number): (x) => number; (x: any): any; }
 >x : (x: any) => number
 >x : any
 >x : any
@@ -35,7 +35,7 @@ function foo(animals: IAnimal[]) { }
 >animals : IAnimal[]

 function bar(animals: { [n: number]: IAnimal }) { }
->bar : (animals: { [n: number]: IAnimal; }) => void
+>bar : (animals: {    [n: number]: IAnimal;}) => void
 >animals : { [n: number]: IAnimal; }
 >n : number

@@ -130,7 +130,7 @@ var a17: {

 };
 var a18: {
->a18 : { (x: { (a: number): number; (a: string): string; }): any[]; (x: { (a: boolean): boolean; (a: Date): Date; }): any[]; }
+>a18 : { (x: {    (a: number): number;    (a: string): string;}): any[]; (x: {    (a: boolean): boolean;    (a: Date): Date;}): any[]; }

    (x: {
 >x : { (a: number): number; (a: string): string; }
@@ -81,7 +81,7 @@ module Errors {
 >b : number

        var a16: {
->a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; }
+>a16 : { (x: {    (a: number): number;    (a?: number): number;}): number[]; (x: {    (a: boolean): boolean;    (a?: boolean): boolean;}): boolean[]; }

                (x: {
 >x : { (a: number): number; (a?: number): number; }
@@ -130,7 +130,7 @@ var a17: {

 };
 var a18: {
->a18 : { new (x: { new (a: number): number; new (a: string): string; }): any[]; new (x: { new (a: boolean): boolean; new (a: Date): Date; }): any[]; }
+>a18 : { new (x: {    new (a: number): number;    new (a: string): string;}): any[]; new (x: {    new (a: boolean): boolean;    new (a: Date): Date;}): any[]; }

    new (x: {
 >x : { new (a: number): number; new (a: string): string; }
@@ -81,7 +81,7 @@ module Errors {
 >b : number

        var a16: {
->a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; }
+>a16 : { new (x: {    new (a: number): number;    new (a?: number): number;}): number[]; new (x: {    new (a: boolean): boolean;    new (a?: boolean): boolean;}): boolean[]; }

                new (x: {
 >x : { new (a: number): number; new (a?: number): number; }
@@ -104,7 +104,7 @@ h(async v => v ? (def) => { } : Promise.reject());

 // repro from #29196
 const increment: (
->increment : (num: number, str: string) => string | Promise<string | ((s: string) => any)>
+>increment : (num: number, str: string) => Promise<((s: string) => any) | string> | string

  num: number,
 >num : number
@@ -130,7 +130,7 @@ const increment: (
 }

 const increment2: (
->increment2 : (num: number, str: string) => Promise<string | ((s: string) => any)>
+>increment2 : (num: number, str: string) => Promise<((s: string) => any) | string>

  num: number,
 >num : number
@@ -4,7 +4,7 @@
 declare namespace Windows.Foundation {
    interface IPromise<TResult> {
        then<U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
->then : { <U>(success?: ((value: TResult) => IPromise<U>) | undefined, error?: ((error: any) => IPromise<U>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U>; <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => U_1) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U_2>(success?: ((value: TResult) => U_2) | undefined, error?: ((error: any) => IPromise<U_2>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => U_3) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; }
+>then : { <U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => U_1) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U_2>(success?: ((value: TResult) => U_2) | undefined, error?: ((error: any) => IPromise<U_2>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => U_3) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; }
 >success : ((value: TResult) => IPromise<U>) | undefined
 >value : TResult
 >error : ((error: any) => IPromise<U>) | undefined
@@ -13,7 +13,7 @@ declare namespace Windows.Foundation {
 >progress : any

        then<U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
->then : { <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => IPromise<U_1>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U>(success?: ((value: TResult) => IPromise<U>) | undefined, error?: ((error: any) => U) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U>; <U_2>(success?: ((value: TResult) => U_2) | undefined, error?: ((error: any) => IPromise<U_2>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => U_3) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; }
+>then : { <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => IPromise<U_1>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U>(success?: (value: TResult) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U_2>(success?: ((value: TResult) => U_2) | undefined, error?: ((error: any) => IPromise<U_2>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => U_3) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; }
 >success : ((value: TResult) => IPromise<U>) | undefined
 >value : TResult
 >error : ((error: any) => U) | undefined
@@ -22,7 +22,7 @@ declare namespace Windows.Foundation {
 >progress : any

        then<U>(success?: (value: TResult) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
->then : { <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => IPromise<U_1>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U_2>(success?: ((value: TResult) => IPromise<U_2>) | undefined, error?: ((error: any) => U_2) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U>(success?: ((value: TResult) => U) | undefined, error?: ((error: any) => IPromise<U>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => U_3) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; }
+>then : { <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => IPromise<U_1>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U_2>(success?: ((value: TResult) => IPromise<U_2>) | undefined, error?: ((error: any) => U_2) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U>(success?: (value: TResult) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => U_3) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; }
 >success : ((value: TResult) => U) | undefined
 >value : TResult
 >error : ((error: any) => IPromise<U>) | undefined
@@ -31,7 +31,7 @@ declare namespace Windows.Foundation {
 >progress : any

        then<U>(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
->then : { <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => IPromise<U_1>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U_2>(success?: ((value: TResult) => IPromise<U_2>) | undefined, error?: ((error: any) => U_2) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => IPromise<U_3>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; <U>(success?: ((value: TResult) => U) | undefined, error?: ((error: any) => U) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U>; }
+>then : { <U_1>(success?: ((value: TResult) => IPromise<U_1>) | undefined, error?: ((error: any) => IPromise<U_1>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_1>; <U_2>(success?: ((value: TResult) => IPromise<U_2>) | undefined, error?: ((error: any) => U_2) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_2>; <U_3>(success?: ((value: TResult) => U_3) | undefined, error?: ((error: any) => IPromise<U_3>) | undefined, progress?: ((progress: any) => void) | undefined): IPromise<U_3>; <U>(success?: (value: TResult) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }
 >success : ((value: TResult) => U) | undefined
 >value : TResult
 >error : ((error: any) => U) | undefined
@@ -40,7 +40,7 @@ declare namespace Windows.Foundation {
 >progress : any

        done<U>(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
->done : <U>(success?: ((value: TResult) => any) | undefined, error?: ((error: any) => any) | undefined, progress?: ((progress: any) => void) | undefined) => void
+>done : <U>(success?: (value: TResult) => any, error?: (error: any) => any, progress?: (progress: any) => void) => void
 >success : ((value: TResult) => any) | undefined
 >value : TResult
 >error : ((error: any) => any) | undefined
@@ -5,7 +5,7 @@ declare const foo: ["a", string, number] | ["b", string, boolean];
 >foo : ["a", string, number] | ["b", string, boolean]

 export function test(arg: { index?: number }) {
->test : (arg: { index?: number | undefined; }) => void
+>test : (arg: {    index?: number;}) => void
 >arg : { index?: number | undefined; }
 >index : number | undefined

@@ -134,7 +134,7 @@ interface A { // T

    };
    a18: {
->a18 : { (x: { (a: number): number; (a: string): string; }): any[]; (x: { (a: boolean): boolean; (a: Date): Date; }): any[]; }
+>a18 : { (x: {    (a: number): number;    (a: string): string;}): any[]; (x: {    (a: boolean): boolean;    (a: Date): Date;}): any[]; }

        (x: {
 >x : { (a: number): number; (a: string): string; }
@@ -81,7 +81,7 @@ module Errors {
 >b : number

            a16: {
->a16 : { (x: { (a: number): number; (a?: number): number; }): number[]; (x: { (a: boolean): boolean; (a?: boolean): boolean; }): boolean[]; }
+>a16 : { (x: {    (a: number): number;    (a?: number): number;}): number[]; (x: {    (a: boolean): boolean;    (a?: boolean): boolean;}): boolean[]; }

                // type of parameter is overload set which means we can't do inference based on this type
                (x: {
@@ -46,13 +46,13 @@ function test2() {

    interface Messages {
        readonly foo: (options: { [key: string]: any, b: number }) => string;
->foo : (options: { [key: string]: any; b: number; }) => string
+>foo : (options: {    [key: string]: any;    b: number;}) => string
 >options : { [key: string]: any; b: number; }
 >key : string
 >b : number

        readonly bar: (options: { [key: string]: any, a: string }) => string;
->bar : (options: { [key: string]: any; a: string; }) => string
+>bar : (options: {    [key: string]: any;    a: string;}) => string
 >options : { [key: string]: any; a: string; }
 >key : string
 >a : string
@@ -12,7 +12,7 @@ var v12: (arguments: number, ...restParameters) => void; // no error - no code g
 >restParameters : any[]

 var v2: {
->v2 : { (arguments: number, ...restParameters: any[]): any; new (arguments: number, ...restParameters: any[]): any; foo(arguments: number, ...restParameters: any[]): any; prop: (arguments: number, ...restParameters: any[]) => void; }
+>v2 : { (arguments: number, ...restParameters: any[]): any; new (arguments: number, ...restParameters: any[]): any; foo(arguments: number, ...restParameters: any[]): any; prop: (arguments: number, ...restParameters) => void; }

    (arguments: number, ...restParameters); // no error - no code gen
 >arguments : number
@@ -33,7 +33,7 @@ var v2: {
 >restParameters : any[]
 }
 var v21: {
->v21 : { (i: number, ...arguments: any[]): any; new (i: number, ...arguments: any[]): any; foo(i: number, ...arguments: any[]): any; prop: (i: number, ...arguments: any[]) => void; }
+>v21 : { (i: number, ...arguments: any[]): any; new (i: number, ...arguments: any[]): any; foo(i: number, ...arguments: any[]): any; prop: (i: number, ...arguments) => void; }

    (i: number, ...arguments); // no error - no code gen
 >i : number
@@ -7,7 +7,7 @@ var v1: (_i: number, ...restParameters) => void; // no error - no code gen
 >restParameters : any[]

 var v2: {
->v2 : { (_i: number, ...restParameters: any[]): any; new (_i: number, ...restParameters: any[]): any; foo(_i: number, ...restParameters: any[]): any; prop: (_i: number, ...restParameters: any[]) => void; }
+>v2 : { (_i: number, ...restParameters: any[]): any; new (_i: number, ...restParameters: any[]): any; foo(_i: number, ...restParameters: any[]): any; prop: (_i: number, ...restParameters) => void; }

    (_i: number, ...restParameters); // no error - no code gen
 >_i : number
@@ -418,12 +418,12 @@ declare module Immutable {
 >value : this

    merge(...collections: Array<Collection<K, V> | {[key: string]: V}>): this;
->merge : (...collections: (Collection<K, V> | { [key: string]: V; })[]) => this
+>merge : (...collections: Array<Collection<K, V> | {    [key: string]: V;}>) => this
 >collections : (Collection<K, V> | { [key: string]: V; })[]
 >key : string

    mergeWith(merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array<Collection<K, V> | {[key: string]: V}>): this;
->mergeWith : (merger: (oldVal: V, newVal: V, key: K) => V, ...collections: (Collection<K, V> | { [key: string]: V; })[]) => this
+>mergeWith : (merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array<Collection<K, V> | {    [key: string]: V;}>) => this
 >merger : (oldVal: V, newVal: V, key: K) => V
 >oldVal : V
 >newVal : V
@@ -432,12 +432,12 @@ declare module Immutable {
 >key : string

    mergeDeep(...collections: Array<Collection<K, V> | {[key: string]: V}>): this;
->mergeDeep : (...collections: (Collection<K, V> | { [key: string]: V; })[]) => this
+>mergeDeep : (...collections: Array<Collection<K, V> | {    [key: string]: V;}>) => this
 >collections : (Collection<K, V> | { [key: string]: V; })[]
 >key : string

    mergeDeepWith(merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array<Collection<K, V> | {[key: string]: V}>): this;
->mergeDeepWith : (merger: (oldVal: V, newVal: V, key: K) => V, ...collections: (Collection<K, V> | { [key: string]: V; })[]) => this
+>mergeDeepWith : (merger: (oldVal: V, newVal: V, key: K) => V, ...collections: Array<Collection<K, V> | {    [key: string]: V;}>) => this
 >merger : (oldVal: V, newVal: V, key: K) => V
 >oldVal : V
 >newVal : V
@@ -500,7 +500,7 @@ declare module Immutable {
 >collections : Iterable<[KC, VC]>[]

    concat<C>(...collections: Array<{[key: string]: C}>): Map<K | string, V | C>;
->concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): Map<K | KC, V | VC>; <C>(...collections: { [key: string]: C; }[]): Map<K | string, V | C>; }
+>concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): Map<K | KC, V | VC>; <C>(...collections: Array<{    [key: string]: C;}>): Map<K | string, V | C>; }
 >collections : { [key: string]: C; }[]
 >key : string

@@ -585,7 +585,7 @@ declare module Immutable {
 >collections : Iterable<[KC, VC]>[]

    concat<C>(...collections: Array<{[key: string]: C}>): OrderedMap<K | string, V | C>;
->concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): OrderedMap<K | KC, V | VC>; <C>(...collections: { [key: string]: C; }[]): OrderedMap<K | string, V | C>; }
+>concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): OrderedMap<K | KC, V | VC>; <C>(...collections: Array<{    [key: string]: C;}>): OrderedMap<K | string, V | C>; }
 >collections : { [key: string]: C; }[]
 >key : string

@@ -653,7 +653,7 @@ declare module Immutable {
 >iter : Collection<T, any>

    function fromKeys(obj: {[key: string]: any}): Set<string>;
->fromKeys : { <T>(iter: Collection<T, any>): Set<T>; (obj: { [key: string]: any; }): Set<string>; }
+>fromKeys : { <T>(iter: Collection<T, any>): Set<T>; (obj: {    [key: string]: any;}): Set<string>; }
 >obj : { [key: string]: any; }
 >key : string

@@ -775,7 +775,7 @@ declare module Immutable {
 >iter : Collection<T, any>

    function fromKeys(obj: {[key: string]: any}): OrderedSet<string>;
->fromKeys : { <T>(iter: Collection<T, any>): OrderedSet<T>; (obj: { [key: string]: any; }): OrderedSet<string>; }
+>fromKeys : { <T>(iter: Collection<T, any>): OrderedSet<T>; (obj: {    [key: string]: any;}): OrderedSet<string>; }
 >obj : { [key: string]: any; }
 >key : string
  }
@@ -1156,7 +1156,7 @@ declare module Immutable {
 >Seq : any

    export function Keyed<V>(obj: {[key: string]: V}): Seq.Keyed<string, V>;
->Keyed : { <K, V_1>(collection: Iterable<[K, V_1]>): Keyed<K, V_1>; <V>(obj: { [key: string]: V; }): Seq.Keyed<string, V>; <K_1, V_2>(): Keyed<K_1, V_2>; (): Keyed<any, any>; }
+>Keyed : { <K, V_1>(collection: Iterable<[K, V_1]>): Keyed<K, V_1>; <V>(obj: {    [key: string]: V;}): Seq.Keyed<string, V>; <K_1, V_2>(): Keyed<K_1, V_2>; (): Keyed<any, any>; }
 >obj : { [key: string]: V; }
 >key : string
 >Seq : any
@@ -1176,7 +1176,7 @@ declare module Immutable {
 >toJS : () => Object

      toJSON(): { [key: string]: V };
->toJSON : () => { [key: string]: V; }
+>toJSON : () => {    [key: string]: V;}
 >key : string

      toSeq(): this;
@@ -1188,7 +1188,7 @@ declare module Immutable {
 >Seq : any

      concat<C>(...collections: Array<{[key: string]: C}>): Seq.Keyed<K | string, V | C>;
->concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): Keyed<K | KC, V | VC>; <C>(...collections: { [key: string]: C; }[]): Seq.Keyed<K | string, V | C>; }
+>concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): Keyed<K | KC, V | VC>; <C>(...collections: Array<{    [key: string]: C;}>): Seq.Keyed<K | string, V | C>; }
 >collections : { [key: string]: C; }[]
 >key : string
 >Seq : any
@@ -1500,7 +1500,7 @@ declare module Immutable {
 >Collection : any

    export function Keyed<V>(obj: {[key: string]: V}): Collection.Keyed<string, V>;
->Keyed : { <K, V_1>(collection: Iterable<[K, V_1]>): Keyed<K, V_1>; <V>(obj: { [key: string]: V; }): Collection.Keyed<string, V>; }
+>Keyed : { <K, V_1>(collection: Iterable<[K, V_1]>): Keyed<K, V_1>; <V>(obj: {    [key: string]: V;}): Collection.Keyed<string, V>; }
 >obj : { [key: string]: V; }
 >key : string
 >Collection : any
@@ -1510,7 +1510,7 @@ declare module Immutable {
 >toJS : () => Object

      toJSON(): { [key: string]: V };
->toJSON : () => { [key: string]: V; }
+>toJSON : () => {    [key: string]: V;}
 >key : string

      toSeq(): Seq.Keyed<K, V>;
@@ -1527,7 +1527,7 @@ declare module Immutable {
 >Collection : any

      concat<C>(...collections: Array<{[key: string]: C}>): Collection.Keyed<K | string, V | C>;
->concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): Keyed<K | KC, V | VC>; <C>(...collections: { [key: string]: C; }[]): Collection.Keyed<K | string, V | C>; }
+>concat : { <KC, VC>(...collections: Iterable<[KC, VC]>[]): Keyed<K | KC, V | VC>; <C>(...collections: Array<{    [key: string]: C;}>): Collection.Keyed<K | string, V | C>; }
 >collections : { [key: string]: C; }[]
 >key : string
 >Collection : any
@@ -1875,18 +1875,18 @@ declare module Immutable {

    // Conversion to JavaScript types
    toJS(): Array<any> | { [key: string]: any };
->toJS : () => any[] | { [key: string]: any; }
+>toJS : () => Array<any> | {    [key: string]: any;}
 >key : string

    toJSON(): Array<V> | { [key: string]: V };
->toJSON : () => V[] | { [key: string]: V; }
+>toJSON : () => Array<V> | {    [key: string]: V;}
 >key : string

    toArray(): Array<V>;
 >toArray : () => Array<V>

    toObject(): { [key: string]: V };
->toObject : () => { [key: string]: V; }
+>toObject : () => {    [key: string]: V;}
 >key : string

    // Conversion to Collections
@@ -52,7 +52,7 @@ module m1 {
    }

    export function f3(): {
->f3 : () => (a: number) => C1
+>f3 : () => {    (a: number): C1;}

        (a: number) : C1;
 >a : number
@@ -74,7 +74,7 @@ module m1 {


    export function f5(arg2: {
->f5 : (arg2: new (arg1: C1) => C1) => void
+>f5 : (arg2: {    new (arg1: C1): C1;}) => void
 >arg2 : new (arg1: C1) => C1

        new (arg1: C1) : C1
@@ -2,7 +2,7 @@

 === computedPropertyNames48_ES5.ts ===
 declare function extractIndexer<T>(p: { [n: number]: T }): T;
->extractIndexer : <T>(p: { [n: number]: T; }) => T
+>extractIndexer : <T>(p: {    [n: number]: T;}) => T
 >p : { [n: number]: T; }
 >n : number

@@ -2,7 +2,7 @@

 === computedPropertyNames48_ES6.ts ===
 declare function extractIndexer<T>(p: { [n: number]: T }): T;
->extractIndexer : <T>(p: { [n: number]: T; }) => T
+>extractIndexer : <T>(p: {    [n: number]: T;}) => T
 >p : { [n: number]: T; }
 >n : number

@@ -6,7 +6,7 @@ declare function useState1<S>(initialState: (S extends (() => any) ? never : S)
 >initialState : (S extends () => any ? never : S) | (() => S)

 declare function useState2<S>(initialState: (S extends ((...args: any[]) => any) ? never : S) | (() => S)): S; // Any args
->useState2 : <S>(initialState: (S extends (...args: any[]) => any ? never : S) | (() => S)) => S
+>useState2 : <S>(initialState: (S extends ((...args: any[]) => any) ? never : S) | (() => S)) => S
 >initialState : (S extends (...args: any[]) => any ? never : S) | (() => S)
 >args : any[]

@@ -31,7 +31,7 @@ declare function useState3<S, T extends S>(initialState: (T extends (() => any)
 >initialState : (T extends () => any ? never : T) | (() => S)

 declare function useState4<S, T extends S>(initialState: (T extends ((...args: any[]) => any) ? never : T) | (() => S)): S; // Any args
->useState4 : <S, T extends S>(initialState: (T extends (...args: any[]) => any ? never : T) | (() => S)) => S
+>useState4 : <S, T extends S>(initialState: (T extends ((...args: any[]) => any) ? never : T) | (() => S)) => S
 >initialState : (T extends (...args: any[]) => any ? never : T) | (() => S)
 >args : any[]

@@ -3,7 +3,7 @@
 === constraintWithIndexedAccess.ts ===
 // #52399
 type DataFetchFns = {
->DataFetchFns : { Boat: { requiresLicense: (id: string) => boolean; maxGroundSpeed: (id: string) => number; description: (id: string) => string; displacement: (id: string) => number; name: (id: string) => string; }; Plane: { requiresLicense: (id: string) => boolean; maxGroundSpeed: (id: string) => number; maxTakeoffWeight: (id: string) => number; maxCruisingAltitude: (id: string) => number; name: (id: string) => string; }; }
+>DataFetchFns : { Boat: {    requiresLicense: (id: string) => boolean;    maxGroundSpeed: (id: string) => number;    description: (id: string) => string;    displacement: (id: string) => number;    name: (id: string) => string;}; Plane: {    requiresLicense: (id: string) => boolean;    maxGroundSpeed: (id: string) => number;    maxTakeoffWeight: (id: string) => number;    maxCruisingAltitude: (id: string) => number;    name: (id: string) => string;}; }

    Boat: {
 >Boat : { requiresLicense: (id: string) => boolean; maxGroundSpeed: (id: string) => number; description: (id: string) => string; displacement: (id: string) => number; name: (id: string) => string; }
@@ -134,7 +134,7 @@ interface A { // T

    };
    a18: {
->a18 : { new (x: { new (a: number): number; new (a: string): string; }): any[]; new (x: { new (a: boolean): boolean; new (a: Date): Date; }): any[]; }
+>a18 : { new (x: {    new (a: number): number;    new (a: string): string;}): any[]; new (x: {    new (a: boolean): boolean;    new (a: Date): Date;}): any[]; }

        new (x: {
 >x : { new (a: number): number; new (a: string): string; }
@@ -81,7 +81,7 @@ module Errors {
 >b : number

            a16: {
->a16 : { new (x: { new (a: number): number; new (a?: number): number; }): number[]; new (x: { new (a: boolean): boolean; new (a?: boolean): boolean; }): boolean[]; }
+>a16 : { new (x: {    new (a: number): number;    new (a?: number): number;}): number[]; new (x: {    new (a: boolean): boolean;    new (a?: boolean): boolean;}): boolean[]; }

                // type of parameter is overload set which means we can't do inference based on this type
                new (x: {
@@ -5,7 +5,7 @@ declare namespace app {
 >app : typeof app

  var foo: {
->foo : { bar: { someFun: (arg: number) => void; }; }
+>foo : { bar: {    someFun: (arg: number) => void;}; }

    bar: {
 >bar : { someFun: (arg: number) => void; }
@@ -4,7 +4,7 @@
 // See: https://github.com/microsoft/TypeScript/pull/53280#discussion_r1138684984

 declare function test(
->test : (arg: Record<string, (arg: string) => void> | ((arg: number) => void)[]) => void
+>test : (arg: Record<string, (arg: string) => void> | Array<(arg: number) => void>) => void

  arg: Record<string, (arg: string) => void> | Array<(arg: number) => void>
 >arg : Record<string, (arg: string) => void> | ((arg: number) => void)[]
@@ -4,7 +4,7 @@
 // See: https://github.com/microsoft/TypeScript/pull/53280#discussion_r1138684984

 declare function test(
->test : (arg: Record<string, (arg: string) => void> | ((arg: number) => void)[]) => void
+>test : (arg: Record<string, (arg: string) => void> | Array<(arg: number) => void>) => void

  arg: Record<string, (arg: string) => void> | Array<(arg: number) => void>
 >arg : Record<string, (arg: string) => void> | ((arg: number) => void)[]
@@ -5,7 +5,7 @@ type Keys = "a" | "b";
 >Keys : "a" | "b"

 type OptionsForKey = { a: { cb: (p: number) => number } } & { b: {} };
->OptionsForKey : { a: { cb: (p: number) => number; }; } & { b: {}; }
+>OptionsForKey : { a: {    cb: (p: number) => number;}; } & { b: {}; }
 >a : { cb: (p: number) => number; }
 >cb : (p: number) => number
 >p : number
@@ -2,7 +2,7 @@

 === contextualTypeOnYield1.ts ===
 type FuncOrGeneratorFunc = () => (number | Generator<(arg: number) => void, any, void>)
->FuncOrGeneratorFunc : () => number | Generator<(arg: number) => void, any, void>
+>FuncOrGeneratorFunc : () => (number | Generator<(arg: number) => void, any, void>)
 >arg : number

 const f: FuncOrGeneratorFunc = function*() {
@@ -2,7 +2,7 @@

 === contextualTypeOnYield2.ts ===
 type OrGen = () => (number | Generator<string, (arg: number) => void, undefined>);
->OrGen : () => number | Generator<string, (arg: number) => void, undefined>
+>OrGen : () => (number | Generator<string, (arg: number) => void, undefined>)
 >arg : number

 const g: OrGen = function* () {
@@ -327,7 +327,7 @@ interface IPlaceHolder {
    }

 var objc8: {
->objc8 : { t1: (s: string) => string; t2: IFoo; t3: number[]; t4: () => IFoo; t5: (n: number) => IFoo; t6: (n: number, s: string) => IFoo; t7: (n: number, s: string) => number; t8: (n: number, s: string) => number; t9: number[][]; t10: IFoo[]; t11: ((n: number, s: string) => string)[]; t12: IBar; t13: IFoo; t14: IFoo; }
+>objc8 : { t1: (s: string) => string; t2: IFoo; t3: number[]; t4: () => IFoo; t5: (n: number) => IFoo; t6: (n: number, s: string) => IFoo; t7: {    (n: number, s: string): number;}; t8: (n: number, s: string) => number; t9: number[][]; t10: IFoo[]; t11: {    (n: number, s: string): string;}[]; t12: IBar; t13: IFoo; t14: IFoo; }

    t1: (s: string) => string;
 >t1 : (s: string) => string
@@ -2,7 +2,7 @@

 === contextualTyping23.ts ===
 var foo:(a:{():number; (i:number):number; })=>number; foo = function(a){return 5};
->foo : (a: { (): number; (i: number): number; }) => number
+>foo : (a: {    (): number;    (i: number): number;}) => number
 >a : { (): number; (i: number): number; }
 >i : number
 >foo = function(a){return 5} : (a: { (): number; (i: number): number; }) => number
@@ -2,7 +2,7 @@

 === contextualTyping24.ts ===
 var foo:(a:{():number; (i:number):number; })=>number; foo = function(this: void, a:string){return 5};
->foo : (a: { (): number; (i: number): number; }) => number
+>foo : (a: {    (): number;    (i: number): number;}) => number
 >a : { (): number; (i: number): number; }
 >i : number
 >foo = function(this: void, a:string){return 5} : (this: void, a: string) => number
@@ -2,7 +2,7 @@

 === contextualTyping32.ts ===
 function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){return 1;}, function(){return 4}]);
->foo : (param: { (): number; (i: number): number; }[]) => void
+>foo : (param: {    (): number;    (i: number): number;}[]) => void
 >param : { (): number; (i: number): number; }[]
 >i : number
 >foo([function(){return 1;}, function(){return 4}]) : void
@@ -2,7 +2,7 @@

 === contextualTyping33.ts ===
 function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){return 1;}, function(){return "foo"}]);
->foo : (param: { (): number; (i: number): number; }[]) => void
+>foo : (param: {    (): number;    (i: number): number;}[]) => void
 >param : { (): number; (i: number): number; }[]
 >i : number
 >foo([function(){return 1;}, function(){return "foo"}]) : void
@@ -22,7 +22,7 @@ obj1 = obj2; // Error - indexer doesn't match
 >obj2 : { x: string; }

 function f(x: { [s: string]: string }) { }
->f : (x: { [s: string]: string; }) => void
+>f : (x: {    [s: string]: string;}) => void
 >x : { [s: string]: string; }
 >s : string

@@ -580,7 +580,7 @@ function f28(obj?: { kind: 'foo', foo: string } | { kind: 'bar', bar: number })
 // Narrowing by aliased discriminant property access

 function f30(obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
->f30 : (obj: { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; }) => void
+>f30 : (obj: {    kind: 'foo';    foo: string;} | {    kind: 'bar';    bar: number;}) => void
 >obj : { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; }
 >kind : "foo"
 >foo : string
@@ -612,7 +612,7 @@ function f30(obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
 }

 function f31(obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
->f31 : (obj: { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; }) => void
+>f31 : (obj: {    kind: 'foo';    foo: string;} | {    kind: 'bar';    bar: number;}) => void
 >obj : { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; }
 >kind : "foo"
 >foo : string
@@ -673,7 +673,7 @@ function f32(obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
 }

 function f33(obj: { kind: 'foo', foo: string } | { kind: 'bar', bar: number }) {
->f33 : (obj: { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; }) => void
+>f33 : (obj: {    kind: 'foo';    foo: string;} | {    kind: 'bar';    bar: number;}) => void
 >obj : { kind: 'foo'; foo: string; } | { kind: 'bar'; bar: number; }
 >kind : "foo"
 >foo : string
@@ -809,7 +809,7 @@ class C11 {
 // Mixing of aliased discriminants and conditionals

 function f40(obj: { kind: 'foo', foo?: string } | { kind: 'bar', bar?: number }) {
->f40 : (obj: { kind: 'foo'; foo?: string | undefined; } | { kind: 'bar'; bar?: number | undefined; }) => void
+>f40 : (obj: {    kind: 'foo';    foo?: string;} | {    kind: 'bar';    bar?: number;}) => void
 >obj : { kind: 'foo'; foo?: string | undefined; } | { kind: 'bar'; bar?: number | undefined; }
 >kind : "foo"
 >foo : string | undefined
@@ -8,7 +8,7 @@ declare function f2(): [b: string];
 >f2 : () => [b: string]

 declare function f3(): { c: string };
->f3 : () => { c: string; }
+>f3 : () => {    c: string;}
 >c : string

 try {
@@ -75,7 +75,7 @@ if (d in c) {
 // repro from https://github.com/microsoft/TypeScript/issues/54790

 function uniqueID_54790(
->uniqueID_54790 : (id: string | undefined, seenIDs: { [key: string]: string; }) => string
+>uniqueID_54790 : (id: string | undefined, seenIDs: {    [key: string]: string;}) => string

  id: string | undefined,
 >id : string
@@ -52,7 +52,7 @@ function test2(foo: Foo | undefined) {
 }

 function Test3({ foo }: { foo: Foo | undefined }) {
->Test3 : ({ foo }: { foo: Foo | undefined; }) => JSX.Element
+>Test3 : ({ foo }: {    foo: Foo | undefined;}) => JSX.Element
 >foo : Foo | undefined
 >foo : Foo | undefined

@@ -6,12 +6,12 @@ function f1(...args) { }
 >args : any[]

 function f2(x: (...args) => void) { }
->f2 : (x: (...args: any[]) => void) => void
+>f2 : (x: (...args) => void) => void
 >x : (...args: any[]) => void
 >args : any[]

 function f3(x: { (...args): void }) { }
->f3 : (x: (...args: any[]) => void) => void
+>f3 : (x: {    (...args): void;}) => void
 >x : (...args: any[]) => void
 >args : any[]

@@ -11,8 +11,8 @@
 // Broken inference cases.

 export const a1 = (isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN;
->a1 : (isNaN: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN : (isNaN: (number: number) => boolean) => (number: number) => boolean
+>a1 : (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN : (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -23,8 +23,8 @@ export const a1 = (isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => i
 >isNaN : (number: number) => boolean

 export const a2 = (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN;
->a2 : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>a2 : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -41,8 +41,8 @@ export const a2 = (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN
 >isNaN : (number: number) => boolean

 export const a3 = (isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar;
->a3 : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
->(isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>a3 : (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar : (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : number
 >bar : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
@@ -54,8 +54,8 @@ export const a3 = (isNaN: number, bar: typeof globalThis.isNaN): typeof globalTh
 >bar : (number: number) => boolean

 export const a4 = (isNaN: number): typeof globalThis.isNaN => globalThis.isNaN;
->a4 : (isNaN: number) => (number: number) => boolean
->(isNaN: number): typeof globalThis.isNaN => globalThis.isNaN : (isNaN: number) => (number: number) => boolean
+>a4 : (isNaN: number) => typeof globalThis.isNaN
+>(isNaN: number): typeof globalThis.isNaN => globalThis.isNaN : (isNaN: number) => typeof globalThis.isNaN
 >isNaN : number
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -65,12 +65,12 @@ export const a4 = (isNaN: number): typeof globalThis.isNaN => globalThis.isNaN;
 >isNaN : (number: number) => boolean

 export const aObj = {
->aObj : { a1: (isNaN: (number: number) => boolean) => (number: number) => boolean; a2: (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean; a3: (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean; a4: (isNaN: number) => (number: number) => boolean; }
->{    a1: (isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN,    a2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN,    a3: (isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar,    a4: (isNaN: number): typeof globalThis.isNaN => globalThis.isNaN,} : { a1: (isNaN: (number: number) => boolean) => (number: number) => boolean; a2: (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean; a3: (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean; a4: (isNaN: number) => (number: number) => boolean; }
+>aObj : { a1: (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN; a2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN; a3: (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN; a4: (isNaN: number) => typeof globalThis.isNaN; }
+>{    a1: (isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN,    a2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN,    a3: (isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar,    a4: (isNaN: number): typeof globalThis.isNaN => globalThis.isNaN,} : { a1: (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN; a2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN; a3: (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN; a4: (isNaN: number) => typeof globalThis.isNaN; }

    a1: (isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN,
->a1 : (isNaN: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN : (isNaN: (number: number) => boolean) => (number: number) => boolean
+>a1 : (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN : (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -81,8 +81,8 @@ export const aObj = {
 >isNaN : (number: number) => boolean

    a2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN,
->a2 : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>a2 : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -99,8 +99,8 @@ export const aObj = {
 >isNaN : (number: number) => boolean

    a3: (isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar,
->a3 : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
->(isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>a3 : (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar : (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : number
 >bar : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
@@ -112,8 +112,8 @@ export const aObj = {
 >bar : (number: number) => boolean

    a4: (isNaN: number): typeof globalThis.isNaN => globalThis.isNaN,
->a4 : (isNaN: number) => (number: number) => boolean
->(isNaN: number): typeof globalThis.isNaN => globalThis.isNaN : (isNaN: number) => (number: number) => boolean
+>a4 : (isNaN: number) => typeof globalThis.isNaN
+>(isNaN: number): typeof globalThis.isNaN => globalThis.isNaN : (isNaN: number) => typeof globalThis.isNaN
 >isNaN : number
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -132,8 +132,8 @@ export type a4oReturn = ReturnType<ReturnType<typeof aObj['a4']>>;
 >aObj : { a1: (isNaN: (number: number) => boolean) => (number: number) => boolean; a2: (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean; a3: (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean; a4: (isNaN: number) => (number: number) => boolean; }

 export const b1 = (isNaN: typeof globalThis.isNaN) => isNaN;
->b1 : (isNaN: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN) => isNaN : (isNaN: (number: number) => boolean) => (number: number) => boolean
+>b1 : (isNaN: typeof globalThis.isNaN) => (number: number) => boolean
+>(isNaN: typeof globalThis.isNaN) => isNaN : (isNaN: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -141,8 +141,8 @@ export const b1 = (isNaN: typeof globalThis.isNaN) => isNaN;
 >isNaN : (number: number) => boolean

 export const b2 = (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN;
->b2 : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>b2 : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean
+>(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -156,8 +156,8 @@ export const b2 = (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN
 >isNaN : (number: number) => boolean

 export const b3 = (isNaN: number, bar: typeof globalThis.isNaN) => bar;
->b3 : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
->(isNaN: number, bar: typeof globalThis.isNaN) => bar : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>b3 : (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean
+>(isNaN: number, bar: typeof globalThis.isNaN) => bar : (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : number
 >bar : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
@@ -174,12 +174,12 @@ export const b4 = (isNaN: number) => globalThis.isNaN;
 >isNaN : (number: number) => boolean

 export const bObj = {
->bObj : { b1: (isNaN: (number: number) => boolean) => (number: number) => boolean; b2: (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean; b3: (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean; b4: (isNaN: number) => (number: number) => boolean; }
->{    b1: (isNaN: typeof globalThis.isNaN) => isNaN,    b2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN,    b3: (isNaN: number, bar: typeof globalThis.isNaN) => bar,    b4: (isNaN: number) => globalThis.isNaN,} : { b1: (isNaN: (number: number) => boolean) => (number: number) => boolean; b2: (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean; b3: (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean; b4: (isNaN: number) => (number: number) => boolean; }
+>bObj : { b1: (isNaN: typeof globalThis.isNaN) => (number: number) => boolean; b2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean; b3: (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean; b4: (isNaN: number) => (number: number) => boolean; }
+>{    b1: (isNaN: typeof globalThis.isNaN) => isNaN,    b2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN,    b3: (isNaN: number, bar: typeof globalThis.isNaN) => bar,    b4: (isNaN: number) => globalThis.isNaN,} : { b1: (isNaN: typeof globalThis.isNaN) => (number: number) => boolean; b2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean; b3: (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean; b4: (isNaN: number) => (number: number) => boolean; }

    b1: (isNaN: typeof globalThis.isNaN) => isNaN,
->b1 : (isNaN: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN) => isNaN : (isNaN: (number: number) => boolean) => (number: number) => boolean
+>b1 : (isNaN: typeof globalThis.isNaN) => (number: number) => boolean
+>(isNaN: typeof globalThis.isNaN) => isNaN : (isNaN: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -187,8 +187,8 @@ export const bObj = {
 >isNaN : (number: number) => boolean

    b2: (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN,
->b2 : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>b2 : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean
+>(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => bar ?? isNaN : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -202,8 +202,8 @@ export const bObj = {
 >isNaN : (number: number) => boolean

    b3: (isNaN: number, bar: typeof globalThis.isNaN) => bar,
->b3 : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
->(isNaN: number, bar: typeof globalThis.isNaN) => bar : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>b3 : (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean
+>(isNaN: number, bar: typeof globalThis.isNaN) => bar : (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : number
 >bar : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
@@ -267,11 +267,11 @@ export function c4(isNaN: number) { return globalThis.isNaN; }
 >isNaN : (number: number) => boolean

 export const cObj = {
->cObj : { c1(isNaN: (number: number) => boolean): (number: number) => boolean; c2(isNaN: (number: number) => boolean, bar?: (number: number) => boolean): (number: number) => boolean; c3(isNaN: number, bar: (number: number) => boolean): (number: number) => boolean; c4(isNaN: number): (number: number) => boolean; }
->{    c1(isNaN: typeof globalThis.isNaN) { return isNaN },    c2(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) { return bar ?? isNaN },    c3(isNaN: number, bar: typeof globalThis.isNaN) { return bar },    c4(isNaN: number) { return globalThis.isNaN; },} : { c1(isNaN: (number: number) => boolean): (number: number) => boolean; c2(isNaN: (number: number) => boolean, bar?: (number: number) => boolean): (number: number) => boolean; c3(isNaN: number, bar: (number: number) => boolean): (number: number) => boolean; c4(isNaN: number): (number: number) => boolean; }
+>cObj : { c1(isNaN: typeof globalThis.isNaN): (number: number) => boolean; c2(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): (number: number) => boolean; c3(isNaN: number, bar: typeof globalThis.isNaN): (number: number) => boolean; c4(isNaN: number): (number: number) => boolean; }
+>{    c1(isNaN: typeof globalThis.isNaN) { return isNaN },    c2(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) { return bar ?? isNaN },    c3(isNaN: number, bar: typeof globalThis.isNaN) { return bar },    c4(isNaN: number) { return globalThis.isNaN; },} : { c1(isNaN: typeof globalThis.isNaN): (number: number) => boolean; c2(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): (number: number) => boolean; c3(isNaN: number, bar: typeof globalThis.isNaN): (number: number) => boolean; c4(isNaN: number): (number: number) => boolean; }

    c1(isNaN: typeof globalThis.isNaN) { return isNaN },
->c1 : (isNaN: (number: number) => boolean) => (number: number) => boolean
+>c1 : (isNaN: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -279,7 +279,7 @@ export const cObj = {
 >isNaN : (number: number) => boolean

    c2(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) { return bar ?? isNaN },
->c2 : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>c2 : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -293,7 +293,7 @@ export const cObj = {
 >isNaN : (number: number) => boolean

    c3(isNaN: number, bar: typeof globalThis.isNaN) { return bar },
->c3 : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>c3 : (isNaN: number, bar: typeof globalThis.isNaN) => (number: number) => boolean
 >isNaN : number
 >bar : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
@@ -318,11 +318,11 @@ export type c4oReturn = ReturnType<ReturnType<typeof cObj['c4']>>;
 >cObj : { c1(isNaN: (number: number) => boolean): (number: number) => boolean; c2(isNaN: (number: number) => boolean, bar?: (number: number) => boolean): (number: number) => boolean; c3(isNaN: number, bar: (number: number) => boolean): (number: number) => boolean; c4(isNaN: number): (number: number) => boolean; }

 export function d1() {
->d1 : () => () => (isNaN: (number: number) => boolean) => (number: number) => boolean
+>d1 : () => () => (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN

    const fn = (isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN;
->fn : (isNaN: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN : (isNaN: (number: number) => boolean) => (number: number) => boolean
+>fn : (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: typeof globalThis.isNaN): typeof globalThis.isNaN => isNaN : (isNaN: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -338,11 +338,11 @@ export function d1() {
 }

 export function d2() {
->d2 : () => () => (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>d2 : () => () => (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN

    const fn = (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN;
->fn : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
->(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN : (isNaN: (number: number) => boolean, bar?: (number: number) => boolean) => (number: number) => boolean
+>fn : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN): typeof globalThis.isNaN => bar ?? isNaN : (isNaN: typeof globalThis.isNaN, bar?: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -364,11 +364,11 @@ export function d2() {
 }

 export function d3() {
->d3 : () => () => (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>d3 : () => () => (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN

    const fn = (isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar;
->fn : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
->(isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar : (isNaN: number, bar: (number: number) => boolean) => (number: number) => boolean
+>fn : (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN
+>(isNaN: number, bar: typeof globalThis.isNaN): typeof globalThis.isNaN => bar : (isNaN: number, bar: typeof globalThis.isNaN) => typeof globalThis.isNaN
 >isNaN : number
 >bar : (number: number) => boolean
 >globalThis.isNaN : (number: number) => boolean
@@ -385,11 +385,11 @@ export function d3() {
 }

 export function d4() {
->d4 : () => () => (isNaN: number) => (number: number) => boolean
+>d4 : () => () => (isNaN: number) => typeof globalThis.isNaN

    const fn = (isNaN: number): typeof globalThis.isNaN => globalThis.isNaN;
->fn : (isNaN: number) => (number: number) => boolean
->(isNaN: number): typeof globalThis.isNaN => globalThis.isNaN : (isNaN: number) => (number: number) => boolean
+>fn : (isNaN: number) => typeof globalThis.isNaN
+>(isNaN: number): typeof globalThis.isNaN => globalThis.isNaN : (isNaN: number) => typeof globalThis.isNaN
 >isNaN : number
 >globalThis.isNaN : (number: number) => boolean
 >globalThis : typeof globalThis
@@ -0,0 +1,23 @@
+//// [tests/cases/compiler/declarationEmitRetainedAnnotationRetainsImportInOutput.ts] ////
+
+//// [index.d.ts]
+export type Whatever<T> = {x: T};
+export declare function something<T>(cb: () => Whatever<T>): Whatever<T>;
+
+//// [index.ts]
+import * as E from 'whatever';
+
+export const run = <E>(i: () => E.Whatever<E>): E.Whatever<E> => E.something(i);
+
+//// [index.js]
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var E = require("whatever");
+var run = function (i) { return E.something(i); };
+exports.run = run;
+
+
+//// [index.d.ts]
+import * as E from 'whatever';
+export declare const run: <E>(i: () => E.Whatever<E>) => E.Whatever<E>;
@@ -0,0 +1,37 @@
+//// [tests/cases/compiler/declarationEmitRetainedAnnotationRetainsImportInOutput.ts] ////
+
+=== node_modules/whatever/index.d.ts ===
+export type Whatever<T> = {x: T};
+>Whatever : Symbol(Whatever, Decl(index.d.ts, 0, 0))
+>T : Symbol(T, Decl(index.d.ts, 0, 21))
+>x : Symbol(x, Decl(index.d.ts, 0, 27))
+>T : Symbol(T, Decl(index.d.ts, 0, 21))
+
+export declare function something<T>(cb: () => Whatever<T>): Whatever<T>;
+>something : Symbol(something, Decl(index.d.ts, 0, 33))
+>T : Symbol(T, Decl(index.d.ts, 1, 34))
+>cb : Symbol(cb, Decl(index.d.ts, 1, 37))
+>Whatever : Symbol(Whatever, Decl(index.d.ts, 0, 0))
+>T : Symbol(T, Decl(index.d.ts, 1, 34))
+>Whatever : Symbol(Whatever, Decl(index.d.ts, 0, 0))
+>T : Symbol(T, Decl(index.d.ts, 1, 34))
+
+=== index.ts ===
+import * as E from 'whatever';
+>E : Symbol(E, Decl(index.ts, 0, 6))
+
+export const run = <E>(i: () => E.Whatever<E>): E.Whatever<E> => E.something(i);
+>run : Symbol(run, Decl(index.ts, 2, 12))
+>E : Symbol(E, Decl(index.ts, 2, 20))
+>i : Symbol(i, Decl(index.ts, 2, 23))
+>E : Symbol(E, Decl(index.ts, 0, 6))
+>Whatever : Symbol(E.Whatever, Decl(index.d.ts, 0, 0))
+>E : Symbol(E, Decl(index.ts, 2, 20))
+>E : Symbol(E, Decl(index.ts, 0, 6))
+>Whatever : Symbol(E.Whatever, Decl(index.d.ts, 0, 0))
+>E : Symbol(E, Decl(index.ts, 2, 20))
+>E.something : Symbol(E.something, Decl(index.d.ts, 0, 33))
+>E : Symbol(E, Decl(index.ts, 0, 6))
+>something : Symbol(E.something, Decl(index.d.ts, 0, 33))
+>i : Symbol(i, Decl(index.ts, 2, 23))
+
@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/declarationEmitRetainedAnnotationRetainsImportInOutput.ts] ////
+
+=== node_modules/whatever/index.d.ts ===
+export type Whatever<T> = {x: T};
+>Whatever : Whatever<T>
+>x : T
+
+export declare function something<T>(cb: () => Whatever<T>): Whatever<T>;
+>something : <T>(cb: () => Whatever<T>) => Whatever<T>
+>cb : () => Whatever<T>
+
+=== index.ts ===
+import * as E from 'whatever';
+>E : typeof E
+
+export const run = <E>(i: () => E.Whatever<E>): E.Whatever<E> => E.something(i);
+>run : <E>(i: () => E.Whatever<E>) => E.Whatever<E>
+><E>(i: () => E.Whatever<E>): E.Whatever<E> => E.something(i) : <E>(i: () => E.Whatever<E>) => E.Whatever<E>
+>i : () => E.Whatever<E>
+>E : any
+>E : any
+>E.something(i) : E.Whatever<E>
+>E.something : <T>(cb: () => E.Whatever<T>) => E.Whatever<T>
+>E : typeof E
+>something : <T>(cb: () => E.Whatever<T>) => E.Whatever<T>
+>i : () => E.Whatever<E>
+
@@ -2,7 +2,7 @@

 === defaultValueInFunctionTypes.ts ===
 type Foo = ({ first = 0 }: { first?: number }) => unknown;
->Foo : ({ first }: { first?: number; }) => unknown
+>Foo : ({ first }: {    first?: number;}) => unknown
 >first : number
 >0 : 0
 >first : number
@@ -743,10 +743,10 @@ reducer("concat", { firstArr: [1, 2], secondArr: [3, 4] });
 // repro from https://github.com/microsoft/TypeScript/pull/47190#issuecomment-1057603588

 type FooMethod = {
->FooMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): void; }
+>FooMethod : { method(...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]): void; }

  method(...args:
->method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => void
+>method : (...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]) => void
 >args : [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]

    [type: "str", cb: (e: string) => void] |
@@ -787,10 +787,10 @@ let fooM: FooMethod = {
 };

 type FooAsyncMethod = {
->FooAsyncMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): Promise<any>; }
+>FooAsyncMethod : { method(...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]): Promise<any>; }

  method(...args:
->method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => Promise<any>
+>method : (...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]) => Promise<any>
 >args : [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]

    [type: "str", cb: (e: string) => void] |
@@ -831,10 +831,10 @@ let fooAsyncM: FooAsyncMethod = {
 };

 type FooGenMethod = {
->FooGenMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): Generator<any, any, any>; }
+>FooGenMethod : { method(...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]): Generator<any, any, any>; }

  method(...args:
->method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => Generator<any, any, any>
+>method : (...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]) => Generator<any, any, any>
 >args : [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]

    [type: "str", cb: (e: string) => void] |
@@ -875,10 +875,10 @@ let fooGenM: FooGenMethod = {
 };

 type FooAsyncGenMethod = {
->FooAsyncGenMethod : { method(...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]): AsyncGenerator<any, any, any>; }
+>FooAsyncGenMethod : { method(...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]): AsyncGenerator<any, any, any>; }

  method(...args:
->method : (...args: [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]) => AsyncGenerator<any, any, any>
+>method : (...args: [    type: "str",    cb: (e: string) => void] | [    type: "num",    cb: (e: number) => void]) => AsyncGenerator<any, any, any>
 >args : [type: "str", cb: (e: string) => void] | [type: "num", cb: (e: number) => void]

    [type: "str", cb: (e: string) => void] |
@@ -21,7 +21,7 @@ let x = 0;
 // Repro from #26235

 function f1(options?: { color?: string, width?: number }) {
->f1 : (options?: { color?: string | undefined; width?: number | undefined; } | undefined) => void
+>f1 : (options?: {    color?: string;    width?: number;}) => void
 >options : { color?: string | undefined; width?: number | undefined; } | undefined
 >color : string | undefined
 >width : number | undefined
@@ -93,7 +93,7 @@ function f2(options?: [string?, number?]) {
 }

 function f3(options?: { color: string, width: number }) {
->f3 : (options?: { color: string; width: number; } | undefined) => void
+>f3 : (options?: {    color: string;    width: number;}) => void
 >options : { color: string; width: number; } | undefined
 >color : string
 >width : number
@@ -27,7 +27,7 @@ interface ExecutionContext {
 }

 type CoercedVariableValues =
->CoercedVariableValues : { errors: ReadonlyArray<GraphQLError>; coerced?: undefined; } | { coerced: { [variable: string]: unknown; }; errors?: undefined; }
+>CoercedVariableValues : { errors: ReadonlyArray<GraphQLError>; coerced?: undefined; } | { coerced: {    [variable: string]: unknown;}; errors?: undefined; }

  | { errors: ReadonlyArray<GraphQLError>; coerced?: never }
 >errors : readonly GraphQLError[]
@@ -39,7 +39,7 @@ type CoercedVariableValues =
 >errors : undefined

 declare function getVariableValues(inputs: {
->getVariableValues : (inputs: { readonly [variable: string]: unknown; }) => CoercedVariableValues
+>getVariableValues : (inputs: {    readonly [variable: string]: unknown;}) => CoercedVariableValues
 >inputs : { readonly [variable: string]: unknown; }

  readonly [variable: string]: unknown;
@@ -27,7 +27,7 @@ interface ExecutionContext {
 }

 type CoercedVariableValues =
->CoercedVariableValues : { errors: ReadonlyArray<GraphQLError>; coerced?: never; } | { coerced: { [variable: string]: unknown; }; errors?: never; }
+>CoercedVariableValues : { errors: ReadonlyArray<GraphQLError>; coerced?: never; } | { coerced: {    [variable: string]: unknown;}; errors?: never; }

  | { errors: ReadonlyArray<GraphQLError>; coerced?: never }
 >errors : readonly GraphQLError[]
@@ -39,7 +39,7 @@ type CoercedVariableValues =
 >errors : undefined

 declare function getVariableValues(inputs: {
->getVariableValues : (inputs: { readonly [variable: string]: unknown; }) => CoercedVariableValues
+>getVariableValues : (inputs: {    readonly [variable: string]: unknown;}) => CoercedVariableValues
 >inputs : { readonly [variable: string]: unknown; }

  readonly [variable: string]: unknown;
@@ -4,7 +4,7 @@
 // repro from https://github.com/microsoft/TypeScript/issues/56341

 function bar(props: { x?: string; y?: string }) {
->bar : (props: { x?: string | undefined; y?: string | undefined; }) => { [x: string]: number; }
+>bar : (props: {    x?: string;    y?: string;}) => { [x: string]: number; }
 >props : { x?: string | undefined; y?: string | undefined; }
 >x : string | undefined
 >y : string | undefined
@@ -2,7 +2,7 @@

 === emitRestParametersFunctionProperty.ts ===
 var obj: {
->obj : { func1: (...rest: any[]) => void; }
+>obj : { func1: (...rest) => void; }

    func1: (...rest) => void
 >func1 : (...rest: any[]) => void
@@ -2,7 +2,7 @@

 === emitRestParametersFunctionPropertyES6.ts ===
 var obj: {
->obj : { func1: (...rest: any[]) => void; }
+>obj : { func1: (...rest) => void; }

    func1: (...rest) => void
 >func1 : (...rest: any[]) => void
@@ -207,7 +207,7 @@ var r4 = foo10(E.A);
 >A : E

 declare function foo11(x: (x) => number): (x) => number;
->foo11 : { (x: (x: any) => number): (x: any) => number; (x: E): E; }
+>foo11 : { (x: (x) => number): (x) => number; (x: E): E; }
 >x : (x: any) => number
 >x : any
 >x : any
@@ -35,14 +35,14 @@ export { C };
 >C : typeof C

 function boundMethodLogger<This, Args extends any[], Return>(source: string, bound = true) {
->boundMethodLogger : <This, Args extends any[], Return>(source: string, bound?: boolean) => (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return
+>boundMethodLogger : <This, Args extends any[], Return>(source: string, bound?: boolean) => (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => ((this: This, ...args: Args) => Return)
 >source : string
 >bound : boolean
 >true : true

    return function loggedDecorator(
->function loggedDecorator(        target: (this: This, ...args: Args) => Return,        context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>    ): ((this: This, ...args: Args) => Return) {        if (bound) {            context.addInitializer(function () {                (this as any)[context.name] = (this as any)[context.name].bind(this);            });        }        return function (this, ...args) {            console.log(`<${source}>: I'm logging stuff from ${context.name.toString()}!`);            return target.apply(this, args);        }    } : (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return
->loggedDecorator : (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => (this: This, ...args: Args) => Return
+>function loggedDecorator(        target: (this: This, ...args: Args) => Return,        context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>    ): ((this: This, ...args: Args) => Return) {        if (bound) {            context.addInitializer(function () {                (this as any)[context.name] = (this as any)[context.name].bind(this);            });        }        return function (this, ...args) {            console.log(`<${source}>: I'm logging stuff from ${context.name.toString()}!`);            return target.apply(this, args);        }    } : (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => ((this: This, ...args: Args) => Return)
+>loggedDecorator : (target: (this: This, ...args: Args) => Return, context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>) => ((this: This, ...args: Args) => Return)

        target: (this: This, ...args: Args) => Return,
 >target : (this: This, ...args: Args) => Return
@@ -3,8 +3,8 @@
 === esNextWeakRefs_IterableWeakMap.ts ===
 /** `static #cleanup` */
 const IterableWeakMap_cleanup = ({ ref, set }: {
->IterableWeakMap_cleanup : ({ ref, set }: { readonly ref: WeakRef<object>; readonly set: Set<WeakRef<object>>; }) => void
->({ ref, set }: {    readonly ref: WeakRef<object>;    readonly set: Set<WeakRef<object>>;}) => {    set.delete(ref);} : ({ ref, set }: { readonly ref: WeakRef<object>; readonly set: Set<WeakRef<object>>; }) => void
+>IterableWeakMap_cleanup : ({ ref, set }: {    readonly ref: WeakRef<object>;    readonly set: Set<WeakRef<object>>;}) => void
+>({ ref, set }: {    readonly ref: WeakRef<object>;    readonly set: Set<WeakRef<object>>;}) => {    set.delete(ref);} : ({ ref, set }: {    readonly ref: WeakRef<object>;    readonly set: Set<WeakRef<object>>;}) => void
 >ref : WeakRef<object>
 >set : Set<WeakRef<object>>

@@ -6,8 +6,8 @@ type Foo<K> = K extends unknown ? { a: number } : unknown
 >a : number

 const createDefaultExample = <K,>(x: K): Foo<K> & { x: K; } => {
->createDefaultExample : <K>(x: K) => Foo<K> & { x: K; }
-><K,>(x: K): Foo<K> & { x: K; } => {  return { a: 1, x: x }; // okay in TS 4.7.4, error in TS 4.8.2} : <K>(x: K) => Foo<K> & { x: K; }
+>createDefaultExample : <K>(x: K) => Foo<K> & {    x: K;}
+><K,>(x: K): Foo<K> & { x: K; } => {  return { a: 1, x: x }; // okay in TS 4.7.4, error in TS 4.8.2} : <K>(x: K) => Foo<K> & {    x: K;}
 >x : K
 >x : K

@@ -2,7 +2,7 @@

 === forInStrictNullChecksNoError.ts ===
 function f(x: { [key: string]: number; } | null | undefined) {
->f : (x: { [key: string]: number; } | null | undefined) => void
+>f : (x: {    [key: string]: number;} | null | undefined) => void
 >x : { [key: string]: number; } | null | undefined
 >key : string

@@ -2,7 +2,7 @@

 === functionDeclarationWithArgumentOfTypeFunctionTypeArray.ts ===
 function foo(args: { (x): number }[]) {
->foo : (args: ((x: any) => number)[]) => number
+>foo : (args: {    (x): number;}[]) => number
 >args : ((x: any) => number)[]
 >x : any

@@ -4,7 +4,7 @@
 // PropName<TypeParamList>(ParamList):ReturnType is equivalent to PropName: { <TypeParamList>(ParamList): ReturnType }

 var b: {
->b : { func1(x: number): number; func2: (x: number) => number; func3: (x: number) => number; }
+>b : { func1(x: number): number; func2: (x: number) => number; func3: {    (x: number): number;}; }

    func1(x: number): number;         // Method signature
 >func1 : (x: number) => number
@@ -75,7 +75,7 @@ b.func3 = b.func2;
 >func2 : (x: number) => number

 var c: {
->c : { func4(x: number): number; func4(s: string): string; func5: { (x: number): number; (s: string): string; }; }
+>c : { func4(x: number): number; func4(s: string): string; func5: {    (x: number): number;    (s: string): string;}; }

    func4(x: number): number;
 >func4 : { (x: number): number; (s: string): string; }
@@ -1093,7 +1093,7 @@ function x128(parm: Array<Base> = [d1, d2]) { }
 >d2 : Derived2

 function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
->x129 : (parm?: { [n: number]: Base; }) => void
+>x129 : (parm?: {    [n: number]: Base;}) => void
 >parm : { [n: number]: Base; }
 >n : number
 >[d1, d2] : (Derived1 | Derived2)[]
@@ -1186,7 +1186,7 @@ function x140(): Array<Base> { return [d1, d2]; }
 >d2 : Derived2

 function x141(): { [n: number]: Base; } { return [d1, d2]; }
->x141 : () => { [n: number]: Base; }
+>x141 : () => {    [n: number]: Base;}
 >n : number
 >[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
@@ -1307,7 +1307,7 @@ function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
 >d2 : Derived2

 function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
->x153 : () => { [n: number]: Base; }
+>x153 : () => {    [n: number]: Base;}
 >n : number
 >[d1, d2] : (Derived1 | Derived2)[]
 >d1 : Derived1
@@ -1422,7 +1422,7 @@ var x164: () => Array<Base> = () => { return [d1, d2]; };
 >d2 : Derived2

 var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
->x165 : () => { [n: number]: Base; }
+>x165 : () => {    [n: number]: Base;}
 >n : number
 >() => { return [d1, d2]; } : () => (Derived1 | Derived2)[]
 >[d1, d2] : (Derived1 | Derived2)[]
@@ -1523,7 +1523,7 @@ var x176: () => Array<Base> = function() { return [d1, d2]; };
 >d2 : Derived2

 var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
->x177 : () => { [n: number]: Base; }
+>x177 : () => {    [n: number]: Base;}
 >n : number
 >function() { return [d1, d2]; } : () => (Derived1 | Derived2)[]
 >[d1, d2] : (Derived1 | Derived2)[]
@@ -2122,7 +2122,7 @@ var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >d2 : Derived2

 var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
->x245 : { n: { [n: number]: Base; }; }
+>x245 : { n: {    [n: number]: Base;}; }
 >n : { [n: number]: Base; }
 >n : number
 >{ n: [d1, d2] } : { n: (Derived1 | Derived2)[]; }
@@ -2974,7 +2974,7 @@ function x328(n: Array<Base>) { }; x328([d1, d2]);
 >d2 : Derived2

 function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
->x329 : (n: { [n: number]: Base; }) => void
+>x329 : (n: {    [n: number]: Base;}) => void
 >n : { [n: number]: Base; }
 >n : number
 >x329([d1, d2]) : void
@@ -3115,8 +3115,8 @@ var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >d2 : Derived2

 var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
->x341 : (n: { [n: number]: Base; }) => { [n: number]: Base; }
->(n: { [n: number]: Base; }) => n : (n: { [n: number]: Base; }) => { [n: number]: Base; }
+>x341 : (n: {    [n: number]: Base;}) => { [n: number]: Base; }
+>(n: { [n: number]: Base; }) => n : (n: {    [n: number]: Base;}) => { [n: number]: Base; }
 >n : { [n: number]: Base; }
 >n : number
 >n : { [n: number]: Base; }
@@ -3127,8 +3127,8 @@ var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 >d2 : Derived2

 var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
->x342 : (n: { n: Base[]; }) => { n: Base[]; }
->(n: {n: Base[]; } ) => n : (n: { n: Base[]; }) => { n: Base[]; }
+>x342 : (n: {    n: Base[];}) => { n: Base[]; }
+>(n: {n: Base[]; } ) => n : (n: {    n: Base[];}) => { n: Base[]; }
 >n : { n: Base[]; }
 >n : Base[]
 >n : { n: Base[]; }
@@ -3256,8 +3256,8 @@ var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >d2 : Derived2

 var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
->x353 : (n: { [n: number]: Base; }) => void
->function(n: { [n: number]: Base; }) { } : (n: { [n: number]: Base; }) => void
+>x353 : (n: {    [n: number]: Base;}) => void
+>function(n: { [n: number]: Base; }) { } : (n: {    [n: number]: Base;}) => void
 >n : { [n: number]: Base; }
 >n : number
 >x353([d1, d2]) : void
@@ -3267,8 +3267,8 @@ var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 >d2 : Derived2

 var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
->x354 : (n: { n: Base[]; }) => void
->function(n: {n: Base[]; } ) { } : (n: { n: Base[]; }) => void
+>x354 : (n: {    n: Base[];}) => void
+>function(n: {n: Base[]; } ) { } : (n: {    n: Base[];}) => void
 >n : { n: Base[]; }
 >n : Base[]
 >x354({ n: [d1, d2] }) : void
@@ -2,7 +2,7 @@

 === generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
->g2 : () => Iterator<Iterable<(x: string) => number>, any, undefined>
+>g2 : () => Iterator<Iterable<(x: string) => number>>
 >x : string

    yield function* () {
@@ -2,7 +2,7 @@

 === generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
->g2 : () => Iterator<Iterable<(x: string) => number>, any, undefined>
+>g2 : () => Iterator<Iterable<(x: string) => number>>
 >x : string

    yield function* () {
@@ -2,7 +2,7 @@

 === generatorTypeCheck31.ts ===
 function* g2(): Iterator<() => Iterable<(x: string) => number>> {
->g2 : () => Iterator<() => Iterable<(x: string) => number>, any, undefined>
+>g2 : () => Iterator<() => Iterable<(x: string) => number>>
 >x : string

    yield function* () {
@@ -2,9 +2,9 @@

 === generatorTypeCheck45.ts ===
 declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T): T;
->foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U, any, undefined>, fun2: (y: U) => T) => T
+>foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T) => T
 >x : T
->fun : () => Iterator<(x: T) => U, any, undefined>
+>fun : () => Iterator<(x: T) => U>
 >x : T
 >fun2 : (y: U) => T
 >y : U
@@ -4,7 +4,7 @@
 // Generic call with parameter of object type with member of function type of n args passed object whose associated member is call signature with n+1 args

 function foo<T, U>(arg: { cb: new(t: T) => U }) {
->foo : <T, U>(arg: { cb: new (t: T) => U; }) => U
+>foo : <T, U>(arg: {    cb: new (t: T) => U;}) => U
 >arg : { cb: new (t: T) => U; }
 >cb : new (t: T) => U
 >t : T
@@ -53,7 +53,7 @@ var r3 = foo(arg3); // error
 >arg3 : { cb: new (x: string, y: number) => string; }

 function foo2<T, U>(arg: { cb: new(t: T, t2: T) => U }) {
->foo2 : <T, U>(arg: { cb: new (t: T, t2: T) => U; }) => U
+>foo2 : <T, U>(arg: {    cb: new (t: T, t2: T) => U;}) => U
 >arg : { cb: new (t: T, t2: T) => U; }
 >cb : new (t: T, t2: T) => U
 >t : T
@@ -4,7 +4,7 @@
 // Generic call with parameter of object type with member of function type of n args passed object whose associated member is call signature with n+1 args

 function foo<T, U>(arg: { cb: (t: T) => U }) {
->foo : <T, U>(arg: { cb: (t: T) => U; }) => U
+>foo : <T, U>(arg: {    cb: (t: T) => U;}) => U
 >arg : { cb: (t: T) => U; }
 >cb : (t: T) => U
 >t : T
@@ -54,7 +54,7 @@ var r3 = foo({ cb: (x: string, y: number) => '' }); // error
 >'' : ""

 function foo2<T, U>(arg: { cb: (t: T, t2: T) => U }) {
->foo2 : <T, U>(arg: { cb: (t: T, t2: T) => U; }) => U
+>foo2 : <T, U>(arg: {    cb: (t: T, t2: T) => U;}) => U
 >arg : { cb: (t: T, t2: T) => U; }
 >cb : (t: T, t2: T) => U
 >t : T
@@ -48,7 +48,7 @@ module GenericParameter {
 >GenericParameter : typeof GenericParameter

    function foo5<T>(cb: { new(x: T): string; new(x: number): T }) {
->foo5 : <T>(cb: { new (x: T): string; new (x: number): T; }) => { new (x: T): string; new (x: number): T; }
+>foo5 : <T>(cb: {    new (x: T): string;    new (x: number): T;}) => { new (x: T): string; new (x: number): T; }
 >cb : { new (x: T): string; new (x: number): T; }
 >x : T
 >x : number
@@ -84,7 +84,7 @@ module GenericParameter {
 >b : { new <T>(x: T): string; new <T_1>(x: number): T_1; }

    function foo6<T>(cb: { new(x: T): string; new(x: T, y?: T): string }) {
->foo6 : <T>(cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
+>foo6 : <T>(cb: {    new (x: T): string;    new (x: T, y?: T): string;}) => { new (x: T): string; new (x: T, y?: T): string; }
 >cb : { new (x: T): string; new (x: T, y?: T): string; }
 >x : T
 >x : T
@@ -107,7 +107,7 @@ module GenericParameter {
 >b : { new <T>(x: T): string; new <T_1>(x: number): T_1; }

    function foo7<T>(x:T, cb: { new(x: T): string; new(x: T, y?: T): string }) {
->foo7 : <T>(x: T, cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
+>foo7 : <T>(x: T, cb: {    new (x: T): string;    new (x: T, y?: T): string;}) => { new (x: T): string; new (x: T, y?: T): string; }
 >x : T
 >cb : { new (x: T): string; new (x: T, y?: T): string; }
 >x : T
@@ -41,7 +41,7 @@ module GenericParameter {
 >GenericParameter : typeof GenericParameter

    function foo5<T>(cb: { new(x: T): string; new(x: number): T }) {
->foo5 : <T>(cb: { new (x: T): string; new (x: number): T; }) => { new (x: T): string; new (x: number): T; }
+>foo5 : <T>(cb: {    new (x: T): string;    new (x: number): T;}) => { new (x: T): string; new (x: number): T; }
 >cb : { new (x: T): string; new (x: number): T; }
 >x : T
 >x : number
@@ -61,7 +61,7 @@ module GenericParameter {
 >a : new <T>(x: T) => T

    function foo6<T>(cb: { new(x: T): string; new(x: T, y?: T): string }) {
->foo6 : <T>(cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
+>foo6 : <T>(cb: {    new (x: T): string;    new (x: T, y?: T): string;}) => { new (x: T): string; new (x: T, y?: T): string; }
 >cb : { new (x: T): string; new (x: T, y?: T): string; }
 >x : T
 >x : T
@@ -83,7 +83,7 @@ module GenericParameter {
 >b : new <T>(x: T, y: T) => string

    function foo7<T>(x:T, cb: { new(x: T): string; new(x: T, y?: T): string }) {
->foo7 : <T>(x: T, cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
+>foo7 : <T>(x: T, cb: {    new (x: T): string;    new (x: T, y?: T): string;}) => { new (x: T): string; new (x: T, y?: T): string; }
 >x : T
 >cb : { new (x: T): string; new (x: T, y?: T): string; }
 >x : T
@@ -53,7 +53,7 @@ module GenericParameter {
 >GenericParameter : typeof GenericParameter

    function foo5<T>(cb: { (x: T): string; (x: number): T }) {
->foo5 : <T>(cb: { (x: T): string; (x: number): T; }) => { (x: T): string; (x: number): T; }
+>foo5 : <T>(cb: {    (x: T): string;    (x: number): T;}) => { (x: T): string; (x: number): T; }
 >cb : { (x: T): string; (x: number): T; }
 >x : T
 >x : number
@@ -82,7 +82,7 @@ module GenericParameter {
 >a : { <T>(x: T): string; <T_1>(x: number): T_1; }

    function foo6<T>(cb: { (x: T): string; (x: T, y?: T): string }) {
->foo6 : <T>(cb: { (x: T): string; (x: T, y?: T): string; }) => { (x: T): string; (x: T, y?: T): string; }
+>foo6 : <T>(cb: {    (x: T): string;    (x: T, y?: T): string;}) => { (x: T): string; (x: T, y?: T): string; }
 >cb : { (x: T): string; (x: T, y?: T): string; }
 >x : T
 >x : T
@@ -118,7 +118,7 @@ module GenericParameter {
 >'' : ""

    function foo7<T>(x:T, cb: { (x: T): string; (x: T, y?: T): string }) {
->foo7 : <T>(x: T, cb: { (x: T): string; (x: T, y?: T): string; }) => { (x: T): string; (x: T, y?: T): string; }
+>foo7 : <T>(x: T, cb: {    (x: T): string;    (x: T, y?: T): string;}) => { (x: T): string; (x: T, y?: T): string; }
 >x : T
 >cb : { (x: T): string; (x: T, y?: T): string; }
 >x : T
@@ -40,7 +40,7 @@ module GenericParameter {
 >GenericParameter : typeof GenericParameter

    function foo5<T>(cb: { (x: T): string; (x: number): T }) {
->foo5 : <T>(cb: { (x: T): string; (x: number): T; }) => { (x: T): string; (x: number): T; }
+>foo5 : <T>(cb: {    (x: T): string;    (x: number): T;}) => { (x: T): string; (x: number): T; }
 >cb : { (x: T): string; (x: number): T; }
 >x : T
 >x : number
@@ -58,7 +58,7 @@ module GenericParameter {
 >x : T

    function foo6<T>(cb: { (x: T): string; (x: T, y?: T): string }) {
->foo6 : <T>(cb: { (x: T): string; (x: T, y?: T): string; }) => { (x: T): string; (x: T, y?: T): string; }
+>foo6 : <T>(cb: {    (x: T): string;    (x: T, y?: T): string;}) => { (x: T): string; (x: T, y?: T): string; }
 >cb : { (x: T): string; (x: T, y?: T): string; }
 >x : T
 >x : T
@@ -78,7 +78,7 @@ module GenericParameter {
 >'' : ""

    function foo7<T>(x:T, cb: { (x: T): string; (x: T, y?: T): string }) {
->foo7 : <T>(x: T, cb: { (x: T): string; (x: T, y?: T): string; }) => { (x: T): string; (x: T, y?: T): string; }
+>foo7 : <T>(x: T, cb: {    (x: T): string;    (x: T, y?: T): string;}) => { (x: T): string; (x: T, y?: T): string; }
 >x : T
 >cb : { (x: T): string; (x: T, y?: T): string; }
 >x : T
@@ -411,7 +411,7 @@ const f41 = pipe4([box, list]);
 >list : <T>(a: T) => T[]

 declare function pipe5<A, B>(f: (a: A) => B): { f: (a: A) => B };
->pipe5 : <A, B>(f: (a: A) => B) => { f: (a: A) => B; }
+>pipe5 : <A, B>(f: (a: A) => B) => {    f: (a: A) => B;}
 >f : (a: A) => B
 >a : A
 >f : (a: A) => B
@@ -16,7 +16,7 @@ interface bar<T> {
 >arg : T

    fail2(func2: { (arg: T): void; }): void;
->fail2 : (func2: (arg: T) => void) => void
+>fail2 : (func2: {    (arg: T): void;}) => void
 >func2 : (arg: T) => void
 >arg : T
 }
@@ -18,7 +18,7 @@ declare function cases(tester: Tester): void;
 >tester : Tester

 declare function fn<Y extends any[]>(implementation?: (...args: Y) => any): Mock<Y>;
->fn : <Y extends any[]>(implementation?: ((...args: Y) => any) | undefined) => Mock<Y>
+>fn : <Y extends any[]>(implementation?: (...args: Y) => any) => Mock<Y>
 >implementation : ((...args: Y) => any) | undefined
 >args : Y

@@ -30,8 +30,8 @@ type PostBody<PATH extends PostPath> = Extract<ApiPost, { path: PATH }>["body"];
 >path : PATH

 const post = <PATH extends PostPath>(
->post : <PATH extends "/login" | "/user">(path: PATH, { body, ...options }: Omit<RequestInit, "body"> & { body: PostBody<PATH>; }) => void
-><PATH extends PostPath>(    path: PATH,    {body, ...options}: Omit<RequestInit, 'body'> & {body: PostBody<PATH>}) => {} : <PATH extends "/login" | "/user">(path: PATH, { body, ...options }: Omit<RequestInit, "body"> & { body: PostBody<PATH>; }) => void
+>post : <PATH extends "/login" | "/user">(path: PATH, { body, ...options }: Omit<RequestInit, 'body'> & {    body: PostBody<PATH>;}) => void
+><PATH extends PostPath>(    path: PATH,    {body, ...options}: Omit<RequestInit, 'body'> & {body: PostBody<PATH>}) => {} : <PATH extends "/login" | "/user">(path: PATH, { body, ...options }: Omit<RequestInit, 'body'> & {    body: PostBody<PATH>;}) => void

    path: PATH,
 >path : PATH
@@ -42,7 +42,7 @@ function testObjLiteral(objLit: { v: any; w: any }) { };
 >w : any

 function testFuncLiteral(funcLit: (y2) => number) { };
->testFuncLiteral : (funcLit: (y2: any) => number) => void
+>testFuncLiteral : (funcLit: (y2) => number) => void
 >funcLit : (y2: any) => number
 >y2 : any

@@ -58,12 +58,12 @@ map = names2;
 >names2 : { a: string; b: string; }

 declare function getStringIndexValue<T>(map: { [x: string]: T }): T;
->getStringIndexValue : <T>(map: { [x: string]: T; }) => T
+>getStringIndexValue : <T>(map: {    [x: string]: T;}) => T
 >map : { [x: string]: T; }
 >x : string

 declare function getNumberIndexValue<T>(map: { [x: number]: T }): T;
->getNumberIndexValue : <T>(map: { [x: number]: T; }) => T
+>getNumberIndexValue : <T>(map: {    [x: number]: T;}) => T
 >map : { [x: number]: T; }
 >x : number

@@ -5,7 +5,7 @@
 // { [key: string]: Y } if X is related to Y.

 function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
->f1 : <T, K extends string>(x: { [key: string]: T; }, y: Record<K, T>) => void
+>f1 : <T, K extends string>(x: {    [key: string]: T;}, y: Record<K, T>) => void
 >x : { [key: string]: T; }
 >key : string
 >y : Record<K, T>
@@ -22,7 +22,7 @@ function f1<T, K extends string>(x: { [key: string]: T }, y: Record<K, T>) {
 }

 function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
->f2 : <T>(x: { [key: string]: T; }, y: Record<string, T>) => void
+>f2 : <T>(x: {    [key: string]: T;}, y: Record<string, T>) => void
 >x : { [key: string]: T; }
 >key : string
 >y : Record<string, T>
@@ -39,7 +39,7 @@ function f2<T>(x: { [key: string]: T }, y: Record<string, T>) {
 }

 function f3<T, U, K extends string>(x: { [key: string]: T }, y: Record<K, U>) {
->f3 : <T, U, K extends string>(x: { [key: string]: T; }, y: Record<K, U>) => void
+>f3 : <T, U, K extends string>(x: {    [key: string]: T;}, y: Record<K, U>) => void
 >x : { [key: string]: T; }
 >key : string
 >y : Record<K, U>
@@ -2,7 +2,7 @@

 === indexSignatureOfTypeUnknownStillRequiresIndexSignature.ts ===
 declare function f<T extends unknown = unknown>(x: { [x: string]: T }): T;
->f : <T extends unknown = unknown>(x: { [x: string]: T; }) => T
+>f : <T extends unknown = unknown>(x: {    [x: string]: T;}) => T
 >x : { [x: string]: T; }
 >x : string

@@ -9,7 +9,7 @@ const sym = Symbol();
 >Symbol : SymbolConstructor

 function gg3(x: { [key: string]: string }, y: { [key: symbol]: string }, z: { [sym]: number }) {
->gg3 : (x: { [key: string]: string; }, y: { [key: symbol]: string; }, z: {    [sym]: number;}) => void
+>gg3 : (x: {    [key: string]: string;}, y: {    [key: symbol]: string;}, z: {    [sym]: number;}) => void
 >x : { [key: string]: string; }
 >key : string
 >y : { [key: symbol]: string; }
@@ -32,7 +32,7 @@ function gg3(x: { [key: string]: string }, y: { [key: symbol]: string }, z: { [s
 // Overlapping index signatures

 function gg1(x: { [key: `a${string}`]: string, [key: `${string}a`]: string }, y: { [key: `a${string}a`]: string }) {
->gg1 : (x: { [key: `a${string}`]: string; [key: `${string}a`]: string; }, y: { [key: `a${string}a`]: string; }) => void
+>gg1 : (x: {    [key: `a${string}`]: string;    [key: `${string}a`]: string;}, y: {    [key: `a${string}a`]: string;}) => void
 >x : { [key: `a${string}`]: string; [key: `${string}a`]: string; }
 >key : `a${string}`
 >key : `${string}a`
@@ -2,13 +2,13 @@

 === indexSignaturesInferentialTyping.ts ===
 function foo<T>(items: { [index: number]: T }): T { return undefined; }
->foo : <T>(items: { [index: number]: T; }) => T
+>foo : <T>(items: {    [index: number]: T;}) => T
 >items : { [index: number]: T; }
 >index : number
 >undefined : undefined

 function bar<T>(items: { [index: string]: T }): T { return undefined; }
->bar : <T>(items: { [index: string]: T; }) => T
+>bar : <T>(items: {    [index: string]: T;}) => T
 >items : { [index: string]: T; }
 >index : string
 >undefined : undefined
@@ -3,7 +3,7 @@
 === indexerReturningTypeParameter1.ts ===
 interface f {
    groupBy<T>(): { [key: string]: T[]; };
->groupBy : <T>() => { [key: string]: T[]; }
+>groupBy : <T>() => {    [key: string]: T[];}
 >key : string
 }
 var a: f;
@@ -20,7 +20,7 @@ class c {
 >c : c

    groupBy<T>(): { [key: string]: T[]; } {
->groupBy : <T>() => { [key: string]: T[]; }
+>groupBy : <T>() => {    [key: string]: T[];}
 >key : string

        return null;
@@ -522,7 +522,7 @@ class ClassWithConvert<T> {
 >val : T

  convert(converter: { to: (v: T) => T; }) { }
->convert : (converter: { to: (v: T) => T; }) => void
+>convert : (converter: {    to: (v: T) => T;}) => void
 >converter : { to: (v: T) => T; }
 >to : (v: T) => T
 >v : T
@@ -4,7 +4,7 @@
 // repro #50687

 declare function repro<T>(config: {
->repro : <T>(config: { params: T; callback: () => (params: T) => number; }) => void
+>repro : <T>(config: {    params: T;    callback: () => (params: T) => number;}) => void
 >config : { params: T; callback: () => (params: T) => number; }

  params: T;
@@ -5,7 +5,7 @@ interface NodeArray<T extends Node> extends ReadonlyArray<T> {}

 interface Node {
    forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined): T | undefined;
->forEachChild : <T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: ((nodes: NodeArray<Node>) => T | undefined) | undefined) => T | undefined
+>forEachChild : <T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray<Node>) => T | undefined) => T | undefined
 >cbNode : (node: Node) => T | undefined
 >node : Node
 >cbNodeArray : ((nodes: NodeArray<Node>) => T | undefined) | undefined
@@ -2,7 +2,7 @@

 === inferenceOptionalProperties.ts ===
 declare function test<T>(x: { [key: string]: T }): T;
->test : <T>(x: { [key: string]: T; }) => T
+>test : <T>(x: {    [key: string]: T;}) => T
 >x : { [key: string]: T; }
 >key : string

@@ -2,7 +2,7 @@

 === inferenceOptionalPropertiesStrict.ts ===
 declare function test<T>(x: { [key: string]: T }): T;
->test : <T>(x: { [key: string]: T; }) => T
+>test : <T>(x: {    [key: string]: T;}) => T
 >x : { [key: string]: T; }
 >key : string

@@ -2,7 +2,7 @@

 === inferenceOptionalPropertiesToIndexSignatures.ts ===
 declare function foo<T>(obj: { [x: string]: T }): T;
->foo : <T>(obj: { [x: string]: T; }) => T
+>foo : <T>(obj: {    [x: string]: T;}) => T
 >obj : { [x: string]: T; }
 >x : string

@@ -2,9 +2,9 @@

 === inferentialTypingWithFunctionTypeNested.ts ===
 declare function map<T, U>(x: T, f: () => { x: (s: T) => U }): U;
->map : <T, U>(x: T, f: () => { x: (s: T) => U; }) => U
+>map : <T, U>(x: T, f: () => {    x: (s: T) => U;}) => U
 >x : T
->f : () => { x: (s: T) => U; }
+>f : () => {    x: (s: T) => U;}
 >x : (s: T) => U
 >s : T

@@ -2,7 +2,7 @@

 === inferentialTypingWithFunctionTypeZip.ts ===
 var pair: <T, S>(x: T) => (y: S) => { x: T; y: S; }
->pair : <T, S>(x: T) => (y: S) => { x: T; y: S; }
+>pair : <T, S>(x: T) => (y: S) => {    x: T;    y: S;}
 >x : T
 >y : S
 >x : T
@@ -49,12 +49,12 @@ declare function f9<T>(x: new () => T): T;
 >x : new () => T

 declare function f10<T>(x: { [x: string]: T }): T;
->f10 : <T>(x: { [x: string]: T; }) => T
+>f10 : <T>(x: {    [x: string]: T;}) => T
 >x : { [x: string]: T; }
 >x : string

 declare function f11<T>(x: { [x: number]: T }): T;
->f11 : <T>(x: { [x: number]: T; }) => T
+>f11 : <T>(x: {    [x: number]: T;}) => T
 >x : { [x: number]: T; }
 >x : number

@@ -14,7 +14,7 @@ import * as foo from "./foo";
 >foo : typeof foo

 function f(map: { [k: string]: number }) {
->f : (map: { [k: string]: number; }) => void
+>f : (map: {    [k: string]: number;}) => void
 >map : { [k: string]: number; }
 >k : string

@@ -15,7 +15,7 @@ export class EnumTypeComposer {
 >EnumTypeComposer : EnumTypeComposer

  public setFields(fields: { [name: string]: { [key: string]: any } }): this;
->setFields : (fields: { [name: string]: { [key: string]: any; }; }) => this
+>setFields : (fields: {    [name: string]: {        [key: string]: any;    };}) => this
 >fields : { [name: string]: { [key: string]: any; }; }
 >name : string
 >key : string
@@ -38,10 +38,10 @@ export class Resolver {
 >Resolver : Resolver

  public wrapArgs<NewContext>(
->wrapArgs : <NewContext>(cb: () => { [argName: string]: Thunk<Readonly<EnumTypeComposer>>; }) => void
+>wrapArgs : <NewContext>(cb: () => {    [argName: string]: Thunk<Readonly<EnumTypeComposer>>;}) => void

    cb: () => {
->cb : () => { [argName: string]: Thunk<Readonly<EnumTypeComposer>>; }
+>cb : () => {    [argName: string]: Thunk<Readonly<EnumTypeComposer>>;}

      [argName: string]: Thunk<Readonly<EnumTypeComposer>>;
 >argName : string
@@ -2,7 +2,7 @@

 === innerTypeCheckOfLambdaArgument.ts ===
 function takesCallback(callback: (n) =>any) {
->takesCallback : (callback: (n: any) => any) => void
+>takesCallback : (callback: (n) => any) => void
 >callback : (n: any) => any
 >n : any

@@ -67,7 +67,7 @@ new GenericComponent({ initialValues: 12, nextValues: val => 12 });
 // #22149

 declare function useStringOrNumber<T extends string | number>(t: T, useIt: T extends string ? ((s: string) => void) : ((n: number) => void)): void;
->useStringOrNumber : <T extends string | number>(t: T, useIt: T extends string ? (s: string) => void : (n: number) => void) => void
+>useStringOrNumber : <T extends string | number>(t: T, useIt: T extends string ? ((s: string) => void) : ((n: number) => void)) => void
 >t : T
 >useIt : T extends string ? (s: string) => void : (n: number) => void
 >s : string
@@ -4,7 +4,7 @@
 // Repros from #47599

 declare function callIt<T>(obj: {
->callIt : <T>(obj: { produce: (n: number) => T; consume: (x: T) => void; }) => void
+>callIt : <T>(obj: {    produce: (n: number) => T;    consume: (x: T) => void;}) => void
 >obj : { produce: (n: number) => T; consume: (x: T) => void; }

    produce: (n: number) => T,
@@ -160,7 +160,7 @@ const myGeneric = inferTypeFn({
 // Repro #38623

 function make<M>(o: { mutations: M,  action: (m: M) => void }) { }
->make : <M>(o: { mutations: M; action: (m: M) => void; }) => void
+>make : <M>(o: {    mutations: M;    action: (m: M) => void;}) => void
 >o : { mutations: M; action: (m: M) => void; }
 >mutations : M
 >action : (m: M) => void
@@ -193,7 +193,7 @@ make({
 // Repro from #38845

 declare function foo<A>(options: { a: A, b: (a: A) => void }): void;
->foo : <A>(options: { a: A; b: (a: A) => void; }) => void
+>foo : <A>(options: {    a: A;    b: (a: A) => void;}) => void
 >options : { a: A; b: (a: A) => void; }
 >a : A
 >b : (a: A) => void
@@ -425,14 +425,14 @@ createMappingComponent({
 // Repro from #48279

 function simplified<T>(props: { generator: () => T, receiver: (t: T) => any }) {}
->simplified : <T>(props: { generator: () => T; receiver: (t: T) => any; }) => void
+>simplified : <T>(props: {    generator: () => T;    receiver: (t: T) => any;}) => void
 >props : { generator: () => T; receiver: (t: T) => any; }
 >generator : () => T
 >receiver : (t: T) => any
 >t : T

 function whatIWant<T>(props: { generator: (bob: any) => T, receiver: (t: T) => any }) {}
->whatIWant : <T>(props: { generator: (bob: any) => T; receiver: (t: T) => any; }) => void
+>whatIWant : <T>(props: {    generator: (bob: any) => T;    receiver: (t: T) => any;}) => void
 >props : { generator: (bob: any) => T; receiver: (t: T) => any; }
 >generator : (bob: any) => T
 >bob : any
@@ -620,7 +620,7 @@ example({
 // Repro from #45255

 declare const branch:
->branch : <T, U extends T>(_: { test: T; if: (t: T) => t is U; then: (u: U) => void; }) => void
+>branch : <T, U extends T>(_: {    test: T;    if: (t: T) => t is U;    then: (u: U) => void;}) => void

  <T, U extends T>(_: { test: T, if: (t: T) => t is U, then: (u: U) => void }) => void
 >_ : { test: T; if: (t: T) => t is U; then: (u: U) => void; }
@@ -705,8 +705,8 @@ Foo({
 });

 declare function nested<T>(arg: {
->nested : <T>(arg: { prop: { produce: (arg1: number) => T; consume: (arg2: T) => void; }; }) => T
->arg : { prop: { produce: (arg1: number) => T; consume: (arg2: T) => void; }; }
+>nested : <T>(arg: {    prop: {        produce: (arg1: number) => T;        consume: (arg2: T) => void;    };}) => T
+>arg : { prop: {    produce: (arg1: number) => T;    consume: (arg2: T) => void;}; }

  prop: {
 >prop : { produce: (arg1: number) => T; consume: (arg2: T) => void; }
@@ -753,7 +753,7 @@ const resNested = nested({
 });

 declare function twoConsumers<T>(arg: {
->twoConsumers : <T>(arg: { a: (arg: string) => T; consume1: (arg1: T) => void; consume2: (arg2: T) => void; }) => T
+>twoConsumers : <T>(arg: {    a: (arg: string) => T;    consume1: (arg1: T) => void;    consume2: (arg2: T) => void;}) => T
 >arg : { a: (arg: string) => T; consume1: (arg1: T) => void; consume2: (arg2: T) => void; }

  a: (arg: string) => T;
@@ -796,7 +796,7 @@ const resTwoConsumers = twoConsumers({
 });

 declare function multipleProducersBeforeConsumers<T, T2>(arg: {
->multipleProducersBeforeConsumers : <T, T2>(arg: { a: (arg: string) => T; b: (arg: string) => T2; consume1: (arg1: T) => void; consume2: (arg2: T2) => void; }) => [T, T2]
+>multipleProducersBeforeConsumers : <T, T2>(arg: {    a: (arg: string) => T;    b: (arg: string) => T2;    consume1: (arg1: T) => void;    consume2: (arg2: T2) => void;}) => [T, T2]
 >arg : { a: (arg: string) => T; b: (arg: string) => T2; consume1: (arg1: T) => void; consume2: (arg2: T2) => void; }

  a: (arg: string) => T;
@@ -851,7 +851,7 @@ const resMultipleProducersBeforeConsumers = multipleProducersBeforeConsumers({
 });

 declare function withConditionalExpression<T, T2, T3>(arg: {
->withConditionalExpression : <T, T2, T3>(arg: { a: (arg1: string) => T; b: (arg2: T) => T2; c: (arg2: T2) => T3; }) => [T, T2, T3]
+>withConditionalExpression : <T, T2, T3>(arg: {    a: (arg1: string) => T;    b: (arg2: T) => T2;    c: (arg2: T2) => T3;}) => [T, T2, T3]
 >arg : { a: (arg1: string) => T; b: (arg2: T) => T2; c: (arg2: T2) => T3; }

  a: (arg1: string) => T;
@@ -908,15 +908,15 @@ const resWithConditionalExpression = withConditionalExpression({
 });

 declare function onion<T, T2, T3>(arg: {
->onion : <T, T2, T3>(arg: { a: (arg1: string) => T; nested: { b: (arg2: T) => T2; nested2: { c: (arg2: T2) => T3; }; }; }) => [T, T2, T3]
->arg : { a: (arg1: string) => T; nested: { b: (arg2: T) => T2; nested2: { c: (arg2: T2) => T3; }; }; }
+>onion : <T, T2, T3>(arg: {    a: (arg1: string) => T;    nested: {        b: (arg2: T) => T2;        nested2: {            c: (arg2: T2) => T3;        };    };}) => [T, T2, T3]
+>arg : { a: (arg1: string) => T; nested: {    b: (arg2: T) => T2;    nested2: {        c: (arg2: T2) => T3;    };}; }

  a: (arg1: string) => T;
 >a : (arg1: string) => T
 >arg1 : string

  nested: {
->nested : { b: (arg2: T) => T2; nested2: { c: (arg2: T2) => T3; }; }
+>nested : { b: (arg2: T) => T2; nested2: {    c: (arg2: T2) => T3;}; }

    b: (arg2: T) => T2;
 >b : (arg2: T) => T2
@@ -977,15 +977,15 @@ const resOnion = onion({
 });

 declare function onion2<T, T2, T3, T4>(arg: {
->onion2 : <T, T2, T3, T4>(arg: { a: (arg1: string) => T; nested: { b: (arg2: T) => T2; c: (arg3: T) => T3; nested2: { d: (arg4: T3) => T4; }; }; }) => [T, T2, T3, T4]
->arg : { a: (arg1: string) => T; nested: { b: (arg2: T) => T2; c: (arg3: T) => T3; nested2: { d: (arg4: T3) => T4; }; }; }
+>onion2 : <T, T2, T3, T4>(arg: {    a: (arg1: string) => T;    nested: {        b: (arg2: T) => T2;        c: (arg3: T) => T3;        nested2: {            d: (arg4: T3) => T4;        };    };}) => [T, T2, T3, T4]
+>arg : { a: (arg1: string) => T; nested: {    b: (arg2: T) => T2;    c: (arg3: T) => T3;    nested2: {        d: (arg4: T3) => T4;    };}; }

  a: (arg1: string) => T;
 >a : (arg1: string) => T
 >arg1 : string

  nested: {
->nested : { b: (arg2: T) => T2; c: (arg3: T) => T3; nested2: { d: (arg4: T3) => T4; }; }
+>nested : { b: (arg2: T) => T2; c: (arg3: T) => T3; nested2: {    d: (arg4: T3) => T4;}; }

    b: (arg2: T) => T2;
 >b : (arg2: T) => T2
@@ -1058,14 +1058,14 @@ const resOnion2 = onion2({
 });

 declare function distant<T>(args: {
->distant : <T>(args: { foo: { bar: { baz: { producer: (arg: string) => T; }; }; }; consumer: (val: T) => unknown; }) => T
->args : { foo: { bar: { baz: { producer: (arg: string) => T; }; }; }; consumer: (val: T) => unknown; }
+>distant : <T>(args: {    foo: {        bar: {            baz: {                producer: (arg: string) => T;            };        };    };    consumer: (val: T) => unknown;}) => T
+>args : { foo: {    bar: {        baz: {            producer: (arg: string) => T;        };    };}; consumer: (val: T) => unknown; }

  foo: {
->foo : { bar: { baz: { producer: (arg: string) => T; }; }; }
+>foo : { bar: {    baz: {        producer: (arg: string) => T;    };}; }

    bar: {
->bar : { baz: { producer: (arg: string) => T; }; }
+>bar : { baz: {    producer: (arg: string) => T;}; }

      baz: {
 >baz : { producer: (arg: string) => T; }
@@ -317,7 +317,7 @@ function f5(s: string) {
 }

 function makeDictionary<T>(obj: { [x: string]: T }) {
->makeDictionary : <T>(obj: { [x: string]: T; }) => { [x: string]: T; }
+>makeDictionary : <T>(obj: {    [x: string]: T;}) => { [x: string]: T; }
 >obj : { [x: string]: T; }
 >x : string

@@ -67,10 +67,15 @@ export namespace myTypes {
        prop2: string;
    };
    type typeC = myTypes.typeB | Function;
-    let myTypes: {
-        [x: string]: any;
-    };
 }
+/**
+ * @namespace myTypes
+ * @global
+ * @type {Object<string,*>}
+ */
+export const myTypes: {
+    [x: string]: any;
+};
 //// [file2.d.ts]
 export namespace testFnTypes {
    type input = boolean | myTypes.typeC;
--- a/Show More
+++ b/Show More