Preserve range on copied identifiers (#57965)

src/compiler/checker.ts

@@ -8611,7 +8611,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     const type = getDeclaredTypeOfSymbol(sym);
                     const name = sym.flags & SymbolFlags.TypeParameter ? typeParameterToName(type, context) : factory.cloneNode(node);
                     name.symbol = sym; // for quickinfo, which uses identifier symbol information
-                    return { introducesError, node: setEmitFlags(setOriginalNode(name, node), EmitFlags.NoAsciiEscaping) };
+                    return { introducesError, node: setTextRange(setEmitFlags(setOriginalNode(name, node), EmitFlags.NoAsciiEscaping), node) };
                 }
             }
 

tests/baselines/reference/1.0lib-noErrors.types

@@ -176,7 +176,7 @@ interface Object {
     /** Returns the primitive value of the specified object. */
     valueOf(): Object;
 >valueOf : () => Object
->        : ^^^^^^^^^^^^
+>        : ^^^^^^      
 
     /**
       * Determines whether an object has a property with the specified name. 
@@ -194,7 +194,7 @@ interface Object {
       */
     isPrototypeOf(v: Object): boolean;
 >isPrototypeOf : (v: Object) => boolean
->              : ^^^^^^^^^^^^^^^       
+>              : ^^^^      ^^^^^       
 >v : Object
 >  : ^^^^^^
 
@@ -214,7 +214,7 @@ interface Object {
   */
 declare var Object: {
 >Object : { (): any; (value: any): any; new (value?: any): Object; prototype: Object; getPrototypeOf(o: any): any; getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor; getOwnPropertyNames(o: any): string[]; create(o: any, properties?: PropertyDescriptorMap): any; defineProperty(o: any, p: string, attributes: PropertyDescriptor): any; defineProperties(o: any, properties: PropertyDescriptorMap): any; seal(o: any): any; freeze(o: any): any; preventExtensions(o: any): any; isSealed(o: any): boolean; isFrozen(o: any): boolean; isExtensible(o: any): boolean; keys(o: any): string[]; }
->       : ^^^^^^   ^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^        ^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^   ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^   ^^^   ^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^   ^^^        ^^^
+>       : ^^^^^^   ^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^      ^^^                  ^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^        ^^^^^^^^^^^^   ^^^^^^^^^^^^^^^                     ^^^   ^^^^^^^^^^^^^^^^^^^^   ^^^^^      ^^^^^^^^^^^^^^                  ^^^   ^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^                     ^^^   ^^^^^^^^^^   ^^^   ^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^   ^^^        ^^^
 
     new (value?: any): Object;
 >value : any
@@ -245,7 +245,7 @@ declare var Object: {
     */
     getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor;
 >getOwnPropertyDescriptor : (o: any, p: string) => PropertyDescriptor
->                         : ^^^^   ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^
+>                         : ^^^^   ^^^^^      ^^^^^                  
 >o : any
 >p : string
 >  : ^^^^^^
@@ -267,7 +267,7 @@ declare var Object: {
       */
     create(o: any, properties?: PropertyDescriptorMap): any;
 >create : (o: any, properties?: PropertyDescriptorMap) => any
->       : ^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   
+>       : ^^^^   ^^^^^^^^^^^^^^^                     ^^^^^   
 >o : any
 >properties : PropertyDescriptorMap
 >           : ^^^^^^^^^^^^^^^^^^^^^
@@ -280,7 +280,7 @@ declare var Object: {
       */
     defineProperty(o: any, p: string, attributes: PropertyDescriptor): any;
 >defineProperty : (o: any, p: string, attributes: PropertyDescriptor) => any
->               : ^^^^   ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   
+>               : ^^^^   ^^^^^      ^^^^^^^^^^^^^^                  ^^^^^   
 >o : any
 >p : string
 >  : ^^^^^^
@@ -294,7 +294,7 @@ declare var Object: {
       */
     defineProperties(o: any, properties: PropertyDescriptorMap): any;
 >defineProperties : (o: any, properties: PropertyDescriptorMap) => any
->                 : ^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   
+>                 : ^^^^   ^^^^^^^^^^^^^^                     ^^^^^   
 >o : any
 >properties : PropertyDescriptorMap
 >           : ^^^^^^^^^^^^^^^^^^^^^
@@ -421,7 +421,7 @@ interface Function {
 
 declare var Function: {
 >Function : { (...args: string[]): Function; new (...args: string[]): Function; prototype: Function; }
->         : ^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>         : ^^^^^^^^^^^^        ^^^        ^^^^^^^^^^^^^^^^        ^^^        ^^^^^^^^^^^^^        ^^^
 
     /** 
       * Creates a new function.
@@ -542,7 +542,7 @@ interface String {
       */
     match(regexp: RegExp): string[];
 >match : { (regexp: string): string[]; (regexp: RegExp): string[]; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^        ^^^
 >regexp : RegExp
 >       : ^^^^^^
 
@@ -583,7 +583,7 @@ interface String {
       */
     replace(searchValue: RegExp, replaceValue: string): string;
 >replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >searchValue : RegExp
 >            : ^^^^^^
 >replaceValue : string
@@ -596,7 +596,7 @@ interface String {
       */
     replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
 >replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                             ^^^      ^^^
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^                                             ^^^      ^^^
 >searchValue : RegExp
 >            : ^^^^^^
 >replaceValue : (substring: string, ...args: any[]) => string
@@ -622,7 +622,7 @@ interface String {
       */
     search(regexp: RegExp): number;
 >search : { (regexp: string): number; (regexp: RegExp): number; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^      ^^^
 >regexp : RegExp
 >       : ^^^^^^
 
@@ -660,7 +660,7 @@ interface String {
       */
     split(separator: RegExp, limit?: number): string[];
 >split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^        ^^^
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^      ^^^        ^^^
 >separator : RegExp
 >          : ^^^^^^
 >limit : number
@@ -734,7 +734,7 @@ interface String {
   */
 declare var String: {
 >String : { (value?: any): string; new (value?: any): String; prototype: String; fromCharCode(...codes: number[]): string; }
->       : ^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^      ^^^
+>       : ^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^      ^^^
 
     new (value?: any): String;
 >value : any
@@ -757,7 +757,7 @@ interface Boolean {
 }
 declare var Boolean: {
 >Boolean : { (value?: any): boolean; new (value?: any): Boolean; prototype: Boolean; }
->        : ^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^       ^^^
 
     new (value?: any): Boolean;
 >value : any
@@ -815,7 +815,7 @@ interface Number {
 /** An object that represents a number of any kind. All JavaScript numbers are 64-bit floating-point numbers. */
 declare var Number: {
 >Number : { (value?: any): number; new (value?: any): Number; prototype: Number; MAX_VALUE: number; MIN_VALUE: number; NaN: number; NEGATIVE_INFINITY: number; POSITIVE_INFINITY: number; }
->       : ^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^      ^^^
+>       : ^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^^^   ^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^      ^^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^      ^^^
 
     new (value?: any): Number;
 >value : any
@@ -1440,7 +1440,7 @@ interface Date {
 
 declare var Date: {
 >Date : { (): string; new (): Date; new (value: number): Date; new (value: string): Date; new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date; prototype: Date; parse(s: string): number; UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number; now(): number; }
->     : ^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^      ^^^^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^      ^^^      ^^^^^^^^^      ^^^
+>     : ^^^^^^      ^^^^^^^^^^    ^^^^^^^^^^^^^^      ^^^    ^^^^^^^^^^^^^^      ^^^    ^^^^^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^      ^^^    ^^^^^^^^^^^^^    ^^^^^^^^^^^      ^^^      ^^^^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^^^^^^      ^^^^^^^      ^^^      ^^^^^^^^^      ^^^
 
     new (): Date;
     new (value: number): Date;
@@ -1726,7 +1726,7 @@ interface RegExp {
       */
     exec(string: string): RegExpExecArray;
 >exec : (string: string) => RegExpExecArray
->     : ^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^
+>     : ^^^^^^^^^      ^^^^^               
 >string : string
 >       : ^^^^^^
 
@@ -1767,11 +1767,11 @@ interface RegExp {
     // Non-standard extensions
     compile(): RegExp;
 >compile : () => RegExp
->        : ^^^^^^^^^^^^
+>        : ^^^^^^      
 }
 declare var RegExp: {
 >RegExp : { (pattern: string, flags?: string): RegExp; new (pattern: string, flags?: string): RegExp; $1: string; $2: string; $3: string; $4: string; $5: string; $6: string; $7: string; $8: string; $9: string; lastMatch: string; }
->       : ^^^^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^      ^^^^^^^^^^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^^^^^^^^      ^^^
+>       : ^^^^^^^^^^^^      ^^^^^^^^^^      ^^^      ^^^^^^^^^^^^^^^^      ^^^^^^^^^^      ^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^      ^^^^^^^^^^^^^      ^^^
 
     new (pattern: string, flags?: string): RegExp;
 >pattern : string
@@ -1838,7 +1838,7 @@ interface Error {
 }
 declare var Error: {
 >Error : { (message?: string): Error; new (message?: string): Error; prototype: Error; }
->      : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^^^^^^^^      ^^^     ^^^^^^^^^^^^^^^^^      ^^^     ^^^^^^^^^^^^^     ^^^
 
     new (message?: string): Error;
 >message : string
@@ -1857,7 +1857,7 @@ interface EvalError extends Error {
 }
 declare var EvalError: {
 >EvalError : { (message?: string): EvalError; new (message?: string): EvalError; prototype: EvalError; }
->          : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>          : ^^^^^^^^^^^^^      ^^^         ^^^^^^^^^^^^^^^^^      ^^^         ^^^^^^^^^^^^^         ^^^
 
     new (message?: string): EvalError;
 >message : string
@@ -1876,7 +1876,7 @@ interface RangeError extends Error {
 }
 declare var RangeError: {
 >RangeError : { (message?: string): RangeError; new (message?: string): RangeError; prototype: RangeError; }
->           : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>           : ^^^^^^^^^^^^^      ^^^          ^^^^^^^^^^^^^^^^^      ^^^          ^^^^^^^^^^^^^          ^^^
 
     new (message?: string): RangeError;
 >message : string
@@ -1895,7 +1895,7 @@ interface ReferenceError extends Error {
 }
 declare var ReferenceError: {
 >ReferenceError : { (message?: string): ReferenceError; new (message?: string): ReferenceError; prototype: ReferenceError; }
->               : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>               : ^^^^^^^^^^^^^      ^^^              ^^^^^^^^^^^^^^^^^      ^^^              ^^^^^^^^^^^^^              ^^^
 
     new (message?: string): ReferenceError;
 >message : string
@@ -1914,7 +1914,7 @@ interface SyntaxError extends Error {
 }
 declare var SyntaxError: {
 >SyntaxError : { (message?: string): SyntaxError; new (message?: string): SyntaxError; prototype: SyntaxError; }
->            : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>            : ^^^^^^^^^^^^^      ^^^           ^^^^^^^^^^^^^^^^^      ^^^           ^^^^^^^^^^^^^           ^^^
 
     new (message?: string): SyntaxError;
 >message : string
@@ -1933,7 +1933,7 @@ interface TypeError extends Error {
 }
 declare var TypeError: {
 >TypeError : { (message?: string): TypeError; new (message?: string): TypeError; prototype: TypeError; }
->          : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>          : ^^^^^^^^^^^^^      ^^^         ^^^^^^^^^^^^^^^^^      ^^^         ^^^^^^^^^^^^^         ^^^
 
     new (message?: string): TypeError;
 >message : string
@@ -1952,7 +1952,7 @@ interface URIError extends Error {
 }
 declare var URIError: {
 >URIError : { (message?: string): URIError; new (message?: string): URIError; prototype: URIError; }
->         : ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>         : ^^^^^^^^^^^^^      ^^^        ^^^^^^^^^^^^^^^^^      ^^^        ^^^^^^^^^^^^^        ^^^
 
     new (message?: string): URIError;
 >message : string
@@ -2081,7 +2081,7 @@ interface Array<T> {
       */
     concat<U extends T[]>(...items: U[]): T[];
 >concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^
 >items : U[]
 >      : ^^^
 
@@ -2091,7 +2091,7 @@ interface Array<T> {
       */
     concat(...items: T[]): T[];
 >concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^  ^^^
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^   ^^^
 >items : T[]
 >      : ^^^
 
@@ -2110,7 +2110,7 @@ interface Array<T> {
       */
     pop(): T;
 >pop : () => T
->    : ^^^^^^^
+>    : ^^^^^^ 
 
     /**
       * Appends new elements to an array, and returns the new length of the array.
@@ -2118,7 +2118,7 @@ interface Array<T> {
       */
     push(...items: T[]): number;
 >push : (...items: T[]) => number
->     : ^^^^^^^^^^^^  ^^^^^      
+>     : ^^^^^^^^^^^   ^^^^^      
 >items : T[]
 >      : ^^^
 
@@ -2127,14 +2127,14 @@ interface Array<T> {
       */
     reverse(): T[];
 >reverse : () => T[]
->        : ^^^^^^^  
+>        : ^^^^^^   
 
     /**
       * Removes the first element from an array and returns it.
       */
     shift(): T;
 >shift : () => T
->      : ^^^^^^^
+>      : ^^^^^^ 
 
     /** 
       * Returns a section of an array.
@@ -2143,7 +2143,7 @@ interface Array<T> {
       */
     slice(start?: number, end?: number): T[];
 >slice : (start?: number, end?: number) => T[]
->      : ^^^^^^^^^      ^^^^^^^^      ^^^^^^  
+>      : ^^^^^^^^^      ^^^^^^^^      ^^^^^   
 >start : number
 >      : ^^^^^^
 >end : number
@@ -2155,9 +2155,9 @@ interface Array<T> {
       */
     sort(compareFn?: (a: T, b: T) => number): T[];
 >sort : (compareFn?: (a: T, b: T) => number) => T[]
->     : ^^^^^^^^^^^^^    ^     ^           ^^^^^^  
+>     : ^^^^^^^^^^^^^                      ^^^^^   
 >compareFn : (a: T, b: T) => number
->          : ^^^^^^^^^^^^^^^^      
+>          : ^^^^ ^^^^^ ^^^^^      
 >a : T
 >  : ^
 >b : T
@@ -2169,7 +2169,7 @@ interface Array<T> {
       */
     splice(start: number): T[];
 >splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^^^^^^^^      ^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^^^^^^^^^^      ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >start : number
 >      : ^^^^^^
 
@@ -2181,7 +2181,7 @@ interface Array<T> {
       */
     splice(start: number, deleteCount: number, ...items: T[]): T[];
 >splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^  ^^^^  ^^^
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^   ^^^   ^^^
 >start : number
 >      : ^^^^^^
 >deleteCount : number
@@ -2195,7 +2195,7 @@ interface Array<T> {
       */
     unshift(...items: T[]): number;
 >unshift : (...items: T[]) => number
->        : ^^^^^^^^^^^^  ^^^^^      
+>        : ^^^^^^^^^^^   ^^^^^      
 >items : T[]
 >      : ^^^
 
@@ -2206,7 +2206,7 @@ interface Array<T> {
       */
     indexOf(searchElement: T, fromIndex?: number): number;
 >indexOf : (searchElement: T, fromIndex?: number) => number
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^      
+>        : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^      ^^^^^      
 >searchElement : T
 >              : ^
 >fromIndex : number
@@ -2219,7 +2219,7 @@ interface Array<T> {
       */
     lastIndexOf(searchElement: T, fromIndex?: number): number;
 >lastIndexOf : (searchElement: T, fromIndex?: number) => number
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^      
+>            : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^      ^^^^^      
 >searchElement : T
 >              : ^
 >fromIndex : number
@@ -2232,9 +2232,9 @@ interface Array<T> {
       */
     every(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
 >every : (callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => boolean
->      : ^^^^^^^^^^^^^        ^                        ^              ^^^^^^^^^^^^   ^^^^^       
+>      : ^^^^^^^^^^^^^                                                ^^^^^^^^^^^^   ^^^^^       
 >callbackfn : (value: T, index: number, array: T[]) => boolean
->           : ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^       
+>           : ^^^^^^^^ ^^^^^^^^^      ^^^^^^^^^   ^^^^^       
 >value : T
 >      : ^
 >index : number
@@ -2250,9 +2250,9 @@ interface Array<T> {
       */
     some(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): boolean;
 >some : (callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => boolean
->     : ^^^^^^^^^^^^^        ^                        ^              ^^^^^^^^^^^^   ^^^^^       
+>     : ^^^^^^^^^^^^^                                                ^^^^^^^^^^^^   ^^^^^       
 >callbackfn : (value: T, index: number, array: T[]) => boolean
->           : ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^       
+>           : ^^^^^^^^ ^^^^^^^^^      ^^^^^^^^^   ^^^^^       
 >value : T
 >      : ^
 >index : number
@@ -2268,9 +2268,9 @@ interface Array<T> {
       */
     forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
 >forEach : (callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any) => void
->        : ^^^^^^^^^^^^^        ^                        ^           ^^^^^^^^^^^^   ^^^^^    
+>        : ^^^^^^^^^^^^^                                             ^^^^^^^^^^^^   ^^^^^    
 >callbackfn : (value: T, index: number, array: T[]) => void
->           : ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^    
+>           : ^^^^^^^^ ^^^^^^^^^      ^^^^^^^^^   ^^^^^    
 >value : T
 >      : ^
 >index : number
@@ -2286,9 +2286,9 @@ interface Array<T> {
       */
     map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
 >map : <U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any) => U[]
->    : ^^^^^^^^^^^^^^^^        ^                        ^       ^^^^^^^^^^^^^   ^^^^^^  
+>    : ^ ^^^^^^^^^^^^^^                                          ^^^^^^^^^^^^   ^^^^^   
 >callbackfn : (value: T, index: number, array: T[]) => U
->           : ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^^
+>           : ^^^^^^^^ ^^^^^^^^^      ^^^^^^^^^   ^^^^^ 
 >value : T
 >      : ^
 >index : number
@@ -2304,9 +2304,9 @@ interface Array<T> {
       */
     filter(callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
 >filter : (callbackfn: (value: T, index: number, array: T[]) => boolean, thisArg?: any) => T[]
->       : ^^^^^^^^^^^^^        ^                        ^              ^^^^^^^^^^^^   ^^^^^^  
+>       : ^^^^^^^^^^^^^                                                ^^^^^^^^^^^^   ^^^^^   
 >callbackfn : (value: T, index: number, array: T[]) => boolean
->           : ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^       
+>           : ^^^^^^^^ ^^^^^^^^^      ^^^^^^^^^   ^^^^^       
 >value : T
 >      : ^
 >index : number
@@ -2322,9 +2322,9 @@ interface Array<T> {
       */
     reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
 >reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->       : ^^^^^^^^^^^^^^^                ^                ^                               ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^^^^^^^^^^^^^^^                                                                          ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^^
+>           : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^      ^^^^^^^^^   ^^^^^ 
 >previousValue : T
 >              : ^
 >currentValue : T
@@ -2343,9 +2343,9 @@ interface Array<T> {
       */
     reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 >reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                ^                ^                               ^       ^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^                                                                          ^^^^^^^^^^^^^^^^ ^^^ ^^^
 >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^^
+>           : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^      ^^^^^^^^^   ^^^^^ 
 >previousValue : U
 >              : ^
 >currentValue : T
@@ -2364,9 +2364,9 @@ interface Array<T> {
       */
     reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
 >reduceRight : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->            : ^^^^^^^^^^^^^^^                ^                ^                               ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>            : ^^^^^^^^^^^^^^^                                                                          ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^^
+>           : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^      ^^^^^^^^^   ^^^^^ 
 >previousValue : T
 >              : ^
 >currentValue : T
@@ -2385,9 +2385,9 @@ interface Array<T> {
       */
     reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
 >reduceRight : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                ^                ^                               ^       ^^^^^^^^^^^^^^^^^^^^^^^^^
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^                                                                          ^^^^^^^^^^^^^^^^ ^^^ ^^^
 >callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^  ^^^^^^
+>           : ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^      ^^^^^^^^^   ^^^^^ 
 >previousValue : U
 >              : ^
 >currentValue : T
@@ -2412,7 +2412,7 @@ interface Array<T> {
 }
 declare var Array: {
 >Array : { (arrayLength?: number): any[]; <T>(arrayLength: number): T[]; <T_1>(...items: T_1[]): T_1[]; new (arrayLength?: number): any[]; new <T_2>(arrayLength: number): T_2[]; new <T_3>(...items: T_3[]): T_3[]; isArray(arg: any): boolean; prototype: Array<any>; }
->      : ^^^^^^^^^^^^^^^^^      ^^^     ^^^^^^^^^^^^^^^^^^^      ^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^^^^^^     ^^^
+>      : ^^^^^^^^^^^^^^^^^      ^^^     ^^^ ^^^^^^^^^^^^^^^      ^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^     ^^^^^^^   ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^       ^^^^^^^^^^^^^          ^^^
 
     new (arrayLength?: number): any[];
 >arrayLength : number

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndGenericClassStaticFunctionOfTheSameName.types

@@ -15,7 +15,7 @@ class clodule<T> {
 
     static fn<U>(id: U) { }
 >fn : <U>(id: U) => void
->   : ^^^^^^^^^^^^^^^^^^
+>   : ^ ^^^^^^ ^^^^^^^^^
 >id : U
 >   : ^
 }
@@ -27,7 +27,7 @@ module clodule {
     // error: duplicate identifier expected
     export function fn<T>(x: T, y: T): T {
 >fn : <T>(x: T, y: T) => T
->   : ^^^^^^^^^^^^^^^^^^^^
+>   : ^ ^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : T

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedGenericFunctionAndNonGenericClassStaticFunctionOfTheSameName.types

@@ -27,7 +27,7 @@ module clodule {
     // error: duplicate identifier expected
     export function fn<T>(x: T, y: T): T {
 >fn : <T>(x: T, y: T) => T
->   : ^^^^^^^^^^^^^^^^^^^^
+>   : ^ ^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : T

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types

@@ -29,7 +29,7 @@ module clodule {
     // error: duplicate identifier expected
     export function fn<T>(x: T, y: T): number {
 >fn : <T>(x: T, y: T) => number
->   : ^^^^^^^^^^^^^^^^^^^      
+>   : ^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : T

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types

@@ -13,7 +13,7 @@ class Point {
 
     static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246
 >Origin : () => Point
->       : ^^^^^^^^^^^
+>       : ^^^^^^     
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -52,7 +52,7 @@ module A {
 
         static Origin(): Point { return { x: 0, y: 0 }; } // unexpected error here bug 840246
 >Origin : () => Point
->       : ^^^^^^^^^^^
+>       : ^^^^^^     
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -13,7 +13,7 @@ class Point {
 
     static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : () => Point
->       : ^^^^^^^^^^^
+>       : ^^^^^^     
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -54,7 +54,7 @@ module A {
 
         static Origin(): Point { return { x: 0, y: 0 }; }
 >Origin : () => Point
->       : ^^^^^^^^^^^
+>       : ^^^^^^     
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number

tests/baselines/reference/ClassDeclaration25.types

@@ -4,7 +4,7 @@
 interface IList<T> {
     data(): T;
 >data : () => T
->     : ^^^^^^^
+>     : ^^^^^^ 
 
     next(): string;
 >next : () => string
@@ -16,7 +16,7 @@ class List<U> implements IList<U> {
 
     data(): U;
 >data : () => U
->     : ^^^^^^^
+>     : ^^^^^^ 
 
     next(): string;
 >next : () => string

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types

@@ -16,7 +16,7 @@ module A {
 
         fromOrigin(p: Point): number;
 >fromOrigin : (p: Point) => number
->           : ^^^^^^^^^^^^^^      
+>           : ^^^^     ^^^^^      
 >p : Point
 >  : ^^^^^
     }
@@ -33,7 +33,7 @@ module A {
 
         fromOrigin(p: Point) {
 >fromOrigin : (p: Point) => number
->           : ^^^^^^^^^^^^^^^^^^^^
+>           : ^^^^     ^^^^^^^^^^^
 >p : Point
 >  : ^^^^^
 

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -73,7 +73,7 @@ module A {
 
         static fromorigin2d(p: Point): Line<Point>{
 >fromorigin2d : (p: Point) => Line<Point>
->             : ^^^^^^^^^^^^^^^^^^ ^^^^^ 
+>             : ^^^^     ^^^^^           
 >p : Point
 >  : ^^^^^
 

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -31,7 +31,7 @@ module A {
 
     export function fromOrigin(p: Point): Line {
 >fromOrigin : (p: Point) => Line
->           : ^^^^^^^^^^^^^^^^^^
+>           : ^^^^     ^^^^^    
 >p : Point
 >  : ^^^^^
 

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

@@ -31,7 +31,7 @@ module A {
 
     export function fromOrigin(p: Point): Line {
 >fromOrigin : (p: Point) => Line
->           : ^^^^^^^^^^^^^^^^^^
+>           : ^^^^     ^^^^^    
 >p : Point
 >  : ^^^^^
 

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

@@ -31,7 +31,7 @@ module A {
 
     export function fromOrigin(p: Point): Line {
 >fromOrigin : (p: Point) => Line
->           : ^^^^^^^^^^^^^^^^^^
+>           : ^^^^     ^^^^^    
 >p : Point
 >  : ^^^^^
 

tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types

@@ -46,7 +46,7 @@ module A {
 
             static fromOrigin(p: Point) {
 >fromOrigin : (p: Point) => Line
->           : ^^^^^^^^^^^^^^^^^^
+>           : ^^^^     ^^^^^^^^^
 >p : Point
 >  : ^^^^^
 

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInNestedMemberTypeAnnotations.types

@@ -18,11 +18,11 @@ module A {
 
     export var UnitSquare : {
 >UnitSquare : { top: { left: Point; right: Point; }; bottom: { left: Point; right: Point; }; }
->           : ^^^^^^^        ^^^^^         ^^^^^   ^^^^^^^^^^        ^^^^^         ^^^^^   ^^^
+>           : ^^^^^^^                              ^^^^^^^^^^                              ^^^
 
         top: { left: Point, right: Point },
 >top : { left: Point; right: Point; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^     ^^^^^^^^^     ^^^
 >left : Point
 >     : ^^^^^
 >right : Point
@@ -30,7 +30,7 @@ module A {
 
         bottom: { left: Point, right: Point }
 >bottom : { left: Point; right: Point; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^^^^^^^^     ^^^^^^^^^     ^^^
 >left : Point
 >     : ^^^^^
 >right : Point

tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types

@@ -18,7 +18,7 @@ module A {
 
     export function fng<T, U>(s: T): U {
 >fng : <T, U>(s: T) => U
->    : ^^^^^^^^^^^^^^^^^
+>    : ^ ^^ ^^^^^ ^^^^^ 
 >s : T
 >  : ^
 
@@ -38,7 +38,7 @@ module A {
 
     function fng2<T, U>(s: T): U {
 >fng2 : <T, U>(s: T) => U
->     : ^^^^^^^^^^^^^^^^^
+>     : ^ ^^ ^^^^^ ^^^^^ 
 >s : T
 >  : ^
 
@@ -65,7 +65,7 @@ var fn = A.fn;
 
 var fng: <T, U>(s: T) => U;
 >fng : <T, U>(s: T) => U
->    : ^^^^^^^^^^^^^^^^^
+>    : ^ ^^ ^^^^^ ^^^^^ 
 >s : T
 >  : ^
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedClassesOfTheSameName.types

@@ -29,7 +29,7 @@ module A {
 
         fromCarthesian(p: A.Point) {
 >fromCarthesian : (p: A.Point) => { x: number; y: number; }
->               : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>               : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : A.Point
 >  : ^^^^^^^
 >A : any

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types

@@ -13,7 +13,7 @@ module A {
 
         toCarth(): Point;
 >toCarth : () => Point
->        : ^^^^^^^^^^^
+>        : ^^^^^^     
     }
 }
 
@@ -21,20 +21,20 @@ module A {
     interface Point {
         fromCarth(): Point;
 >fromCarth : () => Point
->          : ^^^^^^^^^^^
+>          : ^^^^^^     
     }
 }
 
 // ensure merges as expected
 var p: { x: number; y: number; toCarth(): A.Point; };
 >p : { x: number; y: number; toCarth(): A.Point; }
->  : ^^^^^      ^^^^^      ^^^^^^^^^^^^^^      ^^^
+>  : ^^^^^      ^^^^^      ^^^^^^^^^^^^^       ^^^
 >x : number
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
 >toCarth : () => A.Point
->        : ^^^^^^^      
+>        : ^^^^^^       
 >A : any
 >  : ^^^
 
@@ -79,7 +79,7 @@ module X {
 // ensure merges as expected
 var l: { new (s: A.Point, e: A.Point); }
 >l : new (s: A.Point, e: A.Point) => any
->  : ^^^^^^^^^      ^^^^^^      ^^^^^^^^
+>  : ^^^^^^^^       ^^^^^       ^^^^^^^^
 >s : A.Point
 >  : ^^^^^^^
 >A : any

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types

@@ -21,7 +21,7 @@ module A {
 
         export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 >  : ^
 
@@ -137,7 +137,7 @@ var o = A.Utils.mirror(o);
 
 var p: { tl: A.Point; br: A.Point };
 >p : { tl: A.Point; br: A.Point; }
->  : ^^^^^^^      ^^^^^^^      ^^^
+>  : ^^^^^^       ^^^^^^       ^^^
 >tl : A.Point
 >   : ^^^^^^^
 >A : any

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types

@@ -13,7 +13,7 @@ module A {
 
         toCarth(): Point;
 >toCarth : () => Point
->        : ^^^^^^^^^^^
+>        : ^^^^^^     
     }
 }
 
@@ -21,24 +21,24 @@ module A {
     export interface Point {
         fromCarth(): Point;
 >fromCarth : () => Point
->          : ^^^^^^^^^^^
+>          : ^^^^^^     
     }
 }
 
 // ensure merges as expected
 var p: { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; };
 >p : { x: number; y: number; toCarth(): A.Point; fromCarth(): A.Point; }
->  : ^^^^^      ^^^^^      ^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^      ^^^
+>  : ^^^^^      ^^^^^      ^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^       ^^^
 >x : number
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
 >toCarth : () => A.Point
->        : ^^^^^^^      
+>        : ^^^^^^       
 >A : any
 >  : ^^^
 >fromCarth : () => A.Point
->          : ^^^^^^^      
+>          : ^^^^^^       
 >A : any
 >  : ^^^
 
@@ -83,7 +83,7 @@ module X {
 // ensure merges as expected
 var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.Point); }
 >l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
->  : ^^^^^^^^^^^      ^^^^^^      ^^^^^^^^^^^^^^^^      ^^^^^^^^      ^^^
+>  : ^^^^^^^^^^       ^^^^^       ^^^^^^^^^^^^^^^       ^^^^^^^       ^^^
 >start : A.Point
 >      : ^^^^^^^
 >A : any

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types

@@ -21,7 +21,7 @@ export module A {
 
         export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 >  : ^
 

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types

@@ -25,7 +25,7 @@ module Root {
 
             export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 >  : ^
 

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types

@@ -21,7 +21,7 @@ module A {
 
         export function mirror<T extends Point>(p: T) {
 >mirror : <T extends Point>(p: T) => { x: number; y: number; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>       : ^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : T
 >  : ^
 
@@ -131,7 +131,7 @@ var o = A.Utils.mirror(o);
 
 var p: { tl: A.Point; br: A.Point };
 >p : { tl: A.Point; br: A.Point; }
->  : ^^^^^^^      ^^^^^^^      ^^^
+>  : ^^^^^^       ^^^^^^       ^^^
 >tl : A.Point
 >   : ^^^^^^^
 >A : any

tests/baselines/reference/TypeGuardWithArrayUnion.types

@@ -12,7 +12,7 @@ class Message {
 
 function saySize(message: Message | Message[]) {
 >saySize : (message: Message | Message[]) => number
->        : ^^^^^^^^^^^^^^^^^   ^^^^^^^  ^^^^^^^^^^^
+>        : ^^^^^^^^^^                   ^^^^^^^^^^^
 >message : Message | Message[]
 >        : ^^^^^^^^^^^^^^^^^^^
 

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -13,7 +13,7 @@ enum Color { R, G, B }
 
 function f1(x: Color | string) {
 >f1 : (x: Color | string) => void
->   : ^^^^^^^^^         ^^^^^^^^^
+>   : ^^^^              ^^^^^^^^^
 >x : string | Color
 >  : ^^^^^^^^^^^^^^
 
@@ -52,7 +52,7 @@ function f1(x: Color | string) {
 
 function f2(x: Color | string | string[]) {
 >f2 : (x: Color | string | string[]) => void
->   : ^^^^^^^^^                    ^^^^^^^^^
+>   : ^^^^                         ^^^^^^^^^
 >x : string | Color | string[]
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^
 

tests/baselines/reference/accessorAccidentalCallDiagnostic.types

@@ -14,7 +14,7 @@ class Test24554 {
 }
 function test24554(x: Test24554) {
 >test24554 : (x: Test24554) => any
->          : ^^^^^^^^^^^^^^^^^^^^^
+>          : ^^^^         ^^^^^^^^
 >x : Test24554
 >  : ^^^^^^^^^
 

tests/baselines/reference/accessorsOverrideProperty8.types

@@ -22,7 +22,7 @@ type AnyCtor<P extends object> = new (...a: any[]) => P
 
 declare function classWithProperties<T extends { [key: string]: Types }, P extends object>(properties: T, klass: AnyCtor<P>): {
 >classWithProperties : <T extends { [key: string]: Types; }, P extends object>(properties: T, klass: AnyCtor<P>) => { new (): P & Properties<T>; prototype: P & Properties<T>; }
->                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^          ^   ^^^^^^^^^^ ^              ^   ^^^^^^^^^^ ^    
+>                    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^          ^^^^^                                                            
 >key : string
 >    : ^^^^^^
 >properties : T

tests/baselines/reference/accessorsOverrideProperty9.types

@@ -50,7 +50,7 @@ interface ApiItemContainerMixin extends ApiItem {
 
 function ApiItemContainerMixin<TBaseClass extends IApiItemConstructor>(
 >ApiItemContainerMixin : <TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass) => TBaseClass & (new (...args: any[]) => ApiItemContainerMixin)
->                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                            ^^^^^^^^^^^^^^^^^^^^^ 
+>                      : ^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^^^                                                            
 
   baseClass: TBaseClass
 >baseClass : TBaseClass

tests/baselines/reference/additionOperatorWithConstrainedTypeParameter.types

@@ -4,7 +4,7 @@
 // test for #17069
 function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k: K) {
 >sum : <T extends Record<K, number>, K extends string>(n: number, v: T, k: K) => void
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^ ^^^^^ ^^^^^^^^^
 >n : number
 >  : ^^^^^^
 >v : T
@@ -42,7 +42,7 @@ function sum<T extends Record<K, number>, K extends string>(n: number, v: T, k:
 }
 function realSum<T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) {
 >realSum : <T extends Record<K, number>, K extends string>(n: number, vs: T[], k: K) => void
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^  ^^^^^^^^^^^^^^^
+>        : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^      ^^^^^^   ^^^^^ ^^^^^^^^^
 >n : number
 >  : ^^^^^^
 >vs : T[]

tests/baselines/reference/additionOperatorWithTypeParameter.types

@@ -12,7 +12,7 @@ enum E { a, b }
 
 function foo<T, U>(t: T, u: U) {
 >foo : <T, U>(t: T, u: U) => void
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^ ^^^^^ ^^^^^ ^^^^^^^^^
 >t : T
 >  : ^
 >u : U

tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash1.types

@@ -12,7 +12,7 @@ class ErrImpl<E> {
 
 declare const Err: typeof ErrImpl & (<T>() => T);
 >Err : typeof ErrImpl & (<T>() => T)
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^
 >ErrImpl : typeof ErrImpl
 >        : ^^^^^^^^^^^^^^
 

tests/baselines/reference/aliasInstantiationExpressionGenericIntersectionNoCrash2.types

@@ -12,18 +12,18 @@ declare class Class<T> {
 
 declare function fn<T>(): T;
 >fn : <T>() => T
->   : ^^^^^^^^^^
+>   : ^ ^^^^^^^ 
 
 
 type ClassAlias<T> = typeof Class<T>;
 >ClassAlias : typeof Class<T>
->           :        ^^^^^ ^ 
+>           :                
 >Class : typeof Class
 >      : ^^^^^^^^^^^^
 
 type FnAlias<T> = typeof fn<T>;
 >FnAlias : typeof fn<T>
->        :        ^^ ^ 
+>        :             
 >fn : <T_1>() => T_1
 >   : ^^^^^^^^^^^^^^
 

tests/baselines/reference/aliasOfGenericFunctionWithRestBehavedSameAsUnaliased.types

@@ -66,11 +66,11 @@ let check1: test1 = "y";
 
 type ExtendedMapper2<HandledInputT, OutputT, ArgsT extends any[]> = (
 >ExtendedMapper2 : (name: string, mixed: HandledInputT, ...args: ArgsT) => OutputT
->                : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                : ^^^^^^^      ^^^^^^^^^             ^^^^^^^^^^^     ^^^^^       
 
     {x:(name : string, mixed : HandledInputT, ...args : ArgsT) => OutputT}["x"]
 >x : (name: string, mixed: HandledInputT, ...args: ArgsT) => OutputT
->  : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^      ^^^^^^^^^             ^^^^^^^^^^^     ^^^^^       
 >name : string
 >     : ^^^^^^
 >mixed : HandledInputT

tests/baselines/reference/aliasOnMergedModuleInterface.types

@@ -50,7 +50,7 @@ declare module "foo"
     interface B {
         bar(name: string): B.A;
 >bar : (name: string) => B.A
->    : ^^^^^^^      ^^^^^^  
+>    : ^^^^^^^      ^^^^^   
 >name : string
 >     : ^^^^^^
 >B : any

tests/baselines/reference/aliasUsageInFunctionExpression.types

@@ -22,9 +22,9 @@ interface IHasVisualizationModel {
 }
 var f = (x: IHasVisualizationModel) => x;
 >f : (x: IHasVisualizationModel) => IHasVisualizationModel
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(x: IHasVisualizationModel) => x : (x: IHasVisualizationModel) => IHasVisualizationModel
->                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                 : ^^^^                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >x : IHasVisualizationModel

tests/baselines/reference/aliasUsageInGenericFunction.types

@@ -22,7 +22,7 @@ interface IHasVisualizationModel {
 }
 function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 >foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^                      ^^^^^^^^ ^^^^^^
 >a : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >x : T
@@ -48,13 +48,13 @@ var r = foo({ a: moduleA });
 
 var r2 = foo({ a: <IHasVisualizationModel>null });
 >r2 : { a: IHasVisualizationModel; }
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^^^^^                      ^^^
 >foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
->                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                         : ^^^^^                      ^^^
 >foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
 >    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
->                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                    : ^^^^^                      ^^^
 >a : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 ><IHasVisualizationModel>null : IHasVisualizationModel

tests/baselines/reference/aliasUsageInObjectLiteral.types

@@ -22,7 +22,7 @@ interface IHasVisualizationModel {
 }
 var a: { x: typeof moduleA } = { x: moduleA };
 >a : { x: typeof moduleA; }
->  : ^^^^^       ^^^^^^^^^^
+>  : ^^^^^              ^^^
 >x : typeof moduleA
 >  : ^^^^^^^^^^^^^^
 >moduleA : typeof moduleA
@@ -36,7 +36,7 @@ var a: { x: typeof moduleA } = { x: moduleA };
 
 var b: { x: IHasVisualizationModel } = { x: moduleA };
 >b : { x: IHasVisualizationModel; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^                      ^^^
 >x : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >{ x: moduleA } : { x: typeof moduleA; }
@@ -48,9 +48,9 @@ var b: { x: IHasVisualizationModel } = { x: moduleA };
 
 var c: { y: { z: IHasVisualizationModel } } = { y: { z: moduleA } };
 >c : { y: { z: IHasVisualizationModel; }; }
->  : ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^   ^^^
+>  : ^^^^^                              ^^^
 >y : { z: IHasVisualizationModel; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^                      ^^^
 >z : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >{ y: { z: moduleA } } : { y: { z: typeof moduleA; }; }

tests/baselines/reference/aliasUsageInOrExpression.types

@@ -56,13 +56,13 @@ var d2: IHasVisualizationModel = moduleA || i;
 
 var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || { x: moduleA };
 >e : { x: IHasVisualizationModel; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^                      ^^^
 >x : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 ><{ x: IHasVisualizationModel }>null || { x: moduleA } : { x: IHasVisualizationModel; }
->                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                      : ^^^^^                      ^^^
 ><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
->                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                    : ^^^^^                      ^^^
 >x : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >{ x: moduleA } : { x: typeof moduleA; }
@@ -74,13 +74,13 @@ var e: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null || {
 
 var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x: moduleA } : null;
 >f : { x: IHasVisualizationModel; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^                      ^^^
 >x : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 ><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: typeof moduleA; }
 >                                                            : ^^^^^^^^^^^^^^^^^^^^^^
 ><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
->                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                    : ^^^^^                      ^^^
 >x : IHasVisualizationModel
 >  : ^^^^^^^^^^^^^^^^^^^^^^
 >{ x: moduleA } : { x: typeof moduleA; }

tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.types

@@ -14,7 +14,7 @@ type WatchHandler<T> = (val: T) => void;
 
 declare function extend(options: ComponentOptions<{}>): void;
 >extend : (options: ComponentOptions<{}>) => void
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^    
+>       : ^^^^^^^^^^                    ^^^^^    
 >options : ComponentOptions<{}>
 >        : ^^^^^^^^^^^^^^^^^^^^
 

tests/baselines/reference/allowSyntheticDefaultImportsCanPaintCrossModuleDeclaration.types

@@ -17,7 +17,7 @@ import Color from "./color";
 
 export declare function styled(): Color;
 >styled : () => Color
->       : ^^^^^^^^^^^
+>       : ^^^^^^     
 
 === file2.ts ===
 import { styled }  from "./file1";

tests/baselines/reference/ambientConstLiterals.types

@@ -3,7 +3,7 @@
 === ambientConstLiterals.ts ===
 function f<T>(x: T): T {
 >f : <T>(x: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 

tests/baselines/reference/ambientDeclarations.types

@@ -72,7 +72,7 @@ declare function fn9(...q: {}[]);
 
 declare function fn10<T>(...q: T[]);
 >fn10 : <T>(...q: T[]) => any
->     : ^^^^^^^^^^^  ^^^^^^^^
+>     : ^ ^^^^^^^^   ^^^^^^^^
 >q : T[]
 >  : ^^^
 
@@ -84,7 +84,7 @@ declare class cls {
     constructor();
     method(): cls;
 >method : () => cls
->       : ^^^^^^^^^
+>       : ^^^^^^   
 
     static static(p): number;
 >static : (p: any) => number

tests/baselines/reference/ambiguousGenericAssertion1.types

@@ -3,15 +3,15 @@
 === ambiguousGenericAssertion1.ts ===
 function f<T>(x: T): T { return null; }
 >f : <T>(x: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 
 var r = <T>(x: T) => x;
 >r : <T>(x: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^^
 ><T>(x: T) => x : <T>(x: T) => T
->               : ^^^^^^^^^^^^^^
+>               : ^ ^^^^^ ^^^^^^
 >x : T
 >  : ^
 >x : T
@@ -19,9 +19,9 @@ var r = <T>(x: T) => x;
 
 var r2 = < <T>(x: T) => T>f; // valid
 >r2 : <T>(x: T) => T
->   : ^^^^^^^^^^^^^^
+>   : ^ ^^^^^ ^^^^^ 
 >< <T>(x: T) => T>f : <T>(x: T) => T
->                   : ^^^^^^^^^^^^^^
+>                   : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >f : <T>(x: T) => T

tests/baselines/reference/ambiguousOverloadResolution.types

@@ -15,7 +15,7 @@ class B extends A { x: number; }
 
 declare function f(p: A, q: B): number;
 >f : { (p: A, q: B): number; (p: B, q: A): string; }
->  : ^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^
 >p : A
 >  : ^
 >q : B
@@ -23,7 +23,7 @@ declare function f(p: A, q: B): number;
 
 declare function f(p: B, q: A): string;
 >f : { (p: A, q: B): number; (p: B, q: A): string; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^      ^^^
 >p : B
 >  : ^
 >q : A

tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.types

@@ -30,7 +30,7 @@ export type Constructor<T> = {
 }
 export function Configurable<T extends Constructor<{}>>(base: T): T {
 >Configurable : <T extends Constructor<{}>>(base: T) => T
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>             : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >base : T
 >     : ^
 

tests/baselines/reference/amdLikeInputDeclarationEmit.types

@@ -3,13 +3,13 @@
 === typing.d.ts ===
 declare function define<T=unknown>(name: string, modules: string[], ready: (...modules: unknown[]) => T);
 >define : <T = unknown>(name: string, modules: string[], ready: (...modules: unknown[]) => T) => any
->       : ^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^        ^^^^^^^^^                           ^^^^^^^^^
+>       : ^ ^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^        ^^^^^^^^^                            ^^^^^^^^
 >name : string
 >     : ^^^^^^
 >modules : string[]
 >        : ^^^^^^^^
 >ready : (...modules: unknown[]) => T
->      : ^^^^^^^^^^^^^         ^^^^^^
+>      : ^^^^^^^^^^^^^         ^^^^^ 
 >modules : unknown[]
 >        : ^^^^^^^^^
 
@@ -24,7 +24,7 @@ declare module "deps/BaseClass" {
 
         static extends<A>(a: A): new () => A & BaseClass;
 >extends : <A>(a: A) => new () => A & BaseClass
->        : ^^^^^^^^^^^^^          ^   ^^^^^^^^^
+>        : ^ ^^^^^ ^^^^^                       
 >a : A
 >  : ^
     }

tests/baselines/reference/anonClassDeclarationEmitIsAnon.types

@@ -30,7 +30,7 @@ export type Constructor<T = {}> = new (...args: any[]) => T;
 
 export function Timestamped<TBase extends Constructor>(Base: TBase) {
 >Timestamped : <TBase extends Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>            : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >Base : TBase
 >     : ^^^^^
 

tests/baselines/reference/anyAssignabilityInInheritance.types

@@ -71,7 +71,7 @@ var r3 = foo3(a); // any
 
 declare function foo5(x: Date): Date;
 >foo5 : { (x: Date): Date; (x: any): any; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^^^^^^    ^^^    ^^^^^^^^^^^^^^^^^^
 >x : Date
 >  : ^^^^
 
@@ -89,7 +89,7 @@ var r3 = foo3(a); // any
 
 declare function foo6(x: RegExp): RegExp;
 >foo6 : { (x: RegExp): RegExp; (x: any): any; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^^^^^^      ^^^      ^^^^^^^^^^^^^^^^^^
 >x : RegExp
 >  : ^^^^^^
 
@@ -151,7 +151,7 @@ interface I8 { foo: string }
 
 declare function foo9(x: I8): I8;
 >foo9 : { (x: I8): I8; (x: any): any; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^^^^^^  ^^^  ^^^^^^^^^^^^^^^^^^
 >x : I8
 >  : ^^
 
@@ -175,7 +175,7 @@ class A { foo: number; }
 
 declare function foo10(x: A): A;
 >foo10 : { (x: A): A; (x: any): any; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^
 >x : A
 >  : ^
 
@@ -199,7 +199,7 @@ class A2<T> { foo: T; }
 
 declare function foo11(x: A2<string>): A2<string>;
 >foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
->      : ^^^^^^^^        ^^^^^        ^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^          ^^^          ^^^^^^^^^^^^^^^^^^
 >x : A2<string>
 >  : ^^^^^^^^^^
 
@@ -237,9 +237,9 @@ var r3 = foo3(a); // any
 
 declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
 >foo13 : { (x: <T>(x: T) => T): <T_1>(x: T_1) => T_1; (x: any): any; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^^ ^^^^^ ^^^^^ ^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : <T>(x: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >x : T
@@ -265,7 +265,7 @@ enum E { A }
 
 declare function foo14(x: E): E;
 >foo14 : { (x: E): E; (x: any): any; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^
 >x : E
 >  : ^
 
@@ -297,7 +297,7 @@ module f {
 }
 declare function foo15(x: typeof f): typeof f;
 >foo15 : { (x: typeof f): typeof f; (x: any): any; }
->      : ^^^^^^       ^^^^       ^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^        ^^^        ^^^^^^^^^^^^^^^^^^
 >x : typeof f
 >  : ^^^^^^^^
 >f : typeof f
@@ -335,7 +335,7 @@ module CC {
 }
 declare function foo16(x: CC): CC;
 >foo16 : { (x: CC): CC; (x: any): any; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^  ^^^  ^^^^^^^^^^^^^^^^^^
 >x : CC
 >  : ^^
 
@@ -353,7 +353,7 @@ var r3 = foo3(a); // any
 
 declare function foo17(x: Object): Object;
 >foo17 : { (x: Object): Object; (x: any): any; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^      ^^^      ^^^^^^^^^^^^^^^^^^
 >x : Object
 >  : ^^^^^^
 

tests/baselines/reference/anyAssignableToEveryType.types

@@ -123,7 +123,7 @@ var n: { foo: string } = a;
 
 var o: <T>(x: T) => T = a;
 >o : <T>(x: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >a : any
@@ -140,7 +140,7 @@ var q: String = a;
 
 function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
 >foo : <T, U, V extends Date>(x: T, y: U, z: V) => void
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^ ^^^^^^^^^
 >x : T
 >  : ^
 >y : U

tests/baselines/reference/argumentsAsPropertyName.types

@@ -18,7 +18,7 @@ declare function use(s: any);
 
 function myFunction(myType: MyType) {
 >myFunction : (myType: MyType) => void
->           : ^^^^^^^^^^^^^^^^^^^^^^^^
+>           : ^^^^^^^^^      ^^^^^^^^^
 >myType : MyType
 >       : ^^^^^^
 

tests/baselines/reference/argumentsSpreadRestIterables(target=es5).types

@@ -59,7 +59,7 @@ declare const itNum: Iterable<number>
 
 declare function fn1<const T extends readonly unknown[]>(...args: T): T;
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 
@@ -118,7 +118,7 @@ const res4 = fn1(true, ...itNum);
 // repro from #52781
 declare function foo<T extends unknown[]>(...args: T): T;
 >foo : <T extends unknown[]>(...args: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 

tests/baselines/reference/argumentsSpreadRestIterables(target=esnext).types

@@ -59,7 +59,7 @@ declare const itNum: Iterable<number>
 
 declare function fn1<const T extends readonly unknown[]>(...args: T): T;
 >fn1 : <const T extends readonly unknown[]>(...args: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 
@@ -118,7 +118,7 @@ const res4 = fn1(true, ...itNum);
 // repro from #52781
 declare function foo<T extends unknown[]>(...args: T): T;
 >foo : <T extends unknown[]>(...args: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 

tests/baselines/reference/arithmeticOnInvalidTypes2.types

@@ -3,11 +3,11 @@
 === arithmeticOnInvalidTypes2.ts ===
 var obj = function f<T>(a: T, b: T) {
 >obj : <T>(a: T, b: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^ ^^^^^ ^^^^^^
 >function f<T>(a: T, b: T) {    var z1 = a + b;    var z2 = a - b;    var z3 = a * b;    var z4 = a / b;    return a;} : <T>(a: T, b: T) => T
->                                                                                                                      : ^^^^^^^^^^^^^^^^^^^^
+>                                                                                                                      : ^ ^^^^^ ^^^^^ ^^^^^^
 >f : <T>(a: T, b: T) => T
->  : ^^^^^^^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^ ^^^^^^
 >a : T
 >  : ^
 >b : T

tests/baselines/reference/arithmeticOperatorWithTypeParameter.types

@@ -4,7 +4,7 @@
 // type parameter type is not valid for arithmetic operand
 function foo<T>(t: T) {
 >foo : <T>(t: T) => void
->    : ^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^ ^^^^^^^^^
 >t : T
 >  : ^
 

tests/baselines/reference/arrayAssignmentTest1.types

@@ -17,7 +17,7 @@ class C1 implements I1 {
 
 	C1M1():C1[] {return null;}
 >C1M1 : () => C1[]
->     : ^^^^^^^^  
+>     : ^^^^^^    
  }
 class C2 extends C1 {
 >C2 : C2
@@ -27,7 +27,7 @@ class C2 extends C1 {
 
     C2M1():C2[] { return null;}
 >C2M1 : () => C2[]
->     : ^^^^^^^^  
+>     : ^^^^^^    
 }
 
 class C3 {

tests/baselines/reference/arrayAssignmentTest2.types

@@ -17,7 +17,7 @@ class C1 implements I1 {
 
 	C1M1():C1[] {return null;}
 >C1M1 : () => C1[]
->     : ^^^^^^^^  
+>     : ^^^^^^    
  }
 class C2 extends C1 {
 >C2 : C2
@@ -27,7 +27,7 @@ class C2 extends C1 {
 
 	C2M1():C2[] { return null;}
 >C2M1 : () => C2[]
->     : ^^^^^^^^  
+>     : ^^^^^^    
 }
 
 class C3 {

tests/baselines/reference/arrayAssignmentTest5.types

@@ -31,7 +31,7 @@ module Test {
     interface IMode {
         onEnter(line:string, state:IState, offset:number):IAction;
 >onEnter : (line: string, state: IState, offset: number) => IAction
->        : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^
+>        : ^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^      ^^^^^       
 >line : string
 >     : ^^^^^^
 >state : IState
@@ -41,7 +41,7 @@ module Test {
 
         tokenize(line:string, state:IState, includeStates:boolean):ILineTokens;
 >tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
->         : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^
+>         : ^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^^^^^^^^       ^^^^^           
 >line : string
 >     : ^^^^^^
 >state : IState
@@ -55,7 +55,7 @@ module Test {
 
         public onEnter(line:string, state:IState, offset:number):IAction {
 >onEnter : (line: string, state: IState, offset: number) => IAction
->        : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^
+>        : ^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^      ^^^^^       
 >line : string
 >     : ^^^^^^
 >state : IState
@@ -122,7 +122,7 @@ module Test {
         }
         public tokenize(line:string, state:IState, includeStates:boolean):ILineTokens {
 >tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
->         : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^
+>         : ^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^^^^^^^^       ^^^^^           
 >line : string
 >     : ^^^^^^
 >state : IState

tests/baselines/reference/arrayAssignmentTest6.types

@@ -24,7 +24,7 @@ module Test {
     interface IMode {
         tokenize(line:string, state:IState, includeStates:boolean):ILineTokens;
 >tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
->         : ^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^
+>         : ^^^^^^^      ^^^^^^^^^      ^^^^^^^^^^^^^^^^^       ^^^^^           
 >line : string
 >     : ^^^^^^
 >state : IState
@@ -38,7 +38,7 @@ module Test {
 
         public tokenize(line:string, tokens:IToken[], includeStates:boolean):ILineTokens {
 >tokenize : (line: string, tokens: IToken[], includeStates: boolean) => ILineTokens
->         : ^^^^^^^      ^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^
+>         : ^^^^^^^      ^^^^^^^^^^        ^^^^^^^^^^^^^^^^^       ^^^^^           
 >line : string
 >     : ^^^^^^
 >tokens : IToken[]

tests/baselines/reference/arrayAugment.types

@@ -4,7 +4,7 @@
 interface Array<T> {
     split: (parts: number) => T[][];
 >split : (parts: number) => T[][]
->      : ^^^^^^^^      ^^^^^^    
+>      : ^^^^^^^^      ^^^^^     
 >parts : number
 >      : ^^^^^^
 }

tests/baselines/reference/arrayBestCommonTypes.types

@@ -393,7 +393,7 @@ module EmptyTypes {
 
             var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
 >t1 : { x: number; y: base; }[]
->   : ^^^^^      ^^^^^^^^^^^^^^
+>   : ^^^^^      ^^^^^    ^^^^^
 >x : number
 >  : ^^^^^^
 >y : base
@@ -427,7 +427,7 @@ module EmptyTypes {
 
             var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
 >t2 : { x: boolean; y: base; }[]
->   : ^^^^^       ^^^^^^^^^^^^^^
+>   : ^^^^^       ^^^^^    ^^^^^
 >x : boolean
 >  : ^^^^^^^
 >y : base
@@ -461,7 +461,7 @@ module EmptyTypes {
 
             var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
 >t3 : { x: string; y: base; }[]
->   : ^^^^^      ^^^^^^^^^^^^^^
+>   : ^^^^^      ^^^^^    ^^^^^
 >x : string
 >  : ^^^^^^
 >y : base
@@ -1075,7 +1075,7 @@ module NonEmptyTypes {
 
             var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
 >t1 : { x: number; y: base; }[]
->   : ^^^^^      ^^^^^^^^^^^^^^
+>   : ^^^^^      ^^^^^    ^^^^^
 >x : number
 >  : ^^^^^^
 >y : base
@@ -1109,7 +1109,7 @@ module NonEmptyTypes {
 
             var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
 >t2 : { x: boolean; y: base; }[]
->   : ^^^^^       ^^^^^^^^^^^^^^
+>   : ^^^^^       ^^^^^    ^^^^^
 >x : boolean
 >  : ^^^^^^^
 >y : base
@@ -1143,7 +1143,7 @@ module NonEmptyTypes {
 
             var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
 >t3 : { x: string; y: base; }[]
->   : ^^^^^      ^^^^^^^^^^^^^^
+>   : ^^^^^      ^^^^^    ^^^^^
 >x : string
 >  : ^^^^^^
 >y : base

tests/baselines/reference/arrayConcat3.types

@@ -10,7 +10,7 @@ type Fn<T extends object> = <U extends T>(subj: U) => U
 
 function doStuff<T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1>>) {
 >doStuff : <T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1>>) => void
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^  ^^^^^^^^^^ ^^ ^^  ^^^^^^^^^
+>        : ^ ^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^            ^^^^^             ^^^^^^^^^
 >a : Fn<T>[]
 >  : ^^^^^^^
 >b : Fn<T1>[]

tests/baselines/reference/arrayDestructuringInSwitch1.types

@@ -11,7 +11,7 @@ export type BooleanLogicExpression = ['and', ...Expression[]] | ['not', Expressi
 
 export function evaluate(expression: Expression): boolean {
 >evaluate : (expression: Expression) => boolean
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^       
+>         : ^^^^^^^^^^^^^          ^^^^^       
 >expression : Expression
 >           : ^^^^^^^^^^
 

tests/baselines/reference/arrayDestructuringInSwitch2.types

@@ -15,7 +15,7 @@ type X = { kind: "a", a: [1] } | { kind: "b", a: [] }
 
 function foo(x: X): 1 {
 >foo : (x: X) => 1
->    : ^^^^^^^^^^ 
+>    : ^^^^ ^^^^^ 
 >x : X
 >  : ^
 

tests/baselines/reference/arrayFlatMap.types

@@ -23,7 +23,7 @@ array.flatMap((): ReadonlyArray<number> => []); // ok
 >flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
->                                : ^^^^^^^^^^^^^^^^^^^        
+>                                : ^^^^^^                     
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
@@ -37,7 +37,7 @@ readonlyArray.flatMap((): ReadonlyArray<number> => []); // ok
 >flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
 >        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
->                                : ^^^^^^^^^^^^^^^^^^^        
+>                                : ^^^^^^                     
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 

tests/baselines/reference/arrayFlatNoCrashInference.types

@@ -3,7 +3,7 @@
 === arrayFlatNoCrashInference.ts ===
 function foo<T>(arr: T[], depth: number) {
 >foo : <T>(arr: T[], depth: number) => FlatArray<T, 0 | 1 | -1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[]
->    : ^^^^^^^^^^  ^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^   ^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : T[]
 >    : ^^^
 >depth : number

tests/baselines/reference/arrayFlatNoCrashInferenceDeclarations.types

@@ -3,7 +3,7 @@
 === arrayFlatNoCrashInferenceDeclarations.ts ===
 function foo<T>(arr: T[], depth: number) {
 >foo : <T>(arr: T[], depth: number) => FlatArray<T, 0 | 1 | -1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20>[]
->    : ^^^^^^^^^^  ^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^   ^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >arr : T[]
 >    : ^^^
 >depth : number

tests/baselines/reference/arrayFrom.types

@@ -126,7 +126,7 @@ const result4: A[] = Array.from(inputB, ({ b }): A => ({ a: b }));
 >inputB : B[]
 >       : ^^^
 >({ b }): A => ({ a: b }) : ({ b }: B) => A
->                         : ^^^^^^^^^^^^^^^
+>                         : ^^^^^^^^^^^^^^ 
 >b : string
 >  : ^^^^^^
 >({ a: b }) : { a: string; }
@@ -180,7 +180,7 @@ const result7: B[] = Array.from(inputALike, ({ a }): B => ({ b: a }));
 >inputALike : ArrayLike<A>
 >           : ^^^^^^^^^^^^
 >({ a }): B => ({ b: a }) : ({ a }: A) => B
->                         : ^^^^^^^^^^^^^^^
+>                         : ^^^^^^^^^^^^^^ 
 >a : string
 >  : ^^^^^^
 >({ b: a }) : { b: string; }
@@ -220,7 +220,7 @@ const result9: B[] = Array.from(inputARand, ({ a }): B => ({ b: a }));
 >inputARand : ArrayLike<A> | Iterable<A>
 >           : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({ a }): B => ({ b: a }) : ({ a }: A) => B
->                         : ^^^^^^^^^^^^^^^
+>                         : ^^^^^^^^^^^^^^ 
 >a : string
 >  : ^^^^^^
 >({ b: a }) : { b: string; }
@@ -262,7 +262,7 @@ const result11: B[] = Array.from(inputASet, ({ a }): B => ({ b: a }));
 >inputASet : Set<A>
 >          : ^^^^^^
 >({ a }): B => ({ b: a }) : ({ a }: A) => B
->                         : ^^^^^^^^^^^^^^^
+>                         : ^^^^^^^^^^^^^^ 
 >a : string
 >  : ^^^^^^
 >({ b: a }) : { b: string; }
@@ -279,7 +279,7 @@ const result11: B[] = Array.from(inputASet, ({ a }): B => ({ b: a }));
 // even when the type is written as : Iterable<T>|ArrayLike<T>
 function getEither<T> (in1: Iterable<T>, in2: ArrayLike<T>) {
 >getEither : <T>(in1: Iterable<T>, in2: ArrayLike<T>) => ArrayLike<T> | Iterable<T>
->          : ^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>          : ^ ^^^^^^^           ^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >in1 : Iterable<T>
 >    : ^^^^^^^^^^^
 >in2 : ArrayLike<T>

tests/baselines/reference/arrayLiteralContextualType.types

@@ -43,13 +43,13 @@ class Elephant {
 
 function foo(animals: IAnimal[]) { }
 >foo : (animals: IAnimal[]) => void
->    : ^^^^^^^^^^^^^^^^^  ^^^^^^^^^
+>    : ^^^^^^^^^^         ^^^^^^^^^
 >animals : IAnimal[]
 >        : ^^^^^^^^^
 
 function bar(animals: { [n: number]: IAnimal }) { }
 >bar : (animals: { [n: number]: IAnimal; }) => void
->    : ^^^^^^^^^^               ^^^^^^^   ^^^^^^^^^
+>    : ^^^^^^^^^^                         ^^^^^^^^^
 >animals : { [n: number]: IAnimal; }
 >        : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >n : number

tests/baselines/reference/arrayLiteralInference.types

@@ -181,7 +181,7 @@ const appTypeStylesWithError: Map<AppType, Array<AppStyle>> = new Map([
 
 declare function foo<T>(...args: T[]): T[];
 >foo : <T>(...args: T[]) => T[]
->    : ^^^^^^^^^^^^^^  ^^^^^^  
+>    : ^ ^^^^^^^^^^^   ^^^^^   
 >args : T[]
 >     : ^^^
 

tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types

@@ -61,11 +61,11 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >ds : ((x: Object) => number)[]
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^^^^^      ^^^^^^^^^^^^^^
 >[(x: Object) => 1, (x: string) => 2] : ((x: Object) => number)[]
->                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                     : ^^^^^      ^^^^^^^^^^^^^^
 >(x: Object) => 1 : (x: Object) => number
->                 : ^^^^^^^^^^^^^^^^^^^^^
+>                 : ^^^^      ^^^^^^^^^^^
 >x : Object
 >  : ^^^^^^
 >1 : 1
@@ -89,7 +89,7 @@ var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >2 : 2
 >  : ^
 >(x: Object) => 1 : (x: Object) => number
->                 : ^^^^^^^^^^^^^^^^^^^^^
+>                 : ^^^^      ^^^^^^^^^^^
 >x : Object
 >  : ^^^^^^
 >1 : 1

tests/baselines/reference/arrayOfExportedClass.types

@@ -16,7 +16,7 @@ class Road {
 
     public AddCars(cars: Car[]) {
 >AddCars : (cars: Car[]) => void
->        : ^^^^^^^^^^  ^^^^^^^^^
+>        : ^^^^^^^     ^^^^^^^^^
 >cars : Car[]
 >     : ^^^^^
 

tests/baselines/reference/arrayOfFunctionTypes3.types

@@ -122,7 +122,7 @@ var r5b = r4(1);
 
 var a2: { <T>(x: T): number; (x: string): string;};
 >a2 : { <T>(x: T): number; (x: string): string; }
->   : ^^^^^^^^^^^^^      ^^^^^^      ^^^      ^^^
+>   : ^^^ ^^^^^ ^^^      ^^^^^^      ^^^      ^^^
 >x : T
 >  : ^
 >x : string
@@ -130,7 +130,7 @@ var a2: { <T>(x: T): number; (x: string): string;};
 
 var b2: { <T>(x: T): number; (x: string): string; };
 >b2 : { <T>(x: T): number; (x: string): string; }
->   : ^^^^^^^^^^^^^      ^^^^^^      ^^^      ^^^
+>   : ^^^ ^^^^^ ^^^      ^^^^^^      ^^^      ^^^
 >x : T
 >  : ^
 >x : string
@@ -138,7 +138,7 @@ var b2: { <T>(x: T): number; (x: string): string; };
 
 var c2: { (x: number): number; <T>(x: T): any; };
 >c2 : { (x: number): number; <T>(x: T): any; }
->   : ^^^^^^      ^^^      ^^^^^^^^^^^^^   ^^^
+>   : ^^^^^^      ^^^      ^^^ ^^^^^ ^^^   ^^^
 >x : number
 >  : ^^^^^^
 >x : T

tests/baselines/reference/arraySpreadInCall.types

@@ -185,7 +185,7 @@ f1(...(([1, 2])), ...(((([3, 4])))), ...([5, 6]));
 
 declare function f2<T extends unknown[]>(...args: T): T;
 >f2 : <T extends unknown[]>(...args: T) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 
@@ -263,7 +263,7 @@ const x24 = f2(true, ...([1, 'foo']))
 
 declare function f3<T extends readonly unknown[]>(...args: T): T;
 >f3 : <T extends readonly unknown[]>(...args: T) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 
@@ -341,7 +341,7 @@ const x34 = f3(true, ...([1, 'foo']))
 
 declare function f4<const T extends readonly unknown[]>(...args: T): T;
 >f4 : <const T extends readonly unknown[]>(...args: T) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >args : T
 >     : ^
 

tests/baselines/reference/arrayTypeInSignatureOfInterfaceAndClass.types

@@ -11,13 +11,13 @@ declare module WinJS {
 
         then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>;
 >then : <U>(success?: (value: T) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void) => Promise<U>
->     : ^^^^^^^^^^^^^^        ^     ^^^^^^^ ^ ^^^^^^^^^^                ^^^^^^^ ^ ^^^^^^^^^^^^^                       ^^^^^^^^^^^^ ^ 
+>     : ^ ^^^^^^^^^^^^                        ^^^^^^^^^^                          ^^^^^^^^^^^^^                       ^^^^^          
 >success : (value: T) => Promise<U>
->        : ^^^^^^^^^^^^^^^^^^^^^ ^ 
+>        : ^^^^^^^^ ^^^^^          
 >value : T
 >      : ^
 >error : (error: any) => Promise<U>
->      : ^^^^^^^^   ^^^^^^^^^^^^ ^ 
+>      : ^^^^^^^^   ^^^^^          
 >error : any
 >progress : (progress: any) => void
 >         : ^^^^^^^^^^^   ^^^^^    
@@ -63,7 +63,7 @@ declare module Data {
         //removeIndices: WinJS.Promise<IListItem<T>[]>;
         removeIndices(indices: number[], options?: any): WinJS.Promise<IListItem<T>[]>;
 >removeIndices : (indices: number[], options?: any) => WinJS.Promise<IListItem<T>[]>
->              : ^^^^^^^^^^        ^^^^^^^^^^^^   ^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^ ^    
+>              : ^^^^^^^^^^        ^^^^^^^^^^^^   ^^^^^                             
 >indices : number[]
 >        : ^^^^^^^^
 >options : any
@@ -77,7 +77,7 @@ declare module Data {
         //removeIndices: WinJS.Promise<IListItem<T>[]>;
         public removeIndices(indices: number[], options?: any): WinJS.Promise<IListItem<T>[]>;
 >removeIndices : (indices: number[], options?: any) => WinJS.Promise<IListItem<T>[]>
->              : ^^^^^^^^^^        ^^^^^^^^^^^^   ^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^ ^    
+>              : ^^^^^^^^^^        ^^^^^^^^^^^^   ^^^^^                             
 >indices : number[]
 >        : ^^^^^^^^
 >options : any

tests/baselines/reference/arrayTypeOfTypeOf.types

@@ -23,13 +23,13 @@ var xs2: typeof Array;
 
 var xs3: typeof Array<number>;
 >xs3 : typeof Array<number>
->    :        ^^^^^        
+>    :                     
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
 
 var xs4: typeof Array<typeof x>;
 >xs4 : typeof Array<typeof x>
->    :        ^^^^^        ^ 
+>    :                       
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
 >x : number

tests/baselines/reference/arrowFunctionContexts.types

@@ -307,9 +307,9 @@ module M2 {
 // <Identifier>(ParamList) => { ... } is a generic arrow function
 var generic1 = <T>(n: T) => [n];
 >generic1 : <T>(n: T) => T[]
->         : ^^^^^^^^^^^^^^^^
+>         : ^ ^^^^^ ^^^^^^^^
 ><T>(n: T) => [n] : <T>(n: T) => T[]
->                 : ^^^^^^^^^^^^^^^^
+>                 : ^ ^^^^^ ^^^^^^^^
 >n : T
 >  : ^
 >[n] : T[]
@@ -325,9 +325,9 @@ var generic1: { <T>(n: T): T[] }; // Incorrect error, Bug 829597
 
 var generic2 = <T>(n: T) => { return [n]; };
 >generic2 : <T>(n: T) => T[]
->         : ^^^^^^^^^^^^^^^^
+>         : ^ ^^^^^ ^^^^^^^^
 ><T>(n: T) => { return [n]; } : <T>(n: T) => T[]
->                             : ^^^^^^^^^^^^^^^^
+>                             : ^ ^^^^^ ^^^^^^^^
 >n : T
 >  : ^
 >[n] : T[]

tests/baselines/reference/arrowFunctionParsingGenericInObject.types

@@ -3,19 +3,19 @@
 === arrowFunctionParsingGenericInObject.ts ===
 const fn1 = () => ({
 >fn1 : () => { test: <T = undefined>(value: T) => T; extraValue: () => void; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => ({    test: <T = undefined>(value: T): T => value,    extraValue: () => {},}) : () => { test: <T = undefined>(value: T) => T; extraValue: () => void; }
->                                                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                    : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({    test: <T = undefined>(value: T): T => value,    extraValue: () => {},}) : { test: <T = undefined>(value: T) => T; extraValue: () => void; }
->                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                              : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{    test: <T = undefined>(value: T): T => value,    extraValue: () => {},} : { test: <T = undefined>(value: T) => T; extraValue: () => void; }
->                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                            : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     test: <T = undefined>(value: T): T => value,
 >test : <T = undefined>(value: T) => T
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 ><T = undefined>(value: T): T => value : <T = undefined>(value: T) => T
->                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                      : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >value : T
 >      : ^
 >value : T
@@ -31,19 +31,19 @@ const fn1 = () => ({
 
 const fn1async = () => ({
 >fn1async : () => { test: <T = undefined>(value: T) => Promise<T>; extraValue: () => void; }
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>         : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => ({    test: async <T = undefined>(value: T): Promise<T> => value,    extraValue: () => {},}) : () => { test: <T = undefined>(value: T) => Promise<T>; extraValue: () => void; }
->                                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                                   : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({    test: async <T = undefined>(value: T): Promise<T> => value,    extraValue: () => {},}) : { test: <T = undefined>(value: T) => Promise<T>; extraValue: () => void; }
->                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                             : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{    test: async <T = undefined>(value: T): Promise<T> => value,    extraValue: () => {},} : { test: <T = undefined>(value: T) => Promise<T>; extraValue: () => void; }
->                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                           : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     test: async <T = undefined>(value: T): Promise<T> => value,
 >test : <T = undefined>(value: T) => Promise<T>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          
 >async <T = undefined>(value: T): Promise<T> => value : <T = undefined>(value: T) => Promise<T>
->                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>                                                     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          
 >value : T
 >      : ^
 >value : T
@@ -59,19 +59,19 @@ const fn1async = () => ({
 
 const fn2 = () => ({
 >fn2 : () => { test: <T>(value: T) => T; extraValue: () => void; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => ({    test: <T>(value: T): T => value,    extraValue: () => {},}) : () => { test: <T>(value: T) => T; extraValue: () => void; }
->                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                        : ^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({    test: <T>(value: T): T => value,    extraValue: () => {},}) : { test: <T>(value: T) => T; extraValue: () => void; }
->                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                  : ^^^^^^^^^ ^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{    test: <T>(value: T): T => value,    extraValue: () => {},} : { test: <T>(value: T) => T; extraValue: () => void; }
->                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                : ^^^^^^^^^ ^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     test: <T>(value: T): T => value,
 >test : <T>(value: T) => T
->     : ^^^^^^^^^^^^^^^^^^
+>     : ^ ^^^^^^^^^ ^^^^^ 
 ><T>(value: T): T => value : <T>(value: T) => T
->                          : ^^^^^^^^^^^^^^^^^^
+>                          : ^ ^^^^^^^^^ ^^^^^ 
 >value : T
 >      : ^
 >value : T
@@ -87,19 +87,19 @@ const fn2 = () => ({
 
 const fn2async = () => ({
 >fn2async : () => { test: <T>(value: T) => Promise<T>; extraValue: () => void; }
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>         : ^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => ({    test: async <T>(value: T): Promise<T> => value,    extraValue: () => {},}) : () => { test: <T>(value: T) => Promise<T>; extraValue: () => void; }
->                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                       : ^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >({    test: async <T>(value: T): Promise<T> => value,    extraValue: () => {},}) : { test: <T>(value: T) => Promise<T>; extraValue: () => void; }
->                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                 : ^^^^^^^^^ ^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{    test: async <T>(value: T): Promise<T> => value,    extraValue: () => {},} : { test: <T>(value: T) => Promise<T>; extraValue: () => void; }
->                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                               : ^^^^^^^^^ ^^^^^^^^^ ^^^^^          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     test: async <T>(value: T): Promise<T> => value,
 >test : <T>(value: T) => Promise<T>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>     : ^ ^^^^^^^^^ ^^^^^          
 >async <T>(value: T): Promise<T> => value : <T>(value: T) => Promise<T>
->                                         : ^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>                                         : ^ ^^^^^^^^^ ^^^^^          
 >value : T
 >      : ^
 >value : T
@@ -115,13 +115,13 @@ const fn2async = () => ({
 
 const fn3 = () => ({
 >fn3 : () => { extraValue: () => void; test: <T = undefined>(value: T) => T; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 >() => ({    extraValue: () => {},    test: <T = undefined>(value: T): T => value,}) : () => { extraValue: () => void; test: <T = undefined>(value: T) => T; }
->                                                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 >({    extraValue: () => {},    test: <T = undefined>(value: T): T => value,}) : { extraValue: () => void; test: <T = undefined>(value: T) => T; }
->                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 >{    extraValue: () => {},    test: <T = undefined>(value: T): T => value,} : { extraValue: () => void; test: <T = undefined>(value: T) => T; }
->                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 
     extraValue: () => {},
 >extraValue : () => void
@@ -131,9 +131,9 @@ const fn3 = () => ({
 
     test: <T = undefined>(value: T): T => value,
 >test : <T = undefined>(value: T) => T
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 ><T = undefined>(value: T): T => value : <T = undefined>(value: T) => T
->                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                      : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >value : T
 >      : ^
 >value : T
@@ -143,13 +143,13 @@ const fn3 = () => ({
 
 const fn3async = () => ({
 >fn3async : () => { extraValue: () => void; test: <T = undefined>(value: T) => Promise<T>; }
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 >() => ({    extraValue: () => {},    test: async <T = undefined>(value: T): Promise<T> => value,}) : () => { extraValue: () => void; test: <T = undefined>(value: T) => Promise<T>; }
->                                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>                                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 >({    extraValue: () => {},    test: async <T = undefined>(value: T): Promise<T> => value,}) : { extraValue: () => void; test: <T = undefined>(value: T) => Promise<T>; }
->                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 >{    extraValue: () => {},    test: async <T = undefined>(value: T): Promise<T> => value,} : { extraValue: () => void; test: <T = undefined>(value: T) => Promise<T>; }
->                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 
     extraValue: () => {},
 >extraValue : () => void
@@ -159,9 +159,9 @@ const fn3async = () => ({
 
     test: async <T = undefined>(value: T): Promise<T> => value,
 >test : <T = undefined>(value: T) => Promise<T>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          
 >async <T = undefined>(value: T): Promise<T> => value : <T = undefined>(value: T) => Promise<T>
->                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>                                                     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          
 >value : T
 >      : ^
 >value : T
@@ -171,13 +171,13 @@ const fn3async = () => ({
 
 const fn4 = () => ({
 >fn4 : () => { extraValue: string; test: <T = undefined>(value: T) => T; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 >() => ({    extraValue: '',    test: <T = undefined>(value: T): T => value,}) : () => { extraValue: string; test: <T = undefined>(value: T) => T; }
->                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 >({    extraValue: '',    test: <T = undefined>(value: T): T => value,}) : { extraValue: string; test: <T = undefined>(value: T) => T; }
->                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 >{    extraValue: '',    test: <T = undefined>(value: T): T => value,} : { extraValue: string; test: <T = undefined>(value: T) => T; }
->                                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^
 
     extraValue: '',
 >extraValue : string
@@ -187,9 +187,9 @@ const fn4 = () => ({
 
     test: <T = undefined>(value: T): T => value,
 >test : <T = undefined>(value: T) => T
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 ><T = undefined>(value: T): T => value : <T = undefined>(value: T) => T
->                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                                      : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ 
 >value : T
 >      : ^
 >value : T
@@ -199,13 +199,13 @@ const fn4 = () => ({
 
 const fn4async = () => ({
 >fn4async : () => { extraValue: string; test: <T = undefined>(value: T) => Promise<T>; }
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 >() => ({    extraValue: '',    test: async <T = undefined>(value: T): Promise<T> => value,}) : () => { extraValue: string; test: <T = undefined>(value: T) => Promise<T>; }
->                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 >({    extraValue: '',    test: async <T = undefined>(value: T): Promise<T> => value,}) : { extraValue: string; test: <T = undefined>(value: T) => Promise<T>; }
->                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 >{    extraValue: '',    test: async <T = undefined>(value: T): Promise<T> => value,} : { extraValue: string; test: <T = undefined>(value: T) => Promise<T>; }
->                                                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ ^^^
+>                                                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          ^^^
 
     extraValue: '',
 >extraValue : string
@@ -215,9 +215,9 @@ const fn4async = () => ({
 
     test: async <T = undefined>(value: T): Promise<T> => value,
 >test : <T = undefined>(value: T) => Promise<T>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          
 >async <T = undefined>(value: T): Promise<T> => value : <T = undefined>(value: T) => Promise<T>
->                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
+>                                                     : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^          
 >value : T
 >      : ^
 >value : T

tests/baselines/reference/assertInWrapSomeTypeParameter.types

@@ -7,7 +7,7 @@ class C<T extends C<T>> {
 
     foo<U extends C<C<T>>(x: U) {
 >foo : <U extends C<C<T>>>(x: U) => any
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^
 >x : U
 >  : ^
 

tests/baselines/reference/assertionFunctionWildcardImport2.types

@@ -3,7 +3,7 @@
 === asserts.ts ===
 function isNonNullable<T>(obj: T): asserts obj is NonNullable<T> {
 >isNonNullable : <T>(obj: T) => asserts obj is NonNullable<T>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>              : ^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >obj : T
 >    : ^
 

tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types

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

tests/baselines/reference/assertionTypePredicates1.types

@@ -37,7 +37,7 @@ declare function assertIsArrayOfStrings(value: unknown): asserts value is string
 
 declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
 >assertDefined : <T>(value: T) => asserts value is NonNullable<T>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>              : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : T
 >      : ^
 
@@ -446,7 +446,7 @@ namespace Debug {
 
     export declare function assertDefined<T>(value: T): asserts value is NonNullable<T>;
 >assertDefined : <T>(value: T) => asserts value is NonNullable<T>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>              : ^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : T
 >      : ^
 }
@@ -824,7 +824,7 @@ class Derived extends Test {
 
 function f11(items: Test[]) {
 >f11 : (items: Test[]) => void
->    : ^^^^^^^^^^^^  ^^^^^^^^^
+>    : ^^^^^^^^      ^^^^^^^^^
 >items : Test[]
 >      : ^^^^^^
 
@@ -1046,7 +1046,7 @@ interface GoodThing {
 
 function example1(things: Thing[]) {
 >example1 : (things: Thing[]) => void
->         : ^^^^^^^^^^^^^^  ^^^^^^^^^
+>         : ^^^^^^^^^       ^^^^^^^^^
 >things : Thing[]
 >       : ^^^^^^^
 

tests/baselines/reference/assertionTypePredicates2.types

@@ -15,9 +15,9 @@
  */
 const foo = (a) => {
 >foo : (a: A) => asserts a is B
->    : ^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^ ^^^^^^^^^^^^^^^^^^^
 >(a) => {    if (/** @type { B } */ (a).y !== 0) throw TypeError();    return undefined;} : (a: A) => asserts a is B
->                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^
+>                                                                                         : ^^^^ ^^^^^^^^^^^^^^^^^^^
 >a : A
 >  : ^
 

tests/baselines/reference/assignAnyToEveryType.types

@@ -125,7 +125,7 @@ var j: { (): string } = x;
 
 var j2: { <T>(x: T): string } = x;
 >j2 : <T>(x: T) => string
->   : ^^^^^^^^^^^^^      
+>   : ^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >x : any
@@ -152,7 +152,7 @@ M = x;
 
 function k<T>(a: T) {
 >k : <T>(a: T) => void
->  : ^^^^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^^^^^
 >a : T
 >  : ^
 

tests/baselines/reference/assignEveryTypeToAny.types

@@ -195,12 +195,12 @@ x = { f() { return 1; } }
 
 x = { f<T>(x: T) { return x; } }
 >x = { f<T>(x: T) { return x; } } : { f<T>(x: T): T; }
->                                 : ^^^^^^^^^^^^^^^^^^
+>                                 : ^^^^ ^^^^^ ^^^^^^^
 >x : any
 >{ f<T>(x: T) { return x; } } : { f<T>(x: T): T; }
->                             : ^^^^^^^^^^^^^^^^^^
+>                             : ^^^^ ^^^^^ ^^^^^^^
 >f : <T>(x: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^^
 >x : T
 >  : ^
 >x : T
@@ -208,7 +208,7 @@ x = { f<T>(x: T) { return x; } }
 
 function j<T>(a: T) {
 >j : <T>(a: T) => void
->  : ^^^^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^^^^^
 >a : T
 >  : ^
 

tests/baselines/reference/assignFromStringInterface2.types

@@ -58,13 +58,13 @@ interface NotString {
 
     match(regexp: string): RegExpMatchArray;
 >match : { (regexp: string): RegExpMatchArray; (regexp: RegExp): RegExpMatchArray; }
->      : ^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^^^^^^      ^^^                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >regexp : string
 >       : ^^^^^^
 
     match(regexp: RegExp): RegExpMatchArray;
 >match : { (regexp: string): RegExpMatchArray; (regexp: RegExp): RegExpMatchArray; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^                ^^^
 >regexp : RegExp
 >       : ^^^^^^
 
@@ -90,7 +90,7 @@ interface NotString {
 
     replace(searchValue: RegExp, replaceValue: string): string;
 >replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^      ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >searchValue : RegExp
 >            : ^^^^^^
 >replaceValue : string
@@ -98,7 +98,7 @@ interface NotString {
 
     replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
 >replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                             ^^^      ^^^
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^                                             ^^^      ^^^
 >searchValue : RegExp
 >            : ^^^^^^
 >replaceValue : (substring: string, ...args: any[]) => string
@@ -116,7 +116,7 @@ interface NotString {
 
     search(regexp: RegExp): number;
 >search : { (regexp: string): number; (regexp: RegExp): number; }
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^      ^^^
 >regexp : RegExp
 >       : ^^^^^^
 
@@ -138,7 +138,7 @@ interface NotString {
 
     split(separator: RegExp, limit?: number): string[];
 >split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^        ^^^
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^      ^^^        ^^^
 >separator : RegExp
 >          : ^^^^^^
 >limit : number

tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.types

@@ -9,7 +9,7 @@ interface IResultCallback extends Function {
 
 function fn(cb: IResultCallback) { }
 >fn : (cb: IResultCallback) => void
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^^^^^               ^^^^^^^^^
 >cb : IResultCallback
 >   : ^^^^^^^^^^^^^^^
 

tests/baselines/reference/assignToObjectTypeWithPrototypeProperty.types

@@ -17,7 +17,7 @@ var p: XEvent = XEvent.prototype;
 
 var x: {prototype: XEvent} = XEvent;
 >x : { prototype: XEvent; }
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^^^^      ^^^
 >prototype : XEvent
 >          : ^^^^^^
 >XEvent : typeof XEvent

tests/baselines/reference/assignmentCompatForEnums.types

@@ -18,7 +18,7 @@ var list = {};
 
 function returnType(): TokenType { return null; }
 >returnType : () => TokenType
->           : ^^^^^^^^^^^^^^^
+>           : ^^^^^^         
 
 function foo() {
 >foo : () => void

tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.types

@@ -24,7 +24,7 @@ class Foo {
 
 function Biz(map: IHandlerMap) { }
 >Biz : (map: IHandlerMap) => void
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^           ^^^^^^^^^
 >map : IHandlerMap
 >    : ^^^^^^^^^^^
 

tests/baselines/reference/assignmentCompatOnNew.types

@@ -7,9 +7,9 @@ class Foo{};
 
 function bar(x: {new(): Foo;}){}
 >bar : (x: { new (): Foo; }) => void
->    : ^^^^          ^^^   ^^^^^^^^^
+>    : ^^^^                ^^^^^^^^^
 >x : new () => Foo
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^^^^^   
 
 bar(Foo); // Error, but should be allowed
 >bar(Foo) : void

tests/baselines/reference/assignmentCompatWithCallSignatures.types

@@ -83,11 +83,11 @@ a = a2;
 
 t = <T>(x: T) => 1;
 >t = <T>(x: T) => 1 : <T>(x: T) => number
->                   : ^^^^^^^^^^^^^^^^^^^
+>                   : ^ ^^^^^ ^^^^^^^^^^^
 >t : T
 >  : ^
 ><T>(x: T) => 1 : <T>(x: T) => number
->               : ^^^^^^^^^^^^^^^^^^^
+>               : ^ ^^^^^ ^^^^^^^^^^^
 >x : T
 >  : ^
 >1 : 1
@@ -117,11 +117,11 @@ t = function (x: number) { return ''; }
 
 a = <T>(x: T) => 1;
 >a = <T>(x: T) => 1 : <T>(x: T) => number
->                   : ^^^^^^^^^^^^^^^^^^^
+>                   : ^ ^^^^^ ^^^^^^^^^^^
 >a : (x: number) => void
 >  : ^^^^^^^^^^^^^^^^^^^
 ><T>(x: T) => 1 : <T>(x: T) => number
->               : ^^^^^^^^^^^^^^^^^^^
+>               : ^ ^^^^^ ^^^^^^^^^^^
 >x : T
 >  : ^
 >1 : 1

tests/baselines/reference/assignmentCompatWithCallSignatures2.types

@@ -105,15 +105,15 @@ t = { f: () => 1 };
 
 t = { f: <T>(x:T) => 1 };
 >t = { f: <T>(x:T) => 1 } : { f: <T>(x: T) => number; }
->                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                         : ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^
 >t : T
 >  : ^
 >{ f: <T>(x:T) => 1 } : { f: <T>(x: T) => number; }
->                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                     : ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^
 >f : <T>(x: T) => number
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^^^^^^^
 ><T>(x:T) => 1 : <T>(x: T) => number
->              : ^^^^^^^^^^^^^^^^^^^
+>              : ^ ^^^^^ ^^^^^^^^^^^
 >x : T
 >  : ^
 >1 : 1
@@ -165,15 +165,15 @@ a = { f: () => 1 }
 
 a = { f: <T>(x: T) => 1 };
 >a = { f: <T>(x: T) => 1 } : { f: <T>(x: T) => number; }
->                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                          : ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^
 >a : { f(x: number): void; }
 >  : ^^^^^^^^^^^^^^^^^^^^^^^
 >{ f: <T>(x: T) => 1 } : { f: <T>(x: T) => number; }
->                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>                      : ^^^^^^ ^^^^^ ^^^^^^^^^^^^^^
 >f : <T>(x: T) => number
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^^^^^^^
 ><T>(x: T) => 1 : <T>(x: T) => number
->               : ^^^^^^^^^^^^^^^^^^^
+>               : ^ ^^^^^ ^^^^^^^^^^^
 >x : T
 >  : ^
 >1 : 1

tests/baselines/reference/assignmentCompatWithCallSignatures3.types

@@ -69,17 +69,17 @@ var a5: (x: (arg: string) => number) => string;
 
 var a6: (x: (arg: Base) => Derived) => Base;
 >a6 : (x: (arg: Base) => Derived) => Base
->   : ^^^^      ^^^^     ^^^^^^^^^^^^^^^^
+>   : ^^^^                      ^^^^^    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 
 var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived;
 >a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived
->   : ^^^^      ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^                      ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >r : Base
@@ -87,13 +87,13 @@ var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived;
 
 var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
 >a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
->   : ^^^^      ^^^^     ^^^^^^^^^^^^       ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^                      ^^^^^                       ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >y : (arg2: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^    ^^^^^       
 >arg2 : Base
 >     : ^^^^
 >r : Base
@@ -101,13 +101,13 @@ var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) =>
 
 var a9: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
 >a9 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
->   : ^^^^      ^^^^     ^^^^^^^^^^^^       ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^                      ^^^^^                       ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >y : (arg2: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^    ^^^^^       
 >arg2 : Base
 >     : ^^^^
 >r : Base
@@ -115,13 +115,13 @@ var a9: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) =>
 
 var a10: (...x: Derived[]) => Derived;
 >a10 : (...x: Derived[]) => Derived
->    : ^^^^^^^^^^^^^^  ^^^^^^^^^^^^
+>    : ^^^^^^^         ^^^^^       
 >x : Derived[]
 >  : ^^^^^^^^^
 
 var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 >a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
->    : ^^^^                ^^^^^                             ^^^^^^^^^
+>    : ^^^^                ^^^^^                             ^^^^^    
 >x : { foo: string; }
 >  : ^^^^^^^      ^^^
 >foo : string
@@ -135,7 +135,7 @@ var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 
 var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
->    : ^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^           ^^^^^               ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : Derived2[]
@@ -143,7 +143,7 @@ var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 
 var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : (x: Array<Base>, y: Array<Derived>) => Array<Derived>
->    : ^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^           ^^^^^              ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : Derived[]
@@ -151,7 +151,7 @@ var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 
 var a14: (x: { a: string; b: number }) => Object;
 >a14 : (x: { a: string; b: number; }) => Object
->    : ^^^^                         ^^^^^^^^^^^
+>    : ^^^^                         ^^^^^      
 >x : { a: string; b: number; }
 >  : ^^^^^      ^^^^^      ^^^
 >a : string
@@ -173,7 +173,7 @@ var a15: {
 }
 var a16: {
 >a16 : { <T extends Derived>(x: T): number[]; <U extends Base>(x: U): number[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^
+>    : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^        ^^^ ^^^^^^^^^^^^^^^^^^ ^^^        ^^^
 
     <T extends Derived>(x: T): number[];
 >x : T
@@ -202,7 +202,7 @@ var a17: {
 };
 var a18: {
 >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; }
@@ -219,7 +219,7 @@ var a18: {
     }): any[];
     (x: {
 >x : { (a: boolean): boolean; (a: Date): Date; }
->  : ^^^^^^       ^^^       ^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^       ^^^       ^^^^^^    ^^^    ^^^
 
         (a: boolean): boolean;
 >a : boolean
@@ -234,7 +234,7 @@ var a18: {
 
 var b: <T>(x: T) => T[]; 
 >b : <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^  
+>  : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -256,7 +256,7 @@ b = a; // ok
 
 var b2: <T>(x: T) => string[]; 
 >b2 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -278,7 +278,7 @@ b2 = a2; // ok
 
 var b3: <T>(x: T) => T; 
 >b3 : <T>(x: T) => T
->   : ^^^^^^^^^^^^^^
+>   : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 
@@ -300,7 +300,7 @@ b3 = a3; // ok
 
 var b4: <T, U>(x: T, y: U) => T; 
 >b4 : <T, U>(x: T, y: U) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^ ^^ ^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : U
@@ -324,9 +324,9 @@ b4 = a4; // ok
 
 var b5: <T, U>(x: (arg: T) => U) => T; 
 >b5 : <T, U>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^ ^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -348,9 +348,9 @@ b5 = a5; // ok
 
 var b6: <T extends Base, U extends Derived>(x: (arg: T) => U) => T; 
 >b6 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -372,9 +372,9 @@ b6 = a6; // ok
 
 var b7: <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U; 
 >b7 : <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^    ^     ^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >r : T
@@ -398,13 +398,13 @@ b7 = a7; // ok
 
 var b8: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U;
 >b8 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^       ^     ^^^^^^    ^     ^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^              ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >y : (arg2: T) => U
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^ 
 >arg2 : T
 >     : ^
 >r : T
@@ -428,13 +428,13 @@ b8 = a8; // ok
 
 var b9: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U; 
 >b9 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^                                          ^^^^^^    ^     ^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^                                           ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >y : (arg2: { foo: string; bing: number; }) => U
->  : ^^^^^^^                              ^^^^^^
+>  : ^^^^^^^                              ^^^^^ 
 >arg2 : { foo: string; bing: number; }
 >     : ^^^^^^^      ^^^^^^^^      ^^^
 >foo : string
@@ -462,7 +462,7 @@ b9 = a9; // ok
 
 var b10: <T extends Derived>(...x: T[]) => T; 
 >b10 : <T extends Derived>(...x: T[]) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^ 
 >x : T[]
 >  : ^^^
 
@@ -484,7 +484,7 @@ b10 = a10; // ok
 
 var b11: <T extends Base>(x: T, y: T) => T; 
 >b11 : <T extends Base>(x: T, y: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : T
@@ -508,7 +508,7 @@ b11 = a11; // ok
 
 var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : <T extends Base[]>(x: Array<Base>, y: T) => Array<Derived>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^ 
+>    : ^ ^^^^^^^^^^^^^^^^^^^^           ^^^^^ ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : T
@@ -532,7 +532,7 @@ b12 = a12; // ok
 
 var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : <T extends Derived[]>(x: Array<Base>, y: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^ ^^^^^ 
 >x : Base[]
 >  : ^^^^^^
 >y : T
@@ -556,9 +556,9 @@ b13 = a13; // ok
 
 var b14: <T>(x: { a: T; b: T }) => T; 
 >b14 : <T>(x: { a: T; b: T; }) => T
->    : ^^^^^^^     ^     ^   ^^^^^^
+>    : ^ ^^^^^               ^^^^^ 
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -582,7 +582,7 @@ b14 = a14; // ok
 
 var b15: <T>(x: T) => T[]; 
 >b15 : <T>(x: T) => T[]
->    : ^^^^^^^^^^^^^^  
+>    : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -604,7 +604,7 @@ b15 = a15; // ok
 
 var b16: <T extends Base>(x: T) => number[];
 >b16 : <T extends Base>(x: T) => number[]
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^        
+>    : ^ ^^^^^^^^^^^^^^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -626,9 +626,9 @@ b16 = a16; // ok
 
 var b17: <T>(x: (a: T) => T) => T[]; // ok
 >b17 : <T>(x: (a: T) => T) => T[]
->    : ^^^^^^^    ^     ^^^^^^^  
+>    : ^ ^^^^^           ^^^^^   
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -650,9 +650,9 @@ b17 = a17; // ok
 
 var b18: <T>(x: (a: T) => T) => T[]; 
 >b18 : <T>(x: (a: T) => T) => T[]
->    : ^^^^^^^    ^     ^^^^^^^  
+>    : ^ ^^^^^           ^^^^^   
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 

tests/baselines/reference/assignmentCompatWithCallSignatures4.types

@@ -50,9 +50,9 @@ module Errors {
 
         var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived2;
 >a7 : (x: (arg: Base) => Derived) => (r: Base) => Derived2
->   : ^^^^      ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^^
+>   : ^^^^                      ^^^^^                     
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >r : Base
@@ -60,13 +60,13 @@ module Errors {
 
         var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
 >a8 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
->   : ^^^^      ^^^^     ^^^^^^^^^^^^       ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^                      ^^^^^                       ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >y : (arg2: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^    ^^^^^       
 >arg2 : Base
 >     : ^^^^
 >r : Base
@@ -74,13 +74,13 @@ module Errors {
 
         var a10: (...x: Base[]) => Base;
 >a10 : (...x: Base[]) => Base
->    : ^^^^^^^^^^^  ^^^^^^^^^
+>    : ^^^^^^^      ^^^^^    
 >x : Base[]
 >  : ^^^^^^
 
         var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 >a11 : (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
->    : ^^^^                ^^^^^                             ^^^^^^^^^
+>    : ^^^^                ^^^^^                             ^^^^^    
 >x : { foo: string; }
 >  : ^^^^^^^      ^^^
 >foo : string
@@ -94,7 +94,7 @@ module Errors {
 
         var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
->    : ^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^           ^^^^^               ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : Derived2[]
@@ -156,11 +156,11 @@ module Errors {
             };
         var a17: {
 >a17 : { (x: { <T extends Derived>(a: T): T; <T_1 extends Base>(a: T_1): T_1; }): any[]; (x: { <T_2 extends Derived2>(a: T_2): T_2; <T_3 extends Base>(a: T_3): T_3; }): any[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
+>    : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
 
                 (x: {
 >x : { <T extends Derived>(a: T): T; <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
                     <T extends Derived>(a: T): T;
 >a : T
@@ -173,7 +173,7 @@ module Errors {
                 }): any[];
                 (x: {
 >x : { <T extends Derived2>(a: T): T; <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
                     <T extends Derived2>(a: T): T;
 >a : T
@@ -188,7 +188,7 @@ module Errors {
 
         var b2: <T, U>(x: T) => U[]; 
 >b2 : <T, U>(x: T) => U[]
->   : ^^^^^^^^^^^^^^^^^  
+>   : ^ ^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -210,9 +210,9 @@ module Errors {
 
         var b7: <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V;
 >b7 : <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^    ^     ^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^             ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >r : T
@@ -236,13 +236,13 @@ module Errors {
 
         var b8: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; 
 >b8 : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^                            ^^^^^^    ^     ^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^                             ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >y : (arg2: { foo: number; }) => U
->  : ^^^^^^^                ^^^^^^
+>  : ^^^^^^^                ^^^^^ 
 >arg2 : { foo: number; }
 >     : ^^^^^^^      ^^^
 >foo : number
@@ -269,7 +269,7 @@ module Errors {
         
         var b10: <T extends Derived>(...x: T[]) => T; 
 >b10 : <T extends Derived>(...x: T[]) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^ 
 >x : T[]
 >  : ^^^
 
@@ -291,7 +291,7 @@ module Errors {
 
         var b11: <T extends Derived>(x: T, y: T) => T; 
 >b11 : <T extends Derived>(x: T, y: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : T
@@ -315,7 +315,7 @@ module Errors {
 
         var b12: <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T; 
 >b12 : <T extends Derived2[]>(x: Array<Base>, y: Array<Base>) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^
+>    : ^ ^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^           ^^^^^ 
 >x : Base[]
 >  : ^^^^^^
 >y : Base[]
@@ -339,9 +339,9 @@ module Errors {
 
         var b15: <T>(x: { a: T; b: T }) => T; 
 >b15 : <T>(x: { a: T; b: T; }) => T
->    : ^^^^^^^     ^     ^   ^^^^^^
+>    : ^ ^^^^^               ^^^^^ 
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -365,9 +365,9 @@ module Errors {
 
         var b15a: <T extends Base>(x: { a: T; b: T }) => number; 
 >b15a : <T extends Base>(x: { a: T; b: T; }) => number
->     : ^^^^^^^^^^^^^^^^^^^^     ^     ^   ^^^^^      
+>     : ^ ^^^^^^^^^^^^^^^^^^               ^^^^^      
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -391,9 +391,9 @@ module Errors {
 
         var b16: <T>(x: (a: T) => T) => T[];
 >b16 : <T>(x: (a: T) => T) => T[]
->    : ^^^^^^^    ^     ^^^^^^^  
+>    : ^ ^^^^^           ^^^^^   
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -415,9 +415,9 @@ module Errors {
 
         var b17: <T>(x: (a: T) => T) => any[];
 >b17 : <T>(x: (a: T) => T) => any[]
->    : ^^^^^^^    ^     ^^^^^^     
+>    : ^ ^^^^^           ^^^^^     
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -445,13 +445,13 @@ module Errors {
         // target type has generic call signature
         var a2: <T>(x: T) => T[];
 >a2 : <T>(x: T) => T[]
->   : ^^^^^^^^^^^^^^  
+>   : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
         var b2: <T>(x: T) => string[];
 >b2 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -474,13 +474,13 @@ module Errors {
         // target type has generic call signature
         var a3: <T>(x: T) => string[];
 >a3 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
         var b3: <T>(x: T) => T[]; 
 >b3 : <T>(x: T) => T[]
->   : ^^^^^^^^^^^^^^  
+>   : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 

tests/baselines/reference/assignmentCompatWithCallSignatures5.types

@@ -35,25 +35,25 @@ class OtherDerived extends Base { bing: string; }
 
 var a: <T>(x: T) => T[];
 >a : <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^  
+>  : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
 var a2: <T>(x: T) => string[];
 >a2 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
 var a3: <T>(x: T) => void;
 >a3 : <T>(x: T) => void
->   : ^^^^^^^^^^^^^    
+>   : ^ ^^^^^ ^^^^^    
 >x : T
 >  : ^
 
 var a4: <T,U>(x: T, y: U) => string;
 >a4 : <T, U>(x: T, y: U) => string
->   : ^^^^^^^^^^^^^^^^^^^^^^      
+>   : ^ ^^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : U
@@ -61,29 +61,29 @@ var a4: <T,U>(x: T, y: U) => string;
 
 var a5: <T,U>(x: (arg: T) => U) => T;
 >a5 : <T, U>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^ ^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
 var a6: <T extends Base>(x: (arg: T) => Derived) => T;
 >a6 : <T extends Base>(x: (arg: T) => Derived) => T
->   : ^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^^^^^^^^
+>   : ^ ^^^^^^^^^^^^^^^^^^                   ^^^^^ 
 >x : (arg: T) => Derived
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^       
 >arg : T
 >    : ^
 
 var a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
 >a11 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
->    : ^^^^^^^       ^   ^^^^^       ^       ^   ^^^^^^^^^
+>    : ^ ^^^^^           ^^^^^                   ^^^^^    
 >x : { foo: T; }
->  : ^^^^^^^^^^^
+>  : ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >y : { foo: T; bar: T; }
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >bar : T
@@ -91,9 +91,9 @@ var a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
 
 var a15: <T>(x: { a: T; b: T }) => T[];
 >a15 : <T>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -101,9 +101,9 @@ var a15: <T>(x: { a: T; b: T }) => T[];
 
 var a16: <T extends Base>(x: { a: T; b: T }) => T[];
 >a16 : <T extends Base>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^^^^^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^^^^^^^^^^^^^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -111,28 +111,28 @@ var a16: <T extends Base>(x: { a: T; b: T }) => T[];
 
 var a17: {
 >a17 : { <T extends Derived>(x: (a: T) => T): T[]; <T_1 extends Base>(x: (a: T_1) => T_1): T_1[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^    ^     ^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^ ^^^^^^^^^^^^^^^^^^^^^           ^^^   ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     <T extends Derived>(x: (a: T) => T): T[];
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
     <T extends Base>(x: (a: T) => T): T[];        
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
 };
 var a18: {
 >a18 : { (x: { <T extends Derived>(a: T): T; <T_1 extends Base>(a: T_1): T_1; }): any[]; (x: { <T_2 extends Derived2>(a: T_2): T_2; <T_3 extends Base>(a: T_3): T_3; }): any[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
+>    : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
 
     (x: {
 >x : { <T extends Derived>(a: T): T; <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         <T extends Derived>(a: T): T;
 >a : T
@@ -145,7 +145,7 @@ var a18: {
     }): any[];
     (x: {
 >x : { <T extends Derived2>(a: T): T; <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         <T extends Derived2>(a: T): T;
 >a : T
@@ -160,7 +160,7 @@ var a18: {
 
 var b: <T>(x: T) => T[]; 
 >b : <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^  
+>  : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -182,7 +182,7 @@ b = a; // ok
 
 var b2: <T>(x: T) => string[]; 
 >b2 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -204,7 +204,7 @@ b2 = a2; // ok
 
 var b3: <T>(x: T) => T; 
 >b3 : <T>(x: T) => T
->   : ^^^^^^^^^^^^^^
+>   : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 
@@ -226,7 +226,7 @@ b3 = a3; // ok
 
 var b4: <T, U>(x: T, y: U) => string; 
 >b4 : <T, U>(x: T, y: U) => string
->   : ^^^^^^^^^^^^^^^^^^^^^^      
+>   : ^ ^^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : U
@@ -250,9 +250,9 @@ b4 = a4; // ok
 
 var b5: <T, U>(x: (arg: T) => U) => T; 
 >b5 : <T, U>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^ ^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -274,9 +274,9 @@ b5 = a5; // ok
 
 var b6: <T extends Base, U extends Derived>(x: (arg: T) => U) => T; 
 >b6 : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -298,13 +298,13 @@ b6 = a6; // ok
 
 var b11: <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base; 
 >b11 : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
->    : ^^^^^^^^^^       ^   ^^^^^       ^       ^   ^^^^^^^^^
+>    : ^ ^^ ^^^^^           ^^^^^                   ^^^^^    
 >x : { foo: T; }
->  : ^^^^^^^^^^^
+>  : ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >y : { foo: U; bar: U; }
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^ ^^^
 >foo : U
 >    : ^
 >bar : U
@@ -328,9 +328,9 @@ b11 = a11; // ok
 
 var b15: <U, V>(x: { a: U; b: V; }) => U[]; 
 >b15 : <U, V>(x: { a: U; b: V; }) => U[]
->    : ^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^ ^^^^^               ^^^^^   
 >x : { a: U; b: V; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : U
 >  : ^
 >b : V
@@ -354,9 +354,9 @@ b15 = a15; // ok
 
 var b16: <T>(x: { a: T; b: T }) => T[]; 
 >b16 : <T>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -380,9 +380,9 @@ b15 = a16; // ok
 
 var b17: <T>(x: (a: T) => T) => T[]; 
 >b17 : <T>(x: (a: T) => T) => T[]
->    : ^^^^^^^    ^     ^^^^^^^  
+>    : ^ ^^^^^           ^^^^^   
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -404,9 +404,9 @@ b17 = a17; // ok
 
 var b18: (x: <T>(a: T) => T) => any[]; 
 >b18 : (x: <T>(a: T) => T) => any[]
->    : ^^^^^^^^^^^^^^^^^^^^^^^     
+>    : ^^^^^ ^^^^^ ^^^^^ ^^^^^     
 >x : <T>(a: T) => T
->  : ^^^^^^^^^^^^^^
+>  : ^ ^^^^^ ^^^^^ 
 >a : T
 >  : ^
 

tests/baselines/reference/assignmentCompatWithCallSignatures6.types

@@ -36,25 +36,25 @@ class OtherDerived extends Base { bing: string; }
 interface A {
     a: <T>(x: T) => T[];
 >a : <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^  
+>  : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
     a2: <T>(x: T) => string[];
 >a2 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
     a3: <T>(x: T) => void;
 >a3 : <T>(x: T) => void
->   : ^^^^^^^^^^^^^    
+>   : ^ ^^^^^ ^^^^^    
 >x : T
 >  : ^
 
     a4: <T,U>(x: T, y: U) => string;
 >a4 : <T, U>(x: T, y: U) => string
->   : ^^^^^^^^^^^^^^^^^^^^^^      
+>   : ^ ^^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : U
@@ -62,29 +62,29 @@ interface A {
 
     a5: <T,U>(x: (arg: T) => U) => T;
 >a5 : <T, U>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^ ^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
     a6: <T extends Base>(x: (arg: T) => Derived) => T;
 >a6 : <T extends Base>(x: (arg: T) => Derived) => T
->   : ^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^^^^^^^^
+>   : ^ ^^^^^^^^^^^^^^^^^^                   ^^^^^ 
 >x : (arg: T) => Derived
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^       
 >arg : T
 >    : ^
 
     a11: <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
 >a11 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
->    : ^^^^^^^       ^   ^^^^^       ^       ^   ^^^^^^^^^
+>    : ^ ^^^^^           ^^^^^                   ^^^^^    
 >x : { foo: T; }
->  : ^^^^^^^^^^^
+>  : ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >y : { foo: T; bar: T; }
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >bar : T
@@ -92,9 +92,9 @@ interface A {
 
     a15: <T>(x: { a: T; b: T }) => T[];
 >a15 : <T>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -102,9 +102,9 @@ interface A {
 
     a16: <T extends Base>(x: { a: T; b: T }) => T[];
 >a16 : <T extends Base>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^^^^^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^^^^^^^^^^^^^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -117,7 +117,7 @@ var x: A;
 
 var b: <T>(x: T) => T[]; 
 >b : <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^  
+>  : ^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -147,7 +147,7 @@ b = x.a;
 
 var b2: <T>(x: T) => string[]; 
 >b2 : <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^        
+>   : ^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -177,7 +177,7 @@ b2 = x.a2;
 
 var b3: <T>(x: T) => T;
 >b3 : <T>(x: T) => T
->   : ^^^^^^^^^^^^^^
+>   : ^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 
@@ -207,7 +207,7 @@ b3 = x.a3;
 
 var b4: <T, U>(x: T, y: U) => string; 
 >b4 : <T, U>(x: T, y: U) => string
->   : ^^^^^^^^^^^^^^^^^^^^^^      
+>   : ^ ^^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : U
@@ -239,9 +239,9 @@ b4 = x.a4;
 
 var b5: <T, U>(x: (arg: T) => U) => T; 
 >b5 : <T, U>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^      ^     ^^^^^^^
+>   : ^ ^^ ^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -271,13 +271,13 @@ b5 = x.a5;
 
 var b11: <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base; 
 >b11 : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
->    : ^^^^^^^^^^       ^   ^^^^^       ^       ^   ^^^^^^^^^
+>    : ^ ^^ ^^^^^           ^^^^^                   ^^^^^    
 >x : { foo: T; }
->  : ^^^^^^^^^^^
+>  : ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >y : { foo: U; bar: U; }
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^ ^^^
 >foo : U
 >    : ^
 >bar : U
@@ -309,9 +309,9 @@ b11 = x.a11;
 
 var b16: <T>(x: { a: T; b: T }) => T[]; 
 >b16 : <T>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^     ^     ^   ^^^^^^  
+>    : ^ ^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T

tests/baselines/reference/assignmentCompatWithConstructSignatures3.types

@@ -69,17 +69,17 @@ var a5: new (x: (arg: string) => number) => string;
 
 var a6: new (x: (arg: Base) => Derived) => Base;
 >a6 : new (x: (arg: Base) => Derived) => Base
->   : ^^^^^^^^      ^^^^     ^^^^^^^^^^^^^^^^
+>   : ^^^^^^^^                      ^^^^^    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 
 var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived;
 >a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived
->   : ^^^^^^^^      ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^^^^^                      ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >r : Base
@@ -87,13 +87,13 @@ var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived;
 
 var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
 >a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
->   : ^^^^^^^^      ^^^^     ^^^^^^^^^^^^       ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^^^^^                      ^^^^^                       ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >y : (arg2: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^    ^^^^^       
 >arg2 : Base
 >     : ^^^^
 >r : Base
@@ -101,13 +101,13 @@ var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base)
 
 var a9: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
 >a9 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
->   : ^^^^^^^^      ^^^^     ^^^^^^^^^^^^       ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^^^^^                      ^^^^^                       ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >y : (arg2: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^    ^^^^^       
 >arg2 : Base
 >     : ^^^^
 >r : Base
@@ -115,13 +115,13 @@ var a9: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base)
 
 var a10: new (...x: Derived[]) => Derived;
 >a10 : new (...x: Derived[]) => Derived
->    : ^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^
+>    : ^^^^^^^^^^^         ^^^^^       
 >x : Derived[]
 >  : ^^^^^^^^^
 
 var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 >a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
->    : ^^^^^^^^                ^^^^^                             ^^^^^^^^^
+>    : ^^^^^^^^                ^^^^^                             ^^^^^    
 >x : { foo: string; }
 >  : ^^^^^^^      ^^^
 >foo : string
@@ -135,7 +135,7 @@ var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 
 var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
->    : ^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^^^^^           ^^^^^               ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : Derived2[]
@@ -143,7 +143,7 @@ var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 
 var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 >a13 : new (x: Array<Base>, y: Array<Derived>) => Array<Derived>
->    : ^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^^^^^           ^^^^^              ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : Derived[]
@@ -151,7 +151,7 @@ var a13: new (x: Array<Base>, y: Array<Derived>) => Array<Derived>;
 
 var a14: new (x: { a: string; b: number }) => Object;
 >a14 : new (x: { a: string; b: number; }) => Object
->    : ^^^^^^^^                         ^^^^^^^^^^^
+>    : ^^^^^^^^                         ^^^^^      
 >x : { a: string; b: number; }
 >  : ^^^^^      ^^^^^      ^^^
 >a : string
@@ -173,7 +173,7 @@ var a15: {
 }
 var a16: {
 >a16 : { new <T extends Derived>(x: T): number[]; new <U extends Base>(x: U): number[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^
+>    : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^        ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^        ^^^
 
     new <T extends Derived>(x: T): number[];
 >x : T
@@ -202,7 +202,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[]; }
->    : ^^^^^^^^^^                                                     ^^^     ^^^^^^^^^^                                     ^^^^   ^^^^   ^^^     ^^^
+>    : ^^^^^^^^^^                                                     ^^^     ^^^^^^^^^^                                                   ^^^     ^^^
 
     new (x: {
 >x : { new (a: number): number; new (a: string): string; }
@@ -219,7 +219,7 @@ var a18: {
     }): any[];
     new (x: {
 >x : { new (a: boolean): boolean; new (a: Date): Date; }
->  : ^^^^^^^^^^       ^^^       ^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^       ^^^       ^^^^^^^^^^    ^^^    ^^^
 
         new (a: boolean): boolean;
 >a : boolean
@@ -234,7 +234,7 @@ var a18: {
 
 var b: new <T>(x: T) => T[]; 
 >b : new <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^^^^^  
+>  : ^^^^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -256,7 +256,7 @@ b = a; // ok
 
 var b2: new <T>(x: T) => string[]; 
 >b2 : new <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^^^^^        
+>   : ^^^^^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -278,7 +278,7 @@ b2 = a2; // ok
 
 var b3: new <T>(x: T) => T; 
 >b3 : new <T>(x: T) => T
->   : ^^^^^^^^^^^^^^^^^^
+>   : ^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 
@@ -300,7 +300,7 @@ b3 = a3; // ok
 
 var b4: new <T, U>(x: T, y: U) => T; 
 >b4 : new <T, U>(x: T, y: U) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>   : ^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : U
@@ -324,9 +324,9 @@ b4 = a4; // ok
 
 var b5: new <T, U>(x: (arg: T) => U) => T; 
 >b5 : new <T, U>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^      ^     ^^^^^^^
+>   : ^^^^^ ^^ ^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -348,9 +348,9 @@ b5 = a5; // ok
 
 var b6: new <T extends Base, U extends Derived>(x: (arg: T) => U) => T; 
 >b6 : new <T extends Base, U extends Derived>(x: (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^ 
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -372,9 +372,9 @@ b6 = a6; // ok
 
 var b7: new <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U; 
 >b7 : new <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^    ^     ^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >r : T
@@ -398,13 +398,13 @@ b7 = a7; // ok
 
 var b8: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U;
 >b8 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^       ^     ^^^^^^    ^     ^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^              ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >y : (arg2: T) => U
->  : ^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^ 
 >arg2 : T
 >     : ^
 >r : T
@@ -428,13 +428,13 @@ b8 = a8; // ok
 
 var b9: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U; 
 >b9 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^                                          ^^^^^^    ^     ^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^                                           ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >y : (arg2: { foo: string; bing: number; }) => U
->  : ^^^^^^^                              ^^^^^^
+>  : ^^^^^^^                              ^^^^^ 
 >arg2 : { foo: string; bing: number; }
 >     : ^^^^^^^      ^^^^^^^^      ^^^
 >foo : string
@@ -462,7 +462,7 @@ b9 = a9; // ok
 
 var b10: new <T extends Derived>(...x: T[]) => T; 
 >b10 : new <T extends Derived>(...x: T[]) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^ 
 >x : T[]
 >  : ^^^
 
@@ -484,7 +484,7 @@ b10 = a10; // ok
 
 var b11: new <T extends Base>(x: T, y: T) => T; 
 >b11 : new <T extends Base>(x: T, y: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : T
@@ -508,7 +508,7 @@ b11 = a11; // ok
 
 var b12: new <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>; 
 >b12 : new <T extends Base[]>(x: Array<Base>, y: T) => Array<Derived>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^^^           ^^^^^ ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : T
@@ -532,7 +532,7 @@ b12 = a12; // ok
 
 var b13: new <T extends Array<Derived>>(x: Array<Base>, y: T) => T; 
 >b13 : new <T extends Derived[]>(x: Array<Base>, y: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^ ^^^^^ 
 >x : Base[]
 >  : ^^^^^^
 >y : T
@@ -556,9 +556,9 @@ b13 = a13; // ok
 
 var b14: new <T>(x: { a: T; b: T }) => T; 
 >b14 : new <T>(x: { a: T; b: T; }) => T
->    : ^^^^^^^^^^^     ^     ^   ^^^^^^
+>    : ^^^^^ ^^^^^               ^^^^^ 
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -582,7 +582,7 @@ b14 = a14; // ok
 
 var b15: new <T>(x: T) => T[]; 
 >b15 : new <T>(x: T) => T[]
->    : ^^^^^^^^^^^^^^^^^^  
+>    : ^^^^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -604,7 +604,7 @@ b15 = a15; // ok
 
 var b16: new <T extends Base>(x: T) => number[];
 >b16 : new <T extends Base>(x: T) => number[]
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -626,9 +626,9 @@ b16 = a16; // ok
 
 var b17: new <T>(x: new (a: T) => T) => T[]; // ok
 >b17 : new <T>(x: new (a: T) => T) => T[]
->    : ^^^^^^^^^^^        ^     ^^^^^^^  
+>    : ^^^^^ ^^^^^               ^^^^^   
 >x : new (a: T) => T
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -650,9 +650,9 @@ b17 = a17; // ok
 
 var b18: new <T>(x: new (a: T) => T) => T[]; 
 >b18 : new <T>(x: new (a: T) => T) => T[]
->    : ^^^^^^^^^^^        ^     ^^^^^^^  
+>    : ^^^^^ ^^^^^               ^^^^^   
 >x : new (a: T) => T
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^^^^ ^^^^^ 
 >a : T
 >  : ^
 

tests/baselines/reference/assignmentCompatWithConstructSignatures4.types

@@ -50,9 +50,9 @@ module Errors {
 
         var a7: new (x: (arg: Base) => Derived) => (r: Base) => Derived2;
 >a7 : new (x: (arg: Base) => Derived) => (r: Base) => Derived2
->   : ^^^^^^^^      ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^^
+>   : ^^^^^^^^                      ^^^^^                     
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >r : Base
@@ -60,13 +60,13 @@ module Errors {
 
         var a8: new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;
 >a8 : new (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
->   : ^^^^^^^^      ^^^^     ^^^^^^^^^^^^       ^^^^     ^^^^^^^^^^^^    ^^^^     ^^^^^^^
+>   : ^^^^^^^^                      ^^^^^                       ^^^^^                    
 >x : (arg: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^    ^^^^^       
 >arg : Base
 >    : ^^^^
 >y : (arg2: Base) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^    ^^^^^       
 >arg2 : Base
 >     : ^^^^
 >r : Base
@@ -74,13 +74,13 @@ module Errors {
 
         var a10: new (...x: Base[]) => Base;
 >a10 : new (...x: Base[]) => Base
->    : ^^^^^^^^^^^^^^^  ^^^^^^^^^
+>    : ^^^^^^^^^^^      ^^^^^    
 >x : Base[]
 >  : ^^^^^^
 
         var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base;
 >a11 : new (x: { foo: string; }, y: { foo: string; bar: string; }) => Base
->    : ^^^^^^^^                ^^^^^                             ^^^^^^^^^
+>    : ^^^^^^^^                ^^^^^                             ^^^^^    
 >x : { foo: string; }
 >  : ^^^^^^^      ^^^
 >foo : string
@@ -94,7 +94,7 @@ module Errors {
 
         var a12: new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;
 >a12 : new (x: Array<Base>, y: Array<Derived2>) => Array<Derived>
->    : ^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^ 
+>    : ^^^^^^^^           ^^^^^               ^^^^^              
 >x : Base[]
 >  : ^^^^^^
 >y : Derived2[]
@@ -156,11 +156,11 @@ module Errors {
             };
         var a17: {
 >a17 : { new (x: { new <T extends Derived>(a: T): T; new <T_1 extends Base>(a: T_1): T_1; }): any[]; new (x: { new <T_2 extends Derived2>(a: T_2): T_2; new <T_3 extends Base>(a: T_3): T_3; }): any[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
+>    : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
 
                 new (x: {
 >x : { new <T extends Derived>(a: T): T; new <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
                     new <T extends Derived>(a: T): T;
 >a : T
@@ -173,7 +173,7 @@ module Errors {
                 }): any[];
                 new (x: {
 >x : { new <T extends Derived2>(a: T): T; new <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
                     new <T extends Derived2>(a: T): T;
 >a : T
@@ -188,7 +188,7 @@ module Errors {
 
         var b2: new <T, U>(x: T) => U[]; 
 >b2 : new <T, U>(x: T) => U[]
->   : ^^^^^^^^^^^^^^^^^^^^^  
+>   : ^^^^^ ^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -210,9 +210,9 @@ module Errors {
 
         var b7: new <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V;
 >b7 : new <T extends Base, U extends Derived, V extends Derived2>(x: (arg: T) => U) => (r: T) => V
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^    ^     ^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^             ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >r : T
@@ -236,13 +236,13 @@ module Errors {
 
         var b8: new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U; 
 >b8 : new <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^     ^^^^^^                            ^^^^^^    ^     ^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^             ^^^^^                             ^^^^^           
 >x : (arg: T) => U
->  : ^^^^^^^^^^^^^
+>  : ^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 >y : (arg2: { foo: number; }) => U
->  : ^^^^^^^                ^^^^^^
+>  : ^^^^^^^                ^^^^^ 
 >arg2 : { foo: number; }
 >     : ^^^^^^^      ^^^
 >foo : number
@@ -269,7 +269,7 @@ module Errors {
         
         var b10: new <T extends Derived>(...x: T[]) => T; 
 >b10 : new <T extends Derived>(...x: T[]) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^ 
 >x : T[]
 >  : ^^^
 
@@ -291,7 +291,7 @@ module Errors {
 
         var b11: new <T extends Derived>(x: T, y: T) => T; 
 >b11 : new <T extends Derived>(x: T, y: T) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 >y : T
@@ -315,7 +315,7 @@ module Errors {
 
         var b12: new <T extends Array<Derived2>>(x: Array<Base>, y: Array<Base>) => T; 
 >b12 : new <T extends Derived2[]>(x: Array<Base>, y: Array<Base>) => T
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^ ^^^^ ^^^^^^
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^           ^^^^^           ^^^^^ 
 >x : Base[]
 >  : ^^^^^^
 >y : Base[]
@@ -339,9 +339,9 @@ module Errors {
 
         var b15: new <T>(x: { a: T; b: T }) => T; 
 >b15 : new <T>(x: { a: T; b: T; }) => T
->    : ^^^^^^^^^^^     ^     ^   ^^^^^^
+>    : ^^^^^ ^^^^^               ^^^^^ 
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -365,9 +365,9 @@ module Errors {
 
         var b15a: new <T extends Base>(x: { a: T; b: T }) => number; 
 >b15a : new <T extends Base>(x: { a: T; b: T; }) => number
->     : ^^^^^^^^^^^^^^^^^^^^^^^^     ^     ^   ^^^^^      
+>     : ^^^^^ ^^^^^^^^^^^^^^^^^^               ^^^^^      
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -391,9 +391,9 @@ module Errors {
 
         var b16: new <T>(x: (a: T) => T) => T[];
 >b16 : new <T>(x: (a: T) => T) => T[]
->    : ^^^^^^^^^^^    ^     ^^^^^^^  
+>    : ^^^^^ ^^^^^           ^^^^^   
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -415,9 +415,9 @@ module Errors {
 
         var b17: new <T>(x: (a: T) => T) => any[];
 >b17 : new <T>(x: (a: T) => T) => any[]
->    : ^^^^^^^^^^^    ^     ^^^^^^     
+>    : ^^^^^ ^^^^^           ^^^^^     
 >x : (a: T) => T
->  : ^^^^^^^^^^^
+>  : ^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -445,13 +445,13 @@ module Errors {
         // target type has generic call signature
         var a2: new <T>(x: T) => T[];
 >a2 : new <T>(x: T) => T[]
->   : ^^^^^^^^^^^^^^^^^^  
+>   : ^^^^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
         var b2: new <T>(x: T) => string[];
 >b2 : new <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^^^^^        
+>   : ^^^^^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -474,13 +474,13 @@ module Errors {
         // target type has generic call signature
         var a3: new <T>(x: T) => string[];
 >a3 : new <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^^^^^        
+>   : ^^^^^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
         var b3: new <T>(x: T) => T[]; 
 >b3 : new <T>(x: T) => T[]
->   : ^^^^^^^^^^^^^^^^^^  
+>   : ^^^^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 

tests/baselines/reference/assignmentCompatWithConstructSignatures5.types

@@ -35,25 +35,25 @@ class OtherDerived extends Base { bing: string; }
 
 var a: new <T>(x: T) => T[];
 >a : new <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^^^^^  
+>  : ^^^^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
 var a2: new <T>(x: T) => string[];
 >a2 : new <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^^^^^        
+>   : ^^^^^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
 var a3: new <T>(x: T) => void;
 >a3 : new <T>(x: T) => void
->   : ^^^^^^^^^^^^^^^^^    
+>   : ^^^^^ ^^^^^ ^^^^^    
 >x : T
 >  : ^
 
 var a4: new <T, U>(x: T, y: U) => string;
 >a4 : new <T, U>(x: T, y: U) => string
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^      
+>   : ^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : U
@@ -61,29 +61,29 @@ var a4: new <T, U>(x: T, y: U) => string;
 
 var a5: new <T, U>(x: new (arg: T) => U) => T;
 >a5 : new <T, U>(x: new (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^          ^     ^^^^^^^
+>   : ^^^^^ ^^ ^^^^^                 ^^^^^ 
 >x : new (arg: T) => U
->  : ^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
 var a6: new <T extends Base>(x: new (arg: T) => Derived) => T;
 >a6 : new <T extends Base>(x: new (arg: T) => Derived) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^          ^     ^^^^^^^^^^^^^
+>   : ^^^^^ ^^^^^^^^^^^^^^^^^^                       ^^^^^ 
 >x : new (arg: T) => Derived
->  : ^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^ ^^^^^       
 >arg : T
 >    : ^
 
 var a11: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
 >a11 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
->    : ^^^^^^^^^^^       ^   ^^^^^       ^       ^   ^^^^^^^^^
+>    : ^^^^^ ^^^^^           ^^^^^                   ^^^^^    
 >x : { foo: T; }
->  : ^^^^^^^^^^^
+>  : ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >y : { foo: T; bar: T; }
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >bar : T
@@ -91,9 +91,9 @@ var a11: new <T>(x: { foo: T }, y: { foo: T; bar: T }) => Base;
 
 var a15: new <T>(x: { a: T; b: T }) => T[];
 >a15 : new <T>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^^^^^ ^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -101,9 +101,9 @@ var a15: new <T>(x: { a: T; b: T }) => T[];
 
 var a16: new <T extends Base>(x: { a: T; b: T }) => T[];
 >a16 : new <T extends Base>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^^^^^^^^^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^^^^^ ^^^^^^^^^^^^^^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -111,28 +111,28 @@ var a16: new <T extends Base>(x: { a: T; b: T }) => T[];
 
 var a17: {
 >a17 : { new <T extends Derived>(x: new (a: T) => T): T[]; new <T_1 extends Base>(x: new (a: T_1) => T_1): T_1[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^     ^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>    : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^               ^^^   ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     new <T extends Derived>(x: new (a: T) => T): T[];
 >x : new (a: T) => T
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^^^^ ^^^^^ 
 >a : T
 >  : ^
 
     new <T extends Base>(x: new (a: T) => T): T[];        
 >x : new (a: T) => T
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^^^^ ^^^^^ 
 >a : T
 >  : ^
 
 };
 var a18: {
 >a18 : { new (x: { new <T extends Derived>(a: T): T; new <T_1 extends Base>(a: T_1): T_1; }): any[]; new (x: { new <T_2 extends Derived2>(a: T_2): T_2; new <T_3 extends Base>(a: T_3): T_3; }): any[]; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
+>    : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^
 
     new (x: {
 >x : { new <T extends Derived>(a: T): T; new <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         new <T extends Derived>(a: T): T;
 >a : T
@@ -145,7 +145,7 @@ var a18: {
     }): any[];
     new (x: {
 >x : { new <T extends Derived2>(a: T): T; new <T_1 extends Base>(a: T_1): T_1; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         new <T extends Derived2>(a: T): T;
 >a : T
@@ -160,7 +160,7 @@ var a18: {
 
 var b: new <T>(x: T) => T[]; 
 >b : new <T>(x: T) => T[]
->  : ^^^^^^^^^^^^^^^^^^  
+>  : ^^^^^ ^^^^^ ^^^^^   
 >x : T
 >  : ^
 
@@ -182,7 +182,7 @@ b = a; // ok
 
 var b2: new <T>(x: T) => string[]; 
 >b2 : new <T>(x: T) => string[]
->   : ^^^^^^^^^^^^^^^^^        
+>   : ^^^^^ ^^^^^ ^^^^^        
 >x : T
 >  : ^
 
@@ -204,7 +204,7 @@ b2 = a2; // ok
 
 var b3: new <T>(x: T) => T; 
 >b3 : new <T>(x: T) => T
->   : ^^^^^^^^^^^^^^^^^^
+>   : ^^^^^ ^^^^^ ^^^^^ 
 >x : T
 >  : ^
 
@@ -226,7 +226,7 @@ b3 = a3; // ok
 
 var b4: new <T, U>(x: T, y: U) => string; 
 >b4 : new <T, U>(x: T, y: U) => string
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^      
+>   : ^^^^^ ^^ ^^^^^ ^^^^^ ^^^^^      
 >x : T
 >  : ^
 >y : U
@@ -250,9 +250,9 @@ b4 = a4; // ok
 
 var b5: new <T, U>(x: new (arg: T) => U) => T; 
 >b5 : new <T, U>(x: new (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^          ^     ^^^^^^^
+>   : ^^^^^ ^^ ^^^^^                 ^^^^^ 
 >x : new (arg: T) => U
->  : ^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -274,9 +274,9 @@ b5 = a5; // ok
 
 var b6: new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T; 
 >b6 : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^     ^^^^^^^
+>   : ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^                 ^^^^^ 
 >x : new (arg: T) => U
->  : ^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^^^^ ^^^^^ 
 >arg : T
 >    : ^
 
@@ -298,13 +298,13 @@ b6 = a6; // ok
 
 var b11: new <T, U>(x: { foo: T }, y: { foo: U; bar: U }) => Base; 
 >b11 : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
->    : ^^^^^^^^^^^^^^       ^   ^^^^^       ^       ^   ^^^^^^^^^
+>    : ^^^^^ ^^ ^^^^^           ^^^^^                   ^^^^^    
 >x : { foo: T; }
->  : ^^^^^^^^^^^
+>  : ^^^^^^^ ^^^
 >foo : T
 >    : ^
 >y : { foo: U; bar: U; }
->  : ^^^^^^^^^^^^^^^^^^^
+>  : ^^^^^^^ ^^^^^^^ ^^^
 >foo : U
 >    : ^
 >bar : U
@@ -328,9 +328,9 @@ b11 = a11; // ok
 
 var b15: new <U, V>(x: { a: U; b: V; }) => U[]; 
 >b15 : new <U, V>(x: { a: U; b: V; }) => U[]
->    : ^^^^^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^^^^^ ^^ ^^^^^               ^^^^^   
 >x : { a: U; b: V; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : U
 >  : ^
 >b : V
@@ -354,9 +354,9 @@ b15 = a15; // ok
 
 var b16: new <T>(x: { a: T; b: T }) => T[]; 
 >b16 : new <T>(x: { a: T; b: T; }) => T[]
->    : ^^^^^^^^^^^     ^     ^   ^^^^^^  
+>    : ^^^^^ ^^^^^               ^^^^^   
 >x : { a: T; b: T; }
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^
 >a : T
 >  : ^
 >b : T
@@ -380,9 +380,9 @@ b15 = a16; // ok
 
 var b17: new <T>(x: new (a: T) => T) => T[]; 
 >b17 : new <T>(x: new (a: T) => T) => T[]
->    : ^^^^^^^^^^^        ^     ^^^^^^^  
+>    : ^^^^^ ^^^^^               ^^^^^   
 >x : new (a: T) => T
->  : ^^^^^^^^^^^^^^^
+>  : ^^^^^^^^ ^^^^^ 
 >a : T
 >  : ^
 
@@ -404,9 +404,9 @@ b17 = a17; // ok
 
 var b18: new (x: new <T>(a: T) => T) => any[]; 
 >b18 : new (x: new <T>(a: T) => T) => any[]
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     
+>    : ^^^^^^^^^^^^^ ^^^^^ ^^^^^ ^^^^^     
 >x : new <T>(a: T) => T
->  : ^^^^^^^^^^^^^^^^^^
+>  : ^^^^^ ^^^^^ ^^^^^ 
 >a : T
 >  : ^