Accept baselines.

tests/baselines/reference/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types

@@ -83,8 +83,8 @@ var p = new A.Point(0, 0); // unexpected error here, bug 840000
 >  : ^^^^^^^^
 >Point : typeof A.Point
 >      : ^^^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
  

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types

@@ -75,8 +75,8 @@ var p = new A.Point(0, 0); // unexpected error here, bug 840000
 >  : ^^^^^^^^
 >Point : typeof A.Point
 >      : ^^^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
 

tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types

@@ -44,8 +44,8 @@ module clodule {
 >        : ^^^^^^^^^^^^^^
 >sfn : (id: string) => number
 >    : ^  ^^      ^^^^^^^^^^^
->'a' : "a"
->    : ^^^
+>'a' : string
+>    : ^^^^^^
     }
 }
 

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndExportedFunctionThatShareAName.types

@@ -18,12 +18,12 @@ class Point {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 module Point {
@@ -57,12 +57,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
     }
 
     export module Point {

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -18,12 +18,12 @@ class Point {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 module Point {
@@ -59,12 +59,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
     }
 
     export module Point {

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndExportedVarThatShareAName.types

@@ -18,12 +18,12 @@ class Point {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 module Point {
@@ -59,12 +59,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
     }
 
     export module Point {

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

@@ -18,12 +18,12 @@ class Point {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 module Point {
@@ -59,12 +59,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
     }
 
     export module Point {

tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRoot.types

@@ -69,10 +69,10 @@ module X.Y {
 >                : ^^^^^
 >Point : typeof Point
 >      : ^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
     }
 }
 
@@ -93,10 +93,10 @@ var cl = new X.Y.Point(1,1);
 >  : ^^^^^^^^^^
 >Point : typeof X.Y.Point
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
+>1 : number
+>  : ^^^^^^
 
 var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ?
 >cl : X.Y.Point

tests/baselines/reference/ClassAndModuleWithSameNameAndCommonRootES6.types

@@ -69,10 +69,10 @@ module X.Y {
 >                : ^^^^^
 >Point : typeof Point
 >      : ^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
     }
 }
 
@@ -93,10 +93,10 @@ var cl = new X.Y.Point(1,1);
 >  : ^^^^^^^^^^
 >Point : typeof X.Y.Point
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
+>1 : number
+>  : ^^^^^^
 
 var cl = X.Y.Point.Origin; // error not expected here same as bug 83996 ?
 >cl : X.Y.Point

tests/baselines/reference/ES5For-of30.types

@@ -12,26 +12,26 @@ var tuple: [number, string] = [2, "3"];
 >      : ^^^^^^^^^^^^^^^^
 >[2, "3"] : [number, string]
 >         : ^^^^^^^^^^^^^^^^
->2 : 2
->  : ^
->"3" : "3"
->    : ^^^
+>2 : number
+>  : ^^^^^^
+>"3" : string
+>    : ^^^^^^
 
 for ([a = 1, b = ""] of tuple) {
 >[a = 1, b = ""] : [number, string]
 >                : ^^^^^^^^^^^^^^^^
->a = 1 : 1
->      : ^
+>a = 1 : number
+>      : ^^^^^^
 >a : string
 >  : ^^^^^^
->1 : 1
->  : ^
->b = "" : ""
->       : ^^
+>1 : number
+>  : ^^^^^^
+>b = "" : string
+>       : ^^^^^^
 >b : number
 >  : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 >tuple : [number, string]
 >      : ^^^^^^^^^^^^^^^^
 

tests/baselines/reference/ES5For-of31.types

@@ -12,20 +12,20 @@ for ({ a: b = 1, b: a = ""} of []) {
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : number
 >  : ^^^^^^
->b = 1 : 1
->      : ^
+>b = 1 : number
+>      : ^^^^^^
 >b : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 >b : string
 >  : ^^^^^^
->a = "" : ""
->       : ^^
+>a = "" : string
+>       : ^^^^^^
 >a : string
 >  : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 

tests/baselines/reference/ES5For-of37.types

@@ -46,8 +46,8 @@ for (const i of [0, 1, 2, 3, 4]) {
 >                 : ^^^^^
 >Error : ErrorConstructor
 >      : ^^^^^^^^^^^^^^^^
->'ERR' : "ERR"
->      : ^^^^^
+>'ERR' : string
+>      : ^^^^^^
             }
         }
         console.log(i);

tests/baselines/reference/ES5For-ofTypeCheck13.types

@@ -18,8 +18,8 @@ strSet.add('Hello')
 >       : ^^^^^^^^^^^
 >add : (value: string) => Set<string>
 >    : ^     ^^^^^^^^^^^^^^^^^^^^^^^^
->'Hello' : "Hello"
->        : ^^^^^^^
+>'Hello' : string
+>        : ^^^^^^
 
 strSet.add('World')
 >strSet.add('World') : Set<string>
@@ -30,8 +30,8 @@ strSet.add('World')
 >       : ^^^^^^^^^^^
 >add : (value: string) => Set<string>
 >    : ^     ^^^^^^^^^^^^^^^^^^^^^^^^
->'World' : "World"
->        : ^^^^^^^
+>'World' : string
+>        : ^^^^^^
 
 for (const str of strSet) { }
 >str : any

tests/baselines/reference/ES5For-ofTypeCheck3.types

@@ -6,10 +6,10 @@ var tuple: [string, number] = ["", 0];
 >      : ^^^^^^^^^^^^^^^^
 >["", 0] : [string, number]
 >        : ^^^^^^^^^^^^^^^^
->"" : ""
->   : ^^
->0 : 0
->  : ^
+>"" : string
+>   : ^^^^^^
+>0 : number
+>  : ^^^^^^
 
 for (var v of tuple) { }
 >v : string | number

tests/baselines/reference/ES5for-of32.types

@@ -40,12 +40,12 @@ for (let num of array) {
 >      : ^^^^^^^^
 >[4,5,6] : number[]
 >        : ^^^^^^^^
->4 : 4
->  : ^
->5 : 5
->  : ^
->6 : 6
->  : ^
+>4 : number
+>  : ^^^^^^
+>5 : number
+>  : ^^^^^^
+>6 : number
+>  : ^^^^^^
     }
     
     sum += num;

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types

@@ -61,8 +61,8 @@ var y = new enumdule.Point(0, 0);
 >         : ^^^^^^^^^^^^^^^
 >Point : typeof enumdule.Point
 >      : ^^^^^^^^^^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
 

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -25,12 +25,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export class Point3d extends Point {
 >Point3d : Point3d
@@ -50,16 +50,16 @@ module A {
 >                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >z : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export class Line<TPoint extends Point>{
 >Line : Line<TPoint>

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -25,12 +25,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export class Point3d extends Point {
 >Point3d : Point3d
@@ -50,16 +50,16 @@ module A {
 >                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >z : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export class Line<TPoint extends Point>{
 >Line : Line<TPoint>

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -44,12 +44,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >p : Point
 >  : ^^^^^
     }

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

@@ -44,12 +44,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >p : Point
 >  : ^^^^^
     }

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

@@ -44,12 +44,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >p : Point
 >  : ^^^^^
     }

tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -22,12 +22,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export interface Point3d extends Point {
         z: number;
@@ -42,16 +42,16 @@ module A {
 >                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >z : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export interface Line<TPoint extends Point>{
         new (start: TPoint, end: TPoint);

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.types

@@ -22,12 +22,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export interface Point3d extends Point {
         z: number;
@@ -42,16 +42,16 @@ module A {
 >                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >z : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export interface Line<TPoint extends Point>{
         new (start: TPoint, end: TPoint);

tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types

@@ -27,10 +27,10 @@ module A {
 >                : ^^^^^
 >Point : typeof Point
 >      : ^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
 
         export class Line {
 >Line : Line
@@ -59,12 +59,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >p : Point
 >  : ^^^^^
             }

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.types

@@ -23,12 +23,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
 >Unity : { start: Point; end: Point; }
@@ -41,19 +41,19 @@ module A {
 >                : ^^^^^
 >Point : typeof Point
 >      : ^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
 >end : Point
 >    : ^^^^^
 >new Point(1, 0) : Point
 >                : ^^^^^
 >Point : typeof Point
 >      : ^^^^^^^^^^^^
->1 : 1
->  : ^
->0 : 0
->  : ^
+>1 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
 }
 

tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.types

@@ -23,11 +23,11 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 

tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.types

@@ -23,12 +23,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     interface Point3d extends Point {
         z: number;
@@ -44,15 +44,15 @@ module A {
 >                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >z : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 

tests/baselines/reference/ModuleAndClassWithSameNameAndCommonRoot.types

@@ -18,10 +18,10 @@ module X.Y {
 >                : ^^^^^
 >Point : typeof Point
 >      : ^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
     }
 }
 

tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types

@@ -61,8 +61,8 @@ var y = new enumdule.Point(0, 0);
 >         : ^^^^^^^^^^^^^^^
 >Point : typeof enumdule.Point
 >      : ^^^^^^^^^^^^^^^^^^^^^
->0 : 0
->  : ^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
+>0 : number
+>  : ^^^^^^
 

tests/baselines/reference/ModuleWithExportedAndNonExportedImportAlias.types

@@ -64,12 +64,12 @@ module Geometry {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     // this is valid since B.Line _is_ visible outside Geometry
     export var Unit: Lines.Line = new Lines.Line(Origin, { x: 1, y: 0 });
@@ -91,12 +91,12 @@ module Geometry {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 // expected to work since all are exported

tests/baselines/reference/NonInitializedExportInInternalModule.types

@@ -106,14 +106,14 @@ module Inner {
     export var c1: string = 'a';
 >c1 : string
 >   : ^^^^^^
->'a' : "a"
->    : ^^^
+>'a' : string
+>    : ^^^^^^
 
     export let d1: number = 1;
 >d1 : number
 >   : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     class D {}
 >D : D

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types

@@ -53,12 +53,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 === part2.ts ===
@@ -70,8 +70,8 @@ module A {
     var Origin: string = "0,0";
 >Origin : string
 >       : ^^^^^^
->"0,0" : "0,0"
->      : ^^^^^
+>"0,0" : string
+>      : ^^^^^^
 
     export module Utils {
 >Utils : typeof Utils
@@ -176,11 +176,11 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedLocalVarsOfTheSameName.types

@@ -54,12 +54,12 @@ export module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 === part2.ts ===

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types

@@ -74,12 +74,12 @@ module otherRoot {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
         export module Utils {
 >Utils : typeof Utils

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types

@@ -60,12 +60,12 @@ module A {
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     export module Utils {
 >Utils : typeof Utils
@@ -170,11 +170,11 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 

tests/baselines/reference/VariableDeclaration10_es6.types

@@ -4,6 +4,6 @@
 let a: number = 1
 >a : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 

tests/baselines/reference/VariableDeclaration5_es6.types

@@ -4,6 +4,6 @@
 const a: number = 1
 >a : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 

tests/baselines/reference/abstractPropertyInConstructor.types

@@ -50,16 +50,16 @@ abstract class AbstractClass {
 >    : ^^^^^^
 
             this.prop = "Hello World";
->this.prop = "Hello World" : "Hello World"
->                          : ^^^^^^^^^^^^^
+>this.prop = "Hello World" : string
+>                          : ^^^^^^
 >this.prop : string
 >          : ^^^^^^
 >this : this
 >     : ^^^^
 >prop : string
 >     : ^^^^^^
->"Hello World" : "Hello World"
->              : ^^^^^^^^^^^^^
+>"Hello World" : string
+>              : ^^^^^^
         }
         this.cb(str);
 >this.cb(str) : void
@@ -235,8 +235,8 @@ abstract class DerivedAbstractClass extends AbstractClass {
 >     : ^^^^
 >method : (num: number) => void
 >       : ^   ^^      ^^^^^    
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
         // OK, references are to another instance
         other.cb(other.prop);
@@ -383,8 +383,8 @@ class User {
 >  : ^^^^^^^^^^^^^
 >cb : (s: string) => void
 >   : ^ ^^      ^^^^^    
->"hi" : "hi"
->     : ^^^^
+>"hi" : string
+>     : ^^^^^^
 
         a.method(12);
 >a.method(12) : void
@@ -395,8 +395,8 @@ class User {
 >  : ^^^^^^^^^^^^^
 >method : (num: number) => void
 >       : ^   ^^      ^^^^^    
->12 : 12
->   : ^^
+>12 : number
+>   : ^^^^^^
 
         a.method2();
 >a.method2() : void

tests/baselines/reference/abstractPropertyNegative.types

@@ -150,8 +150,8 @@ abstract class AbstractAccessorMismatch {
     get p2(): string { return "should work"; }
 >p2 : string
 >   : ^^^^^^
->"should work" : "should work"
->              : ^^^^^^^^^^^^^
+>"should work" : string
+>              : ^^^^^^
 
     abstract set p2(val: string);
 >p2 : string

tests/baselines/reference/acceptSymbolAsWeakType.types

@@ -8,8 +8,8 @@ const s: symbol = Symbol('s');
 >            : ^^^^^^^^^^^^^
 >Symbol : SymbolConstructor
 >       : ^^^^^^^^^^^^^^^^^
->'s' : "s"
->    : ^^^
+>'s' : string
+>    : ^^^^^^
 
 const ws = new WeakSet([s]);
 >ws : WeakSet<symbol>

tests/baselines/reference/accessorAccidentalCallDiagnostic.types

@@ -9,8 +9,8 @@ class Test24554 {
     get property(): number { return 1; }
 >property : number
 >         : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 }
 function test24554(x: Test24554) {
 >test24554 : (x: Test24554) => any

tests/baselines/reference/accessorsAreNotContextuallyTyped.types

@@ -25,8 +25,8 @@ class C {
 >                  : ^ ^^      ^^^^^^^^^^^
 >x : string
 >  : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
     }
 }
 
@@ -45,6 +45,6 @@ var r = c.x(''); // string
 >  : ^
 >x : (a: string) => string
 >  : ^ ^^      ^^^^^      
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 

tests/baselines/reference/accessors_spec_section-4.5_error-cases.types

@@ -14,14 +14,14 @@ class LanguageSpec_section_4_5_error_cases {
     public get AnnotatedSetter_SetterFirst() { return ""; }
 >AnnotatedSetter_SetterFirst : number
 >                            : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 
     public get AnnotatedSetter_SetterLast() { return ""; }
 >AnnotatedSetter_SetterLast : number
 >                           : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 
     public set AnnotatedSetter_SetterLast(a: number) { }
 >AnnotatedSetter_SetterLast : number
@@ -32,36 +32,36 @@ class LanguageSpec_section_4_5_error_cases {
     public get AnnotatedGetter_GetterFirst(): string { return ""; }
 >AnnotatedGetter_GetterFirst : string
 >                            : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 
     public set AnnotatedGetter_GetterFirst(aStr) { aStr = 0; }
 >AnnotatedGetter_GetterFirst : string
 >                            : ^^^^^^
 >aStr : string
 >     : ^^^^^^
->aStr = 0 : 0
->         : ^
+>aStr = 0 : number
+>         : ^^^^^^
 >aStr : string
 >     : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     public set AnnotatedGetter_GetterLast(aStr) { aStr = 0; }
 >AnnotatedGetter_GetterLast : string
 >                           : ^^^^^^
 >aStr : string
 >     : ^^^^^^
->aStr = 0 : 0
->         : ^
+>aStr = 0 : number
+>         : ^^^^^^
 >aStr : string
 >     : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     public get AnnotatedGetter_GetterLast(): string { return ""; }
 >AnnotatedGetter_GetterLast : string
 >                           : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 }

tests/baselines/reference/addMoreCallSignaturesToBaseSignature2.types

@@ -24,6 +24,6 @@ var kitty = a(1);
 >     : ^^^^^^
 >a : Bar
 >  : ^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 

tests/baselines/reference/aliasOnMergedModuleInterface.types

@@ -19,8 +19,8 @@ z.bar("hello"); // This should be ok
 >  : ^^^
 >bar : (name: string) => foo.A
 >    : ^    ^^      ^^^^^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
+>"hello" : string
+>        : ^^^^^^
 
 var x: foo.A = foo.bar("hello"); // foo.A should be ok but foo.bar should be error
 >x : foo.A

tests/baselines/reference/allowImportClausesToMergeWithTypes.types

@@ -29,8 +29,8 @@ const x: zzz = { x: "" };
 >          : ^^^^^^^^^^^^^^
 >x : string
 >  : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 
 zzz;
 >zzz : 123
@@ -54,8 +54,8 @@ const x: zzz = { x: "" };
 >          : ^^^^^^^^^^^^^^
 >x : string
 >  : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 
 zzz;
 >zzz : 123

tests/baselines/reference/allowsImportingTsExtension.types

@@ -31,8 +31,8 @@ const aPromise = import("./a.ts"); // error
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("./a.ts") : Promise<typeof import("a")>
 >                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
->"./a.ts" : "./a.ts"
->         : ^^^^^^^^
+>"./a.ts" : string
+>         : ^^^^^^
 
 === c.ts ===
 import type { A } from "./a.d.ts"; // ok
@@ -55,6 +55,6 @@ const aPromise = import("./a.d.ts"); // error
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >import("./a.d.ts") : Promise<typeof import("a")>
 >                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
->"./a.d.ts" : "./a.d.ts"
->           : ^^^^^^^^^^
+>"./a.d.ts" : string
+>           : ^^^^^^
 

tests/baselines/reference/ambientRequireFunction(module=commonjs).types

@@ -10,8 +10,8 @@ const fs = require("fs");
 >              : ^^^^^^^^^
 >require : (moduleName: string) => any
 >        : ^          ^^      ^^^^^   
->"fs" : "fs"
->     : ^^^^
+>"fs" : string
+>     : ^^^^^^
 
 const text = fs.readFileSync("/a/b/c");
 >text : string
@@ -24,8 +24,8 @@ const text = fs.readFileSync("/a/b/c");
 >   : ^^^^^^^^^
 >readFileSync : (s: string) => string
 >             : ^ ^^      ^^^^^      
->"/a/b/c" : "/a/b/c"
->         : ^^^^^^^^
+>"/a/b/c" : string
+>         : ^^^^^^
 
 === node.d.ts ===
 declare function require(moduleName: string): any;

tests/baselines/reference/ambientRequireFunction(module=preserve).types

@@ -10,8 +10,8 @@ const fs = require("fs");
 >              : ^^^^^^^^^
 >require : (moduleName: string) => any
 >        : ^          ^^      ^^^^^   
->"fs" : "fs"
->     : ^^^^
+>"fs" : string
+>     : ^^^^^^
 
 const text = fs.readFileSync("/a/b/c");
 >text : string
@@ -24,8 +24,8 @@ const text = fs.readFileSync("/a/b/c");
 >   : ^^^^^^^^^
 >readFileSync : (s: string) => string
 >             : ^ ^^      ^^^^^      
->"/a/b/c" : "/a/b/c"
->         : ^^^^^^^^
+>"/a/b/c" : string
+>         : ^^^^^^
 
 === node.d.ts ===
 declare function require(moduleName: string): any;

tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types

@@ -76,8 +76,8 @@ class TestClass2 {
 >x : any
 
         return 0;
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
     }
  
     public foo(x: string): number;

tests/baselines/reference/ambiguousOverload.types

@@ -32,8 +32,8 @@ var x: number = foof("s", null);
 >                : ^^^^^^
 >foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
 >     : ^^^   ^^      ^^ ^^^^^^^^      ^^^   ^^      ^^ ^^^^^^^^      ^^^
->"s" : "s"
->    : ^^^
+>"s" : string
+>    : ^^^^^^
 
 var y: string = foof("s", null);
 >y : string
@@ -42,8 +42,8 @@ var y: string = foof("s", null);
 >                : ^^^^^^
 >foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
 >     : ^^^   ^^      ^^ ^^^^^^^^      ^^^   ^^      ^^ ^^^^^^^^      ^^^
->"s" : "s"
->    : ^^^
+>"s" : string
+>    : ^^^^^^
 
 function foof2(bar: string, x): string;
 >foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
@@ -76,8 +76,8 @@ var x2: string = foof2("s", null);
 >                 : ^^^^^^
 >foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
 >      : ^^^   ^^      ^^ ^^^^^^^^      ^^^   ^^      ^^ ^^^^^^^^      ^^^
->"s" : "s"
->    : ^^^
+>"s" : string
+>    : ^^^^^^
 
 var y2: number = foof2("s", null);
 >y2 : number
@@ -86,6 +86,6 @@ var y2: number = foof2("s", null);
 >                 : ^^^^^^
 >foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
 >      : ^^^   ^^      ^^ ^^^^^^^^      ^^^   ^^      ^^ ^^^^^^^^      ^^^
->"s" : "s"
->    : ^^^
+>"s" : string
+>    : ^^^^^^
 

tests/baselines/reference/amdLikeInputDeclarationEmit.types

@@ -37,12 +37,12 @@ define("lib/ExtendedClass", ["deps/BaseClass"],
 >define("lib/ExtendedClass", ["deps/BaseClass"], /** * {typeof import("deps/BaseClass")} * @param  {typeof import("deps/BaseClass")} BaseClass  * @returns  */(BaseClass) => {            const ExtendedClass = BaseClass.extends({        f: function() {            return "something";        }    });    // Exports the module in a way tsc recognize class export     const module = {};    module.exports = ExtendedClass    return module.exports;}) : any
 >define : <T = unknown>(name: string, modules: string[], ready: (...modules: unknown[]) => T) => any
 >       : ^ ^^^^^^^^^^^^    ^^      ^^       ^^        ^^     ^^                            ^^^^^^^^
->"lib/ExtendedClass" : "lib/ExtendedClass"
->                    : ^^^^^^^^^^^^^^^^^^^
+>"lib/ExtendedClass" : string
+>                    : ^^^^^^
 >["deps/BaseClass"] : string[]
 >                   : ^^^^^^^^
->"deps/BaseClass" : "deps/BaseClass"
->                 : ^^^^^^^^^^^^^^^^
+>"deps/BaseClass" : string
+>                 : ^^^^^^
 
 /**
  * {typeof import("deps/BaseClass")}

tests/baselines/reference/amdModuleName1.types

@@ -12,16 +12,16 @@ class Foo {
 
     constructor() {
         this.x = 5;
->this.x = 5 : 5
->           : ^
+>this.x = 5 : number
+>           : ^^^^^^
 >this.x : number
 >       : ^^^^^^
 >this : this
 >     : ^^^^
 >x : number
 >  : ^^^^^^
->5 : 5
->  : ^
+>5 : number
+>  : ^^^^^^
     }
 }
 export = Foo;

tests/baselines/reference/amdModuleName2.types

@@ -13,16 +13,16 @@ class Foo {
 
     constructor() {
         this.x = 5;
->this.x = 5 : 5
->           : ^
+>this.x = 5 : number
+>           : ^^^^^^
 >this.x : number
 >       : ^^^^^^
 >this : this
 >     : ^^^^
 >x : number
 >  : ^^^^^^
->5 : 5
->  : ^
+>5 : number
+>  : ^^^^^^
     }
 }
 export = Foo;

tests/baselines/reference/anonterface.types

@@ -61,8 +61,8 @@ c.m(function(n) { return "hello: "+n; },18);
 >          : ^^^^^^^^^
 >n : number
 >  : ^^^^^^
->18 : 18
->   : ^^
+>18 : number
+>   : ^^^^^^
 
 
 

tests/baselines/reference/argsInScope.types

@@ -57,10 +57,10 @@ c.P(1,2,3);
 >  : ^
 >P : (ii: number, j: number, k: number) => void
 >  : ^  ^^      ^^ ^^      ^^ ^^      ^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 

tests/baselines/reference/argumentExpressionContextualTyping.types

@@ -101,10 +101,10 @@ var o1: { x: [string, number], y: { c: boolean, d: string, e: number } } = { x:
 >  : ^^^^^^^^^^^^^^^^
 >["string", 1] : [string, number]
 >              : ^^^^^^^^^^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
->1 : 1
->  : ^
+>"string" : string
+>         : ^^^^^^
+>1 : number
+>  : ^^^^^^
 >y : { c: true; d: string; e: number; }
 >  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >{ c: true, d: "world", e: 3 } : { c: true; d: string; e: number; }
@@ -115,12 +115,12 @@ var o1: { x: [string, number], y: { c: boolean, d: string, e: number } } = { x:
 >     : ^^^^
 >d : string
 >  : ^^^^^^
->"world" : "world"
->        : ^^^^^^^
+>"world" : string
+>        : ^^^^^^
 >e : number
 >  : ^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 foo(o1); // Not error since x has contextual type of tuple namely [string, number]
 >foo(o1) : void
@@ -179,10 +179,10 @@ var tuple: [string, number, boolean] = ["string", 1, true];
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >["string", 1, true] : [string, number, true]
 >                    : ^^^^^^^^^^^^^^^^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
->1 : 1
->  : ^
+>"string" : string
+>         : ^^^^^^
+>1 : number
+>  : ^^^^^^
 >true : true
 >     : ^^^^
 
@@ -201,10 +201,10 @@ baz(["string", 1, true]);
 >    : ^ ^^                         ^^^^^^^^^
 >["string", 1, true] : [string, number, true]
 >                    : ^^^^^^^^^^^^^^^^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
->1 : 1
->  : ^
+>"string" : string
+>         : ^^^^^^
+>1 : number
+>  : ^^^^^^
 >true : true
 >     : ^^^^
 
@@ -223,10 +223,10 @@ baz(["string", 1, true, ...array]);  // Error
 >    : ^ ^^                         ^^^^^^^^^
 >["string", 1, true, ...array] : [string, number, true, ...(string | number | boolean)[]]
 >                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
->1 : 1
->  : ^
+>"string" : string
+>         : ^^^^^^
+>1 : number
+>  : ^^^^^^
 >true : true
 >     : ^^^^
 >...array : string | number | boolean

tests/baselines/reference/argumentsObjectCreatesRestForJs.types

@@ -67,8 +67,8 @@ jsdocced(1);
 >            : ^^^^
 >jsdocced : (x: number, ...args: any[]) => void
 >         : ^ ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 function dontDoubleRest(x, ...y) { arguments; }
 >dontDoubleRest : (x: any, ...y: any[]) => void

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

@@ -30,8 +30,8 @@ declare const itNum: Iterable<number>
 >  : ^^^^^^
 >rest : Iterable<number>
 >     : ^^^^^^^^^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >...itNum : Iterable<number>
 >         : ^^^^^^^^^^^^^^^^
 >itNum : Iterable<number>
@@ -48,8 +48,8 @@ declare const itNum: Iterable<number>
 >  : ^^^^^^
 >rest : [boolean, ...Iterable<number>[]]
 >     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >true : true
 >     : ^^^^
 >...itNum : Iterable<number>

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

@@ -30,8 +30,8 @@ declare const itNum: Iterable<number>
 >  : ^^^^^^
 >rest : number[]
 >     : ^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >...itNum : number
 >         : ^^^^^^
 >itNum : Iterable<number>
@@ -48,8 +48,8 @@ declare const itNum: Iterable<number>
 >  : ^^^^^^
 >rest : [boolean, ...number[]]
 >     : ^^^^^^^^^^^^^^^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >true : true
 >     : ^^^^
 >...itNum : number

tests/baselines/reference/arrayAssignmentTest3.types

@@ -30,8 +30,8 @@ var xx = new a(null, 7, new B());
 >                        : ^
 >a : typeof a
 >  : ^^^^^^^^
->7 : 7
->  : ^
+>7 : number
+>  : ^^^^^^
 >new B() : B
 >        : ^
 >B : typeof B

tests/baselines/reference/arrayAugment.types

@@ -28,8 +28,8 @@ var y = x.split(4);
 >  : ^^^^^^^^
 >split : (parts: number) => string[][]
 >      : ^     ^^      ^^^^^^^^^^^^^^^
->4 : 4
->  : ^
+>4 : number
+>  : ^^^^^^
 
 var y: string[][]; // Expect no error here
 >y : string[][]

tests/baselines/reference/arrayBestCommonTypes.types

@@ -404,8 +404,8 @@ module EmptyTypes {
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->7 : 7
->  : ^
+>7 : number
+>  : ^^^^^^
 >y : derived
 >  : ^^^^^^^
 >new derived() : derived
@@ -416,8 +416,8 @@ module EmptyTypes {
 >                        : ^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->5 : 5
->  : ^
+>5 : number
+>  : ^^^^^^
 >y : base
 >  : ^^^^
 >new base() : base
@@ -484,8 +484,8 @@ module EmptyTypes {
 >                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : string
 >  : ^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >y : derived
 >  : ^^^^^^^
 >new derived() : derived
@@ -1086,8 +1086,8 @@ module NonEmptyTypes {
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->7 : 7
->  : ^
+>7 : number
+>  : ^^^^^^
 >y : derived
 >  : ^^^^^^^
 >new derived() : derived
@@ -1098,8 +1098,8 @@ module NonEmptyTypes {
 >                        : ^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->5 : 5
->  : ^
+>5 : number
+>  : ^^^^^^
 >y : base
 >  : ^^^^
 >new base() : base
@@ -1166,8 +1166,8 @@ module NonEmptyTypes {
 >                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : string
 >  : ^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >y : derived
 >  : ^^^^^^^
 >new derived() : derived

tests/baselines/reference/arrayConstructors1.types

@@ -14,8 +14,8 @@ x = new Array(1);
 >             : ^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 x = new Array('hi', 'bye'); 
 >x = new Array('hi', 'bye') : string[]
@@ -26,10 +26,10 @@ x = new Array('hi', 'bye');
 >                       : ^^^^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->'hi' : "hi"
->     : ^^^^
->'bye' : "bye"
->      : ^^^^^
+>'hi' : string
+>     : ^^^^^^
+>'bye' : string
+>      : ^^^^^^
 
 x = new Array<string>('hi', 'bye');
 >x = new Array<string>('hi', 'bye') : string[]
@@ -40,10 +40,10 @@ x = new Array<string>('hi', 'bye');
 >                               : ^^^^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->'hi' : "hi"
->     : ^^^^
->'bye' : "bye"
->      : ^^^^^
+>'hi' : string
+>     : ^^^^^^
+>'bye' : string
+>      : ^^^^^^
 
 var y: number[];
 >y : number[]
@@ -58,8 +58,8 @@ y = new Array(1);
 >             : ^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 y = new Array(1,2);
 >y = new Array(1,2) : number[]
@@ -70,10 +70,10 @@ y = new Array(1,2);
 >               : ^^^^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
 
 y = new Array<number>(1, 2);
 >y = new Array<number>(1, 2) : number[]
@@ -84,8 +84,8 @@ y = new Array<number>(1, 2);
 >                        : ^^^^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
 

tests/baselines/reference/arrayEvery.types

@@ -6,8 +6,8 @@ const foo: (number | string)[] = ['aaa'];
 >    : ^^^^^^^^^^^^^^^^^^^
 >['aaa'] : string[]
 >        : ^^^^^^^^
->'aaa' : "aaa"
->      : ^^^^^
+>'aaa' : string
+>      : ^^^^^^
 
 const isString = (x: unknown): x is string => typeof x === 'string';
 >isString : (x: unknown) => x is string
@@ -50,7 +50,7 @@ if (foo.every(isString)) {
 >  : ^
 >slice : (start?: number, end?: number) => string
 >      : ^     ^^^      ^^   ^^^      ^^^^^      
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 

tests/baselines/reference/arrayFrom.types

@@ -35,8 +35,8 @@ const inputALike: ArrayLike<A> = { length: 0 };
 >              : ^^^^^^^^^^^^^^^^^^^
 >length : number
 >       : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
 const inputARand = getEither(inputA, inputALike);
 >inputARand : ArrayLike<A> | Iterable<A>

tests/baselines/reference/arrayFromAsync.types

@@ -88,8 +88,8 @@ const arrLike = {
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     1: Promise.resolve(2),
 >1 : Promise<number>
@@ -102,8 +102,8 @@ const arrLike = {
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->2 : 2
->  : ^
+>2 : number
+>  : ^^^^^^
 
     2: Promise.resolve(4),
 >2 : Promise<number>
@@ -116,8 +116,8 @@ const arrLike = {
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->4 : 4
->  : ^
+>4 : number
+>  : ^^^^^^
 
     3: Promise.resolve(6),
 >3 : Promise<number>
@@ -130,8 +130,8 @@ const arrLike = {
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->6 : 6
->  : ^
+>6 : number
+>  : ^^^^^^
 
     length: 4,
 >length : number
@@ -208,8 +208,8 @@ const sameArr2 = await Array.fromAsync([Promise.resolve(0), Promise.resolve(2),
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >Promise.resolve(2) : Promise<number>
 >                   : ^^^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -218,8 +218,8 @@ const sameArr2 = await Array.fromAsync([Promise.resolve(0), Promise.resolve(2),
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->2 : 2
->  : ^
+>2 : number
+>  : ^^^^^^
 >Promise.resolve(4) : Promise<number>
 >                   : ^^^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -228,8 +228,8 @@ const sameArr2 = await Array.fromAsync([Promise.resolve(0), Promise.resolve(2),
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->4 : 4
->  : ^
+>4 : number
+>  : ^^^^^^
 >Promise.resolve(6) : Promise<number>
 >                   : ^^^^^^^^^^^^^^^
 >Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
@@ -238,8 +238,8 @@ const sameArr2 = await Array.fromAsync([Promise.resolve(0), Promise.resolve(2),
 >        : ^^^^^^^^^^^^^^^^^^
 >resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>; }
 >        : ^^^^^^             ^^^ ^^     ^^ ^^^                   ^^^ ^^     ^^                  ^^^                   ^^^
->6 : 6
->  : ^
+>6 : number
+>  : ^^^^^^
 
 const sameArr3 = await Array.fromAsync(genPromises(4));
 >sameArr3 : number[]
@@ -367,14 +367,14 @@ const mapArr2 = await Array.fromAsync([0,2,4,6], v => Promise.resolve(v ** 2));
 >          : ^^^ ^^                   ^^                                                                               ^^^            ^^^ ^^ ^^                   ^^                                             ^^     ^^                        ^^       ^^^   ^^^                     ^^^
 >[0,2,4,6] : number[]
 >          : ^^^^^^^^
->0 : 0
->  : ^
->2 : 2
->  : ^
->4 : 4
->  : ^
->6 : 6
->  : ^
+>0 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>4 : number
+>  : ^^^^^^
+>6 : number
+>  : ^^^^^^
 >v => Promise.resolve(v ** 2) : (v: number) => Promise<number>
 >                             : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >v : number
@@ -409,14 +409,14 @@ const mapArr3 = await Array.fromAsync([0,2,4,6], v => v ** 2);
 >          : ^^^ ^^                   ^^                                                                               ^^^            ^^^ ^^ ^^                   ^^                                             ^^     ^^                        ^^       ^^^   ^^^                     ^^^
 >[0,2,4,6] : number[]
 >          : ^^^^^^^^
->0 : 0
->  : ^
->2 : 2
->  : ^
->4 : 4
->  : ^
->6 : 6
->  : ^
+>0 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>4 : number
+>  : ^^^^^^
+>6 : number
+>  : ^^^^^^
 >v => v ** 2 : (v: number) => number
 >            : ^ ^^^^^^^^^^^^^^^^^^^
 >v : number

tests/baselines/reference/arrayLiteral.types

@@ -16,8 +16,8 @@ var x = new Array(1);
 >             : ^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var y = [1];
 >y : number[]
@@ -58,26 +58,26 @@ var x2: number[] = new Array(1);
 >             : ^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var y2: number[] = [1];
 >y2 : number[]
 >   : ^^^^^^^^
 >[1] : number[]
 >    : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var y2: number[] = [1, 2];
 >y2 : number[]
 >   : ^^^^^^^^
 >[1, 2] : number[]
 >       : ^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
 
 var y2: number[] = new Array<number>();
 >y2 : number[]

tests/baselines/reference/arrayLiteralExpressionContextualTyping.types

@@ -33,12 +33,12 @@ var tup: [number, number, number] = [1, 2, 3, 4];
 >    : ^^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, 4] : [number, number, number, number]
 >             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >4 : 4
 >  : ^
 
@@ -47,12 +47,12 @@ var tup1: [number|string, number|string, number|string] = [1, 2, 3, "string"];
 >     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, "string"] : [number, number, number, string]
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >"string" : "string"
 >         : ^^^^^^^^
 
@@ -61,12 +61,12 @@ var tup2: [number, number, number] = [1, 2, 3, "string"];  // Error
 >     : ^^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, "string"] : [number, number, number, string]
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >"string" : "string"
 >         : ^^^^^^^^
 
@@ -109,12 +109,12 @@ var spr2:[number, number, number] = [1, 2, 3, ...tup];  // Error
 >     : ^^^^^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3, ...tup] : [number, number, number, number, number, number]
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >...tup : number
 >       : ^^^^^^
 >tup : [number, number, number]

tests/baselines/reference/arrayLiteralInNonVarArgParameter.types

@@ -16,8 +16,8 @@ panic([], 'one', 'two');
 >      : ^   ^^        ^^^^^   ^^        ^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
->'one' : "one"
->      : ^^^^^
->'two' : "two"
->      : ^^^^^
+>'one' : string
+>      : ^^^^^^
+>'two' : string
+>      : ^^^^^^
 

tests/baselines/reference/arrayLiteralTypeInference.types

@@ -43,8 +43,8 @@ var x1: Action[] = [
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->2 : 2
->  : ^
+>2 : number
+>  : ^^^^^^
 >trueness : boolean
 >         : ^^^^^^^
 >false : false
@@ -55,8 +55,8 @@ var x1: Action[] = [
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 >name : string
 >     : ^^^^^^
 >"three" : "three"
@@ -125,8 +125,8 @@ var z1: { id: number }[] =
 >                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->2 : 2
->  : ^
+>2 : number
+>  : ^^^^^^
 >trueness : boolean
 >         : ^^^^^^^
 >false : false
@@ -137,8 +137,8 @@ var z1: { id: number }[] =
 >                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 >name : string
 >     : ^^^^^^
 >"three" : "three"

tests/baselines/reference/arrayLiterals.types

@@ -143,12 +143,12 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : string
 >  : ^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 >b : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >c : string
 >  : ^^^^^^
 >'' : ""
@@ -157,12 +157,12 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >a : string
 >  : ^^^^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 >b : number
 >  : ^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 >c : number
 >  : ^^^^^^
 >0 : 0

tests/baselines/reference/arrayLiterals2ES5.types

@@ -116,18 +116,18 @@ var b1: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 >                                 : ^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >["hello", "string"] : string[]
 >                    : ^^^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
+>"hello" : string
+>        : ^^^^^^
+>"string" : string
+>         : ^^^^^^
 
 // The resulting type an array literal expression is determined as follows:
 //     - If the array literal contains no spread elements and is an array assignment pattern in a destructuring assignment (section 4.17.1),
@@ -193,18 +193,18 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 >                                 : ^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >["hello", "string"] : string[]
 >                    : ^^^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
+>"hello" : string
+>        : ^^^^^^
+>"string" : string
+>         : ^^^^^^
 
 var temp3 = [undefined, null, undefined];
 >temp3 : any[]

tests/baselines/reference/arrayLiterals2ES6.types

@@ -116,18 +116,18 @@ var b1: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 >                                 : ^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >["hello", "string"] : string[]
 >                    : ^^^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
+>"hello" : string
+>        : ^^^^^^
+>"string" : string
+>         : ^^^^^^
 
 // The resulting type an array literal expression is determined as follows:
 //     - If the array literal contains no spread elements and is an array assignment pattern in a destructuring assignment (section 4.17.1),
@@ -193,18 +193,18 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 >                                 : ^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >["hello", "string"] : string[]
 >                    : ^^^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
+>"hello" : string
+>        : ^^^^^^
+>"string" : string
+>         : ^^^^^^
 
 interface myArray extends Array<Number> { }
 interface myArray2 extends Array<Number|String> { }

tests/baselines/reference/arrayLiterals3.types

@@ -23,8 +23,8 @@ var a1: [boolean, string, number] = ["string", 1, true];  // Error
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >"string" : "string"
 >         : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 >true : true
 >     : ^^^^
 
@@ -39,10 +39,10 @@ var [b1, b2]: [number, number] = [1, 2, "string", true];
 >   : ^^^^^^
 >[1, 2, "string", true] : [number, number, string, boolean]
 >                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
 >"string" : "string"
 >         : ^^^^^^^^
 >true : true
@@ -82,18 +82,18 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 >                                 : ^^^^^^^^^^^^^^^^^^^^
 >[1, 2, 3] : number[]
 >          : ^^^^^^^^
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
 >["hello", "string"] : string[]
 >                    : ^^^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
->"string" : "string"
->         : ^^^^^^^^
+>"hello" : string
+>        : ^^^^^^
+>"string" : string
+>         : ^^^^^^
 
 interface tup {
     0: number[]|string[];

tests/baselines/reference/arrayOfFunctionTypes3.types

@@ -117,8 +117,8 @@ var r5b = r4(1);
 >      : ^^^^^^
 >r4 : { (x: number): number; (x: any): any; }
 >   : ^^^ ^^      ^^^      ^^^ ^^   ^^^   ^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var a2: { <T>(x: T): number; (x: string): string;};
 >a2 : { <T>(x: T): number; (x: string): string; }
@@ -171,6 +171,6 @@ var r7 = r6(''); // any not string
 >r6('') : any
 >r6 : { (x: number): number; <T>(x: T): any; }
 >   : ^^^ ^^      ^^^      ^^^ ^^ ^^ ^^^   ^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 

tests/baselines/reference/arraySigChecking.types

@@ -111,8 +111,8 @@ isEmpty(new Array(3));
 >             : ^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 isEmpty(new Array<string>(3));
 >isEmpty(new Array<string>(3)) : boolean
@@ -123,8 +123,8 @@ isEmpty(new Array<string>(3));
 >                     : ^^^^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 isEmpty(['a']);
 >isEmpty(['a']) : boolean

tests/baselines/reference/arraySlice.types

@@ -14,8 +14,8 @@ arr.splice(1, 1);
 >    : ^^^^^^^^^^^^^^^^^^^
 >splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
 >       : ^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^
->1 : 1
->  : ^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
+>1 : number
+>  : ^^^^^^
 

tests/baselines/reference/arraySpreadInCall.types

@@ -22,14 +22,14 @@ f1(1, 2, 3, 4, ...[5, 6]);
 >                          : ^^^^
 >f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
 >   : ^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^^^^    
->1 : 1
->  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
->4 : 4
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
+>4 : number
+>  : ^^^^^^
 >...[5, 6] : number
 >          : ^^^^^^
 >[5, 6] : [number, number]
@@ -50,26 +50,26 @@ f1(...[1], 2, 3, 4, 5, 6);
 >    : ^^^^^^^^
 >1 : 1
 >  : ^
->2 : 2
->  : ^
->3 : 3
->  : ^
->4 : 4
->  : ^
->5 : 5
->  : ^
->6 : 6
->  : ^
+>2 : number
+>  : ^^^^^^
+>3 : number
+>  : ^^^^^^
+>4 : number
+>  : ^^^^^^
+>5 : number
+>  : ^^^^^^
+>6 : number
+>  : ^^^^^^
 
 f1(1, 2, ...[3, 4], 5, 6);
 >f1(1, 2, ...[3, 4], 5, 6) : void
 >                          : ^^^^
 >f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
 >   : ^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^^^^    
->1 : 1
->  : ^
->2 : 2
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
 >...[3, 4] : number
 >          : ^^^^^^
 >[3, 4] : [number, number]
@@ -78,28 +78,28 @@ f1(1, 2, ...[3, 4], 5, 6);
 >  : ^
 >4 : 4
 >  : ^
->5 : 5
->  : ^
->6 : 6
->  : ^
+>5 : number
+>  : ^^^^^^
+>6 : number
+>  : ^^^^^^
 
 f1(1, 2, ...[3], 4, ...[5, 6]);
 >f1(1, 2, ...[3], 4, ...[5, 6]) : void
 >                               : ^^^^
 >f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
 >   : ^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^ ^^      ^^^^^    
->1 : 1
->  : ^
->2 : 2
->  : ^
+>1 : number
+>  : ^^^^^^
+>2 : number
+>  : ^^^^^^
 >...[3] : number
 >       : ^^^^^^
 >[3] : [number]
 >    : ^^^^^^^^
 >3 : 3
 >  : ^
->4 : 4
->  : ^
+>4 : number
+>  : ^^^^^^
 >...[5, 6] : number
 >          : ^^^^^^
 >[5, 6] : [number, number]

tests/baselines/reference/arrayToLocaleStringES2015.types

@@ -70,8 +70,8 @@ str = arr.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }); // OK
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const dates: readonly Date[] = [new Date(), new Date()];
 >dates : readonly Date[]
@@ -136,8 +136,8 @@ str = dates.toLocaleString('fr', { timeZone: 'UTC' }); // OK
 >                    : ^^^^^^^^^^^^^^^^^^^^^
 >timeZone : string
 >         : ^^^^^^
->'UTC' : "UTC"
->      : ^^^^^
+>'UTC' : string
+>      : ^^^^^^
 
 const mixed = [1, new Date(), 59782, new Date()];
 >mixed : (number | Date)[]
@@ -210,8 +210,8 @@ str = mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }); // OK
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: 'EUR', style: 'currency', timeZone: 'UTC' }); // OK
 >str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: 'EUR', style: 'currency', timeZone: 'UTC' }) : string
@@ -236,16 +236,16 @@ str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: '
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 >style : "currency"
 >      : ^^^^^^^^^^
 >'currency' : "currency"
 >           : ^^^^^^^^^^
 >timeZone : string
 >         : ^^^^^^
->'UTC' : "UTC"
->      : ^^^^^
+>'UTC' : string
+>      : ^^^^^^
 
 const int8Array = new Int8Array(3);
 >int8Array : Int8Array
@@ -254,8 +254,8 @@ const int8Array = new Int8Array(3);
 >                 : ^^^^^^^^^
 >Int8Array : Int8ArrayConstructor
 >          : ^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int8Array.toLocaleString(); // OK
 >str = int8Array.toLocaleString() : string
@@ -310,8 +310,8 @@ str = int8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' });
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint8Array = new Uint8Array(3);
 >uint8Array : Uint8Array
@@ -320,8 +320,8 @@ const uint8Array = new Uint8Array(3);
 >                  : ^^^^^^^^^^
 >Uint8Array : Uint8ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint8Array.toLocaleString(); // OK
 >str = uint8Array.toLocaleString() : string
@@ -376,8 +376,8 @@ str = uint8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint8ClampedArray = new Uint8ClampedArray(3);
 >uint8ClampedArray : Uint8ClampedArray
@@ -386,8 +386,8 @@ const uint8ClampedArray = new Uint8ClampedArray(3);
 >                         : ^^^^^^^^^^^^^^^^^
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint8ClampedArray.toLocaleString(); // OK
 >str = uint8ClampedArray.toLocaleString() : string
@@ -442,8 +442,8 @@ str = uint8ClampedArray.toLocaleString('en-US', { style: 'currency', currency: '
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const int16Array = new Int16Array(3);
 >int16Array : Int16Array
@@ -452,8 +452,8 @@ const int16Array = new Int16Array(3);
 >                  : ^^^^^^^^^^
 >Int16Array : Int16ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int16Array.toLocaleString(); // OK
 >str = int16Array.toLocaleString() : string
@@ -508,8 +508,8 @@ str = int16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint16Array = new Uint16Array(3);
 >uint16Array : Uint16Array
@@ -518,8 +518,8 @@ const uint16Array = new Uint16Array(3);
 >                   : ^^^^^^^^^^^
 >Uint16Array : Uint16ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint16Array.toLocaleString(); // OK
 >str = uint16Array.toLocaleString() : string
@@ -574,8 +574,8 @@ str = uint16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const int32Array = new Int32Array(3);
 >int32Array : Int32Array
@@ -584,8 +584,8 @@ const int32Array = new Int32Array(3);
 >                  : ^^^^^^^^^^
 >Int32Array : Int32ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int32Array.toLocaleString(); // OK
 >str = int32Array.toLocaleString() : string
@@ -640,8 +640,8 @@ str = int32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint32Array = new Uint32Array(3);
 >uint32Array : Uint32Array
@@ -650,8 +650,8 @@ const uint32Array = new Uint32Array(3);
 >                   : ^^^^^^^^^^^
 >Uint32Array : Uint32ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint32Array.toLocaleString(); // OK
 >str = uint32Array.toLocaleString() : string
@@ -706,8 +706,8 @@ str = uint32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const float32Array = new Float32Array(3);
 >float32Array : Float32Array
@@ -716,8 +716,8 @@ const float32Array = new Float32Array(3);
 >                    : ^^^^^^^^^^^^
 >Float32Array : Float32ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = float32Array.toLocaleString(); // OK
 >str = float32Array.toLocaleString() : string
@@ -772,8 +772,8 @@ str = float32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const float64Array = new Float64Array(3);
 >float64Array : Float64Array
@@ -782,8 +782,8 @@ const float64Array = new Float64Array(3);
 >                    : ^^^^^^^^^^^^
 >Float64Array : Float64ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = float64Array.toLocaleString(); // OK
 >str = float64Array.toLocaleString() : string
@@ -838,6 +838,6 @@ str = float64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 

tests/baselines/reference/arrayToLocaleStringES2020.types

@@ -70,8 +70,8 @@ str = arr.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }); // OK
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const dates: readonly Date[] = [new Date(), new Date()];
 >dates : readonly Date[]
@@ -136,8 +136,8 @@ str = dates.toLocaleString('fr', { timeZone: 'UTC' }); // OK
 >                    : ^^^^^^^^^^^^^^^^^^^^^
 >timeZone : string
 >         : ^^^^^^
->'UTC' : "UTC"
->      : ^^^^^
+>'UTC' : string
+>      : ^^^^^^
 
 const mixed = [1, new Date(), 59782, new Date()];
 >mixed : (number | Date)[]
@@ -194,8 +194,8 @@ str = mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }); // OK
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: 'EUR', style: 'currency', timeZone: 'UTC' }); // OK
 >str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: 'EUR', style: 'currency', timeZone: 'UTC' }) : string
@@ -220,16 +220,16 @@ str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: '
 >                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 >style : "currency"
 >      : ^^^^^^^^^^
 >'currency' : "currency"
 >           : ^^^^^^^^^^
 >timeZone : string
 >         : ^^^^^^
->'UTC' : "UTC"
->      : ^^^^^
+>'UTC' : string
+>      : ^^^^^^
 
 const bigInts = [BigInt(1), BigInt(2), BigInt(3)];
 >bigInts : bigint[]
@@ -308,8 +308,8 @@ str = bigInts.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }); /
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const int8Array = new Int8Array(3);
 >int8Array : Int8Array
@@ -318,8 +318,8 @@ const int8Array = new Int8Array(3);
 >                 : ^^^^^^^^^
 >Int8Array : Int8ArrayConstructor
 >          : ^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int8Array.toLocaleString(); // OK
 >str = int8Array.toLocaleString() : string
@@ -374,8 +374,8 @@ str = int8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' });
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint8Array = new Uint8Array(3);
 >uint8Array : Uint8Array
@@ -384,8 +384,8 @@ const uint8Array = new Uint8Array(3);
 >                  : ^^^^^^^^^^
 >Uint8Array : Uint8ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint8Array.toLocaleString(); // OK
 >str = uint8Array.toLocaleString() : string
@@ -440,8 +440,8 @@ str = uint8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint8ClampedArray = new Uint8ClampedArray(3);
 >uint8ClampedArray : Uint8ClampedArray
@@ -450,8 +450,8 @@ const uint8ClampedArray = new Uint8ClampedArray(3);
 >                         : ^^^^^^^^^^^^^^^^^
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint8ClampedArray.toLocaleString(); // OK
 >str = uint8ClampedArray.toLocaleString() : string
@@ -506,8 +506,8 @@ str = uint8ClampedArray.toLocaleString('en-US', { style: 'currency', currency: '
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const int16Array = new Int16Array(3);
 >int16Array : Int16Array
@@ -516,8 +516,8 @@ const int16Array = new Int16Array(3);
 >                  : ^^^^^^^^^^
 >Int16Array : Int16ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int16Array.toLocaleString(); // OK
 >str = int16Array.toLocaleString() : string
@@ -572,8 +572,8 @@ str = int16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint16Array = new Uint16Array(3);
 >uint16Array : Uint16Array
@@ -582,8 +582,8 @@ const uint16Array = new Uint16Array(3);
 >                   : ^^^^^^^^^^^
 >Uint16Array : Uint16ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint16Array.toLocaleString(); // OK
 >str = uint16Array.toLocaleString() : string
@@ -638,8 +638,8 @@ str = uint16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const int32Array = new Int32Array(3);
 >int32Array : Int32Array
@@ -648,8 +648,8 @@ const int32Array = new Int32Array(3);
 >                  : ^^^^^^^^^^
 >Int32Array : Int32ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int32Array.toLocaleString(); // OK
 >str = int32Array.toLocaleString() : string
@@ -704,8 +704,8 @@ str = int32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const uint32Array = new Uint32Array(3);
 >uint32Array : Uint32Array
@@ -714,8 +714,8 @@ const uint32Array = new Uint32Array(3);
 >                   : ^^^^^^^^^^^
 >Uint32Array : Uint32ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint32Array.toLocaleString(); // OK
 >str = uint32Array.toLocaleString() : string
@@ -770,8 +770,8 @@ str = uint32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const float32Array = new Float32Array(3);
 >float32Array : Float32Array
@@ -780,8 +780,8 @@ const float32Array = new Float32Array(3);
 >                    : ^^^^^^^^^^^^
 >Float32Array : Float32ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = float32Array.toLocaleString(); // OK
 >str = float32Array.toLocaleString() : string
@@ -836,8 +836,8 @@ str = float32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const float64Array = new Float64Array(3);
 >float64Array : Float64Array
@@ -846,8 +846,8 @@ const float64Array = new Float64Array(3);
 >                    : ^^^^^^^^^^^^
 >Float64Array : Float64ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = float64Array.toLocaleString(); // OK
 >str = float64Array.toLocaleString() : string
@@ -902,8 +902,8 @@ str = float64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const bigInt64Array = new BigInt64Array(3);
 >bigInt64Array : BigInt64Array
@@ -912,8 +912,8 @@ const bigInt64Array = new BigInt64Array(3);
 >                     : ^^^^^^^^^^^^^
 >BigInt64Array : BigInt64ArrayConstructor
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = bigInt64Array.toLocaleString(); // OK
 >str = bigInt64Array.toLocaleString() : string
@@ -968,8 +968,8 @@ str = bigInt64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 
 const bigIntUint64Array = new BigUint64Array(3);
 >bigIntUint64Array : BigUint64Array
@@ -978,8 +978,8 @@ const bigIntUint64Array = new BigUint64Array(3);
 >                      : ^^^^^^^^^^^^^^
 >BigUint64Array : BigUint64ArrayConstructor
 >               : ^^^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = bigIntUint64Array.toLocaleString(); // OK
 >str = bigIntUint64Array.toLocaleString() : string
@@ -1034,6 +1034,6 @@ str = bigIntUint64Array.toLocaleString('en-US', { style: 'currency', currency: '
 >           : ^^^^^^^^^^
 >currency : string
 >         : ^^^^^^
->'EUR' : "EUR"
->      : ^^^^^
+>'EUR' : string
+>      : ^^^^^^
 

tests/baselines/reference/arrayToLocaleStringES5.types

@@ -146,8 +146,8 @@ const int8Array = new Int8Array(3);
 >                 : ^^^^^^^^^
 >Int8Array : Int8ArrayConstructor
 >          : ^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int8Array.toLocaleString(); // OK
 >str = int8Array.toLocaleString() : string
@@ -212,8 +212,8 @@ const uint8Array = new Uint8Array(3);
 >                  : ^^^^^^^^^^
 >Uint8Array : Uint8ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint8Array.toLocaleString(); // OK
 >str = uint8Array.toLocaleString() : string
@@ -278,8 +278,8 @@ const uint8ClampedArray = new Uint8ClampedArray(3);
 >                         : ^^^^^^^^^^^^^^^^^
 >Uint8ClampedArray : Uint8ClampedArrayConstructor
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint8ClampedArray.toLocaleString(); // OK
 >str = uint8ClampedArray.toLocaleString() : string
@@ -344,8 +344,8 @@ const int16Array = new Int16Array(3);
 >                  : ^^^^^^^^^^
 >Int16Array : Int16ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int16Array.toLocaleString(); // OK
 >str = int16Array.toLocaleString() : string
@@ -410,8 +410,8 @@ const uint16Array = new Uint16Array(3);
 >                   : ^^^^^^^^^^^
 >Uint16Array : Uint16ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint16Array.toLocaleString(); // OK
 >str = uint16Array.toLocaleString() : string
@@ -476,8 +476,8 @@ const int32Array = new Int32Array(3);
 >                  : ^^^^^^^^^^
 >Int32Array : Int32ArrayConstructor
 >           : ^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = int32Array.toLocaleString(); // OK
 >str = int32Array.toLocaleString() : string
@@ -542,8 +542,8 @@ const uint32Array = new Uint32Array(3);
 >                   : ^^^^^^^^^^^
 >Uint32Array : Uint32ArrayConstructor
 >            : ^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = uint32Array.toLocaleString(); // OK
 >str = uint32Array.toLocaleString() : string
@@ -608,8 +608,8 @@ const float32Array = new Float32Array(3);
 >                    : ^^^^^^^^^^^^
 >Float32Array : Float32ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = float32Array.toLocaleString(); // OK
 >str = float32Array.toLocaleString() : string
@@ -674,8 +674,8 @@ const float64Array = new Float64Array(3);
 >                    : ^^^^^^^^^^^^
 >Float64Array : Float64ArrayConstructor
 >             : ^^^^^^^^^^^^^^^^^^^^^^^
->3 : 3
->  : ^
+>3 : number
+>  : ^^^^^^
 
 str = float64Array.toLocaleString(); // OK
 >str = float64Array.toLocaleString() : string

tests/baselines/reference/arrayconcat.types

@@ -66,8 +66,8 @@ class parser {
 >        : ^^^^^^^^^^
 >sort : (compareFn?: (a: IOptions, b: IOptions) => number) => IOptions[]
 >     : ^         ^^^^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^
->function(a, b) {            var aName = a.name.toLowerCase();            var bName = b.name.toLowerCase();            if (aName > bName) {                return 1;            } else if (aName < bName) {                return -1;            } else {                return 0;            }        } : (a: IOptions, b: IOptions) => 1 | -1 | 0
->                                                                                                                                                                                                                                                                                                        : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
+>function(a, b) {            var aName = a.name.toLowerCase();            var bName = b.name.toLowerCase();            if (aName > bName) {                return 1;            } else if (aName < bName) {                return -1;            } else {                return 0;            }        } : (a: IOptions, b: IOptions) => number
+>                                                                                                                                                                                                                                                                                                        : ^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
 >a : IOptions
 >  : ^^^^^^^^
 >b : IOptions
@@ -114,8 +114,8 @@ class parser {
 >      : ^^^^^^
 
                 return 1;
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
             } else if (aName < bName) {
 >aName < bName : boolean
@@ -133,8 +133,8 @@ class parser {
 
             } else {
                 return 0;
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
             }
         });
 	}

tests/baselines/reference/arrowFunctionContexts.types

@@ -56,8 +56,8 @@ window.setTimeout(() => null, 100);
 >           : ^^       ^^            ^^       ^^^      ^^^^^         ^^     ^^^^^      ^^^^^^       ^^            ^^       ^^^      ^^^^^         ^^     ^^^^^      ^
 >() => null : () => any
 >           : ^^^^^^^^^
->100 : 100
->    : ^^^
+>100 : number
+>    : ^^^^^^
 
 // Arrow function as value in array literal
 
@@ -209,8 +209,8 @@ module M2 {
 >           : ^^       ^^            ^^       ^^^      ^^^^^         ^^     ^^^^^      ^^^^^^       ^^            ^^       ^^^      ^^^^^         ^^     ^^^^^      ^
 >() => null : () => any
 >           : ^^^^^^^^^
->100 : 100
->    : ^^^
+>100 : number
+>    : ^^^^^^
 
     // Arrow function as value in array literal
 

tests/baselines/reference/arrowFunctionExpressions.types

@@ -171,8 +171,8 @@ var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >         : ^^^^^^^^^^^^^^^
 >b : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var p10 = ([{ value, done }]) => { };
 >p10 : ([{ value, done }]: [{ value: any; done: any; }]) => void
@@ -278,10 +278,10 @@ var e = arrrr()(3)()(4);
 >        : ^ ^^      ^^^^^^^^^^^^ ^^      ^^^^^^^^^^^
 >arrrr : () => (m: number) => () => (n: number) => number
 >      : ^^^^^^^ ^^      ^^^^^^^^^^^^ ^^      ^^^^^^^^^^^
->3 : 3
->  : ^
->4 : 4
->  : ^
+>3 : number
+>  : ^^^^^^
+>4 : number
+>  : ^^^^^^
 
 var e: number;
 >e : number
@@ -321,10 +321,10 @@ function someFn() {
 >       : ^ ^^      ^^^^^^^^^^^
 >arr : (n: number) => (p: number) => number
 >    : ^ ^^      ^^^^^^ ^^      ^^^^^^^^^^^
->3 : 3
->  : ^
->4 : 4
->  : ^
+>3 : number
+>  : ^^^^^^
+>4 : number
+>  : ^^^^^^
 >toExponential : (fractionDigits?: number) => string
 >              : ^              ^^^      ^^^^^      
 }
@@ -357,12 +357,12 @@ function someOtherFn() {
 >       : ^^^^^^
 >arr : (n: number) => string
 >    : ^ ^^      ^^^^^^^^^^^
->4 : 4
->  : ^
+>4 : number
+>  : ^^^^^^
 >charAt : (pos: number) => string
 >       : ^   ^^      ^^^^^      
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 
 // Arrow function used in nested function in function
@@ -424,8 +424,8 @@ var f = (n: string) => {
 >      : ^^^^^^^^^^^^
 >fn : (x: number) => () => string
 >   : ^ ^^      ^^^^^^^^^^^^^^^^^
->4 : 4
->  : ^
+>4 : number
+>  : ^^^^^^
 }
 var g = f('')();
 >g : string
@@ -436,8 +436,8 @@ var g = f('')();
 >      : ^^^^^^^^^^^^
 >f : (n: string) => () => string
 >  : ^ ^^      ^^^^^^^^^^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 
 var g: string;
 >g : string
@@ -492,8 +492,8 @@ var h = someOuterFn()('')()();
 >              : ^ ^^      ^^^^^^^^^^^^^^^^^^^^^^^
 >someOuterFn : () => (n: string) => () => () => number
 >            : ^^^^^^^ ^^      ^^^^^^^^^^^^^^^^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 
 h.toExponential();
 >h.toExponential() : string

tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.types

@@ -12,12 +12,12 @@ var a = () => <Error>{ name: "foo", message: "bar" };
 >                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"foo" : "foo"
->      : ^^^^^
+>"foo" : string
+>      : ^^^^^^
 >message : string
 >        : ^^^^^^
->"bar" : "bar"
->      : ^^^^^
+>"bar" : string
+>      : ^^^^^^
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : () => Error
@@ -32,12 +32,12 @@ var b = () => (<Error>{ name: "foo", message: "bar" });
 >                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"foo" : "foo"
->      : ^^^^^
+>"foo" : string
+>      : ^^^^^^
 >message : string
 >        : ^^^^^^
->"bar" : "bar"
->      : ^^^^^
+>"bar" : string
+>      : ^^^^^^
 
 var c = () => ({ name: "foo", message: "bar" });           
 >c : () => { name: string; message: string; }
@@ -74,10 +74,10 @@ var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"foo" : "foo"
->      : ^^^^^
+>"foo" : string
+>      : ^^^^^^
 >message : string
 >        : ^^^^^^
->"bar" : "bar"
->      : ^^^^^
+>"bar" : string
+>      : ^^^^^^
 

tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.types

@@ -12,12 +12,12 @@ var a = () => <Error>{ name: "foo", message: "bar" };
 >                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"foo" : "foo"
->      : ^^^^^
+>"foo" : string
+>      : ^^^^^^
 >message : string
 >        : ^^^^^^
->"bar" : "bar"
->      : ^^^^^
+>"bar" : string
+>      : ^^^^^^
 
 var b = () => (<Error>{ name: "foo", message: "bar" });    
 >b : () => Error
@@ -32,12 +32,12 @@ var b = () => (<Error>{ name: "foo", message: "bar" });
 >                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"foo" : "foo"
->      : ^^^^^
+>"foo" : string
+>      : ^^^^^^
 >message : string
 >        : ^^^^^^
->"bar" : "bar"
->      : ^^^^^
+>"bar" : string
+>      : ^^^^^^
 
 var c = () => ({ name: "foo", message: "bar" });           
 >c : () => { name: string; message: string; }
@@ -74,10 +74,10 @@ var d = () => ((<Error>({ name: "foo", message: "bar" })));
 >                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"foo" : "foo"
->      : ^^^^^
+>"foo" : string
+>      : ^^^^^^
 >message : string
 >        : ^^^^^^
->"bar" : "bar"
->      : ^^^^^
+>"bar" : string
+>      : ^^^^^^
 

tests/baselines/reference/asOperator1.types

@@ -42,14 +42,14 @@ var j = 32 as number|string;
 >  : ^^^^^^^^^^^^^^^
 >32 as number|string : string | number
 >                    : ^^^^^^^^^^^^^^^
->32 : 32
->   : ^^
+>32 : number
+>   : ^^^^^^
 
 j = '';
->j = '' : ""
->       : ^^
+>j = '' : string
+>       : ^^^^^^
 >j : string | number
 >  : ^^^^^^^^^^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 

tests/baselines/reference/asOperator2.types

@@ -6,6 +6,6 @@ var x = 23 as string;
 >  : ^^^^^^
 >23 as string : string
 >             : ^^^^^^
->23 : 23
->   : ^^
+>23 : number
+>   : ^^^^^^
 

tests/baselines/reference/asOperator3.types

@@ -64,8 +64,8 @@ var e = `Hello` as string;
 >  : ^^^^^^
 >`Hello` as string : string
 >                  : ^^^^^^
->`Hello` : "Hello"
->        : ^^^^^^^
+>`Hello` : string
+>        : ^^^^^^
 
 var f = 1 + `${1} end of string` as string;
 >f : string

tests/baselines/reference/assertionFunctionWildcardImport2.types

@@ -26,8 +26,8 @@ function isNonNullable<T>(obj: T): asserts obj is NonNullable<T> {
 >                                          : ^^^^^
 >Error : ErrorConstructor
 >      : ^^^^^^^^^^^^^^^^
->"Must not be a nullable value" : "Must not be a nullable value"
->                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>"Must not be a nullable value" : string
+>                               : ^^^^^^
     }
 }
 

tests/baselines/reference/assertionTypePredicates2.types

@@ -59,8 +59,8 @@ export const main = () => {
 >         : ^^^^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     foo(a);
 >foo(a) : void

tests/baselines/reference/assign1.types

@@ -22,11 +22,11 @@ module M {
 >                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >salt : number
 >     : ^^^^^^
->2 : 2
->  : ^
+>2 : number
+>  : ^^^^^^
 >pepper : number
 >       : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 }
 

tests/baselines/reference/assignmentCompatBug2.types

@@ -34,8 +34,8 @@ b2 = {b: 0, a: 0 };
 >              : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >b : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 >a : number
 >  : ^^^^^^
 >0 : 0
@@ -76,8 +76,8 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     g: (s) => { return 0; },
 >g : (s: string) => number
@@ -86,14 +86,14 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     m: 0,
 >m : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
 }; // ok
 
@@ -112,8 +112,8 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     g: (s) => { return 0; },
 >g : (s: string) => number
@@ -122,8 +122,8 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
 }; // error
 
@@ -142,14 +142,14 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     m: 0,
 >m : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
 }; // error
 
@@ -168,8 +168,8 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     g: (s) => { return 0; },
 >g : (s: string) => number
@@ -178,20 +178,20 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     m: 0,
 >m : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     n: 0,
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     k: (a) =>{ return null; },
 >k : (a: any) => any
@@ -218,8 +218,8 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     g: (s) => { return 0; },
 >g : (s: string) => number
@@ -228,14 +228,14 @@ b3 = {
 >                     : ^ ^^^^^^^^^^^^^^^^^^^
 >s : string
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     n: 0,
 >n : number
 >  : ^^^^^^
->0 : 0
->  : ^
+>0 : number
+>  : ^^^^^^
 
     k: (a) =>{ return null; },
 >k : (a: any) => any

tests/baselines/reference/assignmentCompatBug5.types

@@ -34,10 +34,10 @@ foo2(["s", "t"]);
 >     : ^ ^^        ^^^^^^^^^
 >["s", "t"] : string[]
 >           : ^^^^^^^^
->"s" : "s"
->    : ^^^
->"t" : "t"
->    : ^^^
+>"s" : string
+>    : ^^^^^^
+>"t" : string
+>    : ^^^^^^
 
 function foo3(x: (n: number) =>number) { };
 >foo3 : (x: (n: number) => number) => void

tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types

@@ -20,8 +20,8 @@ foo({ id: 1234 });                 // Ok
 >             : ^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->1234 : 1234
->     : ^^^^
+>1234 : number
+>     : ^^^^^^
 
 foo({ id: 1234, name: "hello" });  // Ok
 >foo({ id: 1234, name: "hello" }) : void
@@ -32,12 +32,12 @@ foo({ id: 1234, name: "hello" });  // Ok
 >                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->1234 : 1234
->     : ^^^^
+>1234 : number
+>     : ^^^^^^
 >name : string
 >     : ^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
+>"hello" : string
+>        : ^^^^^^
 
 foo({ id: 1234, name: false });    // Error, name of wrong type
 >foo({ id: 1234, name: false }) : void
@@ -48,8 +48,8 @@ foo({ id: 1234, name: false });    // Error, name of wrong type
 >                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >id : number
 >   : ^^^^^^
->1234 : 1234
->     : ^^^^
+>1234 : number
+>     : ^^^^^^
 >name : boolean
 >     : ^^^^^^^
 >false : false
@@ -64,6 +64,6 @@ foo({ name: "hello" });            // Error, id required but missing
 >                  : ^^^^^^^^^^^^^^^^^
 >name : string
 >     : ^^^^^^
->"hello" : "hello"
->        : ^^^^^^^
+>"hello" : string
+>        : ^^^^^^
 

tests/baselines/reference/assignmentCompatWithCallSignaturesWithOptionalParameters.types

@@ -59,8 +59,8 @@ var a: () => number;
 >  : ^^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (x?: number) => 1; // ok, same number of required params
 >a = (x?: number) => 1 : (x?: number) => number
@@ -71,8 +71,8 @@ var a: () => number;
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (x: number) => 1; // error, too many required params
 >a = (x: number) => 1 : (x: number) => number
@@ -171,8 +171,8 @@ var a2: (x?: number) => number;
 >   : ^ ^^^      ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x?: number) => 1; // ok, same number of required params
 >a2 = (x?: number) => 1 : (x?: number) => number
@@ -183,8 +183,8 @@ var a2: (x?: number) => number;
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x: number) => 1; // ok, same number of params
 >a2 = (x: number) => 1 : (x: number) => number
@@ -195,8 +195,8 @@ var a2: (x?: number) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = b.a; // ok
 >a2 = b.a : () => number
@@ -283,8 +283,8 @@ var a3: (x: number) => number;
 >   : ^ ^^      ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x?: number) => 1; // ok, fewer required params
 >a3 = (x?: number) => 1 : (x?: number) => number
@@ -295,8 +295,8 @@ var a3: (x: number) => number;
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: number) => 1; // ok, same number of required params
 >a3 = (x: number) => 1 : (x: number) => number
@@ -307,8 +307,8 @@ var a3: (x: number) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: number, y: number) => 1;  // error, too many required params
 >a3 = (x: number, y: number) => 1 : (x: number, y: number) => number
@@ -411,8 +411,8 @@ var a4: (x: number, y?: number) => number;
 >   : ^ ^^      ^^ ^^^      ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x?: number, y?: number) => 1; // ok, fewer required params
 >a4 = (x?: number, y?: number) => 1 : (x?: number, y?: number) => number
@@ -425,8 +425,8 @@ var a4: (x: number, y?: number) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x: number) => 1; // ok, same number of required params
 >a4 = (x: number) => 1 : (x: number) => number
@@ -437,8 +437,8 @@ var a4: (x: number, y?: number) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x: number, y: number) => 1; // ok, same number of params
 >a4 = (x: number, y: number) => 1 : (x: number, y: number) => number
@@ -451,8 +451,8 @@ var a4: (x: number, y?: number) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = b.a; // ok
 >a4 = b.a : () => number
@@ -541,8 +541,8 @@ var a5: (x?: number, y?: number) => number;
 >   : ^ ^^^      ^^ ^^^      ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a5 = (x?: number, y?: number) => 1; // ok, fewer required params
 >a5 = (x?: number, y?: number) => 1 : (x?: number, y?: number) => number
@@ -555,8 +555,8 @@ var a5: (x?: number, y?: number) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a5 = (x: number) => 1; // ok, fewer params in lambda
 >a5 = (x: number) => 1 : (x: number) => number
@@ -567,8 +567,8 @@ var a5: (x?: number, y?: number) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a5 = (x: number, y: number) => 1;  // ok, same number of params
 >a5 = (x: number, y: number) => 1 : (x: number, y: number) => number
@@ -581,8 +581,8 @@ var a5: (x?: number, y?: number) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a5 = b.a; // ok
 >a5 = b.a : () => number

tests/baselines/reference/assignmentCompatWithCallSignaturesWithRestParameters.types

@@ -52,8 +52,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >  : ^^^^    ^^        ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (...args: number[]) => 1; // ok, same number of required params
 >a = (...args: number[]) => 1 : (...args: number[]) => number
@@ -64,8 +64,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >                         : ^^^^    ^^        ^^^^^^^^^^^
 >args : number[]
 >     : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (...args: string[]) => 1; // error, type mismatch
 >a = (...args: string[]) => 1 : (...args: string[]) => number
@@ -76,8 +76,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >                         : ^^^^    ^^        ^^^^^^^^^^^
 >args : string[]
 >     : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (x?: number) => 1; // ok, same number of required params
 >a = (x?: number) => 1 : (x?: number) => number
@@ -88,8 +88,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (x?: number, y?: number, z?: number) => 1; // ok, same number of required params
 >a = (x?: number, y?: number, z?: number) => 1 : (x?: number, y?: number, z?: number) => number
@@ -104,8 +104,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >  : ^^^^^^
 >z : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (x: number) => 1; // ok, rest param corresponds to infinite number of params
 >a = (x: number) => 1 : (x: number) => number
@@ -116,8 +116,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a = (x?: string) => 1; // error, incompatible type
 >a = (x?: string) => 1 : (x?: string) => number
@@ -128,8 +128,8 @@ var a: (...args: number[]) => number; // ok, same number of required params
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : string
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 
 var a2: (x: number, ...z: number[]) => number;
@@ -147,8 +147,8 @@ var a2: (x: number, ...z: number[]) => number;
 >   : ^ ^^      ^^^^^ ^^        ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (...args: number[]) => 1; // ok, fewer required params
 >a2 = (...args: number[]) => 1 : (...args: number[]) => number
@@ -159,8 +159,8 @@ var a2: (x: number, ...z: number[]) => number;
 >                         : ^^^^    ^^        ^^^^^^^^^^^
 >args : number[]
 >     : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x?: number) => 1; // ok, fewer required params
 >a2 = (x?: number) => 1 : (x?: number) => number
@@ -171,8 +171,8 @@ var a2: (x: number, ...z: number[]) => number;
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x: number) => 1; // ok, same number of required params
 >a2 = (x: number) => 1 : (x: number) => number
@@ -183,8 +183,8 @@ var a2: (x: number, ...z: number[]) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x: number, ...args: number[]) => 1; // ok, same number of required params
 >a2 = (x: number, ...args: number[]) => 1 : (x: number, ...args: number[]) => number
@@ -197,8 +197,8 @@ var a2: (x: number, ...z: number[]) => number;
 >  : ^^^^^^
 >args : number[]
 >     : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x: number, ...args: string[]) => 1; // should be type mismatch error
 >a2 = (x: number, ...args: string[]) => 1 : (x: number, ...args: string[]) => number
@@ -211,8 +211,8 @@ var a2: (x: number, ...z: number[]) => number;
 >  : ^^^^^^
 >args : string[]
 >     : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x: number, y: number) => 1; // ok, rest param corresponds to infinite number of params
 >a2 = (x: number, y: number) => 1 : (x: number, y: number) => number
@@ -225,8 +225,8 @@ var a2: (x: number, ...z: number[]) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a2 = (x: number, y?: number) => 1; // ok, same number of required params
 >a2 = (x: number, y?: number) => 1 : (x: number, y?: number) => number
@@ -239,8 +239,8 @@ var a2: (x: number, ...z: number[]) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var a3: (x: number, y?: string, ...z: number[]) => number;
 >a3 : (x: number, y?: string, ...z: number[]) => number
@@ -259,8 +259,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >   : ^ ^^      ^^ ^^^      ^^^^^ ^^        ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x?: number) => 1; // ok, fewer required params
 >a3 = (x?: number) => 1 : (x?: number) => number
@@ -271,8 +271,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >                  : ^ ^^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: number) => 1; // ok, same number of required params
 >a3 = (x: number) => 1 : (x: number) => number
@@ -283,8 +283,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: number, y: string) => 1;  // ok, all present params match
 >a3 = (x: number, y: string) => 1 : (x: number, y: string) => number
@@ -297,8 +297,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >y : string
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: number, y?: number, z?: number) => 1;  // error
 >a3 = (x: number, y?: number, z?: number) => 1 : (x: number, y?: number, z?: number) => number
@@ -313,8 +313,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >z : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: number, ...z: number[]) => 1;  // error
 >a3 = (x: number, ...z: number[]) => 1 : (x: number, ...z: number[]) => number
@@ -327,8 +327,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >z : number[]
 >  : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a3 = (x: string, y?: string, z?: string) => 1;  // error
 >a3 = (x: string, y?: string, z?: string) => 1 : (x: string, y?: string, z?: string) => number
@@ -343,8 +343,8 @@ var a3: (x: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >z : string
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
 var a4: (x?: number, y?: string, ...z: number[]) => number;
 >a4 : (x?: number, y?: string, ...z: number[]) => number
@@ -363,8 +363,8 @@ var a4: (x?: number, y?: string, ...z: number[]) => number;
 >   : ^ ^^^      ^^ ^^^      ^^^^^ ^^        ^^^^^      
 >() => 1 : () => number
 >        : ^^^^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x?: number, y?: number) => 1; // error, type mismatch
 >a4 = (x?: number, y?: number) => 1 : (x?: number, y?: number) => number
@@ -377,8 +377,8 @@ var a4: (x?: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x: number) => 1; // ok, all present params match
 >a4 = (x: number) => 1 : (x: number) => number
@@ -389,8 +389,8 @@ var a4: (x?: number, y?: string, ...z: number[]) => number;
 >                 : ^ ^^      ^^^^^^^^^^^
 >x : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x: number, y?: number) => 1;  // error, second param has type mismatch
 >a4 = (x: number, y?: number) => 1 : (x: number, y?: number) => number
@@ -403,8 +403,8 @@ var a4: (x?: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >y : number
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x?: number, y?: string) => 1;  // ok, same number of required params with matching types
 >a4 = (x?: number, y?: string) => 1 : (x?: number, y?: string) => number
@@ -417,8 +417,8 @@ var a4: (x?: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >y : string
 >  : ^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 
     a4 = (x: number, ...args: string[]) => 1;  // error, rest params have type mismatch
 >a4 = (x: number, ...args: string[]) => 1 : (x: number, ...args: string[]) => number
@@ -431,6 +431,6 @@ var a4: (x?: number, y?: string, ...z: number[]) => number;
 >  : ^^^^^^
 >args : string[]
 >     : ^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 

tests/baselines/reference/assignmentCompatWithDiscriminatedUnion.types

@@ -381,8 +381,8 @@ namespace GH14865 {
 >    : ^^^
 >data : string
 >     : ^^^^^^
->"whatevs" : "whatevs"
->          : ^^^^^^^^^
+>"whatevs" : string
+>          : ^^^^^^
 
     let b: Style1;
 >b : Style1
@@ -713,14 +713,14 @@ namespace GH39357 {
 >       : ^^^^^^^^^^^^^^^^^^^
 >b : "a" | "b"
 >  : ^^^^^^^^^
->1 : 1
->  : ^
+>1 : number
+>  : ^^^^^^
 >["c", ""] : ["c", string]
 >          : ^^^^^^^^^^^^^
 >"c" : "c"
 >    : ^^^
->"" : ""
->   : ^^
+>"" : string
+>   : ^^^^^^
 }
 
 // https://github.com/microsoft/TypeScript/issues/58603

tests/baselines/reference/assignmentCompatWithObjectMembers3.types

@@ -67,8 +67,8 @@ var a2: S2 = { foo: '' };
 >            : ^^^^^^^^^^^^^^^^
 >foo : string
 >    : ^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 
 var b2: T2 = { foo: '' };
 >b2 : T2
@@ -77,8 +77,8 @@ var b2: T2 = { foo: '' };
 >            : ^^^^^^^^^^^^^^^^
 >foo : string
 >    : ^^^^^^
->'' : ""
->   : ^^
+>'' : string
+>   : ^^^^^^
 
 s = t;
 >s = t : T