Accepting new baselines

Author: ahejlsberg

tests/baselines/reference/arrayOfFunctionTypes3.errors.txt

@@ -0,0 +1,35 @@
+tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts(17,13): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts(26,10): error TS2349: Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts (2 errors) ====
+    // valid uses of arrays of function types
+    
+    var x = [() => 1, () => { }];
+    var r2 = x[0]();
+    
+    class C {
+        foo: string;
+    }
+    var y = [C, C];
+    var r3 = new y[0]();
+    
+    var a: { (x: number): number; (x: string): string; };
+    var b: { (x: number): number; (x: string): string; };
+    var c: { (x: number): number; (x: any): any; };
+    var z = [a, b, c];
+    var r4 = z[0];
+    var r5 = r4(''); // any not string
+                ~~
+!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+    var r5b = r4(1);
+    
+    var a2: { <T>(x: T): number; (x: string): string;};
+    var b2: { <T>(x: T): number; (x: string): string; };
+    var c2: { (x: number): number; <T>(x: T): any; };
+    
+    var z2 = [a2, b2, c2];
+    var r6 = z2[0];
+    var r7 = r6(''); // any not string
+             ~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.

tests/baselines/reference/arrayOfFunctionTypes3.symbols

@@ -82,7 +82,5 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 

tests/baselines/reference/arrayOfFunctionTypes3.types

@@ -90,10 +90,10 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >x4 : IWithCallSignatures | IWithCallSignatures4
 >IWithCallSignatures : IWithCallSignatures
 >IWithCallSignatures4 : IWithCallSignatures4
->a => /*here a should be any*/ a.toString() : (a: number) => string
->a : number
->a.toString() : string
->a.toString : (radix?: number) => string
->a : number
->toString : (radix?: number) => string
+>a => /*here a should be any*/ a.toString() : (a: any) => any
+>a : any
+>a.toString() : any
+>a.toString : any
+>a : any
+>toString : any
 

tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols

@@ -1,17 +1,20 @@
+tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(7,30): error TS2349: Cannot invoke an expression whose type lacks a call signature.
 tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(10,30): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
   Type 'string | number' is not assignable to type 'number'.
     Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): error TS2346: Supplied parameters do not match any signature of call target.
 
 
-==== tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts (2 errors) ====
+==== tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts (3 errors) ====
     function map<T, U>(xs: T[], f: (x: T) => U) {
         var ys: U[] = [];
         xs.forEach(x => ys.push(f(x)));
         return ys;
     }
 
     var r0 = map([1, ""], (x) => x.toString());
+                                 ~~~~~~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
     var r5 = map<any, any>([1, ""], (x) => x.toString());
     var r6 = map<Object, Object>([1, ""], (x) => x.toString());
     var r7 = map<number, string>([1, ""], (x) => x.toString()); // error

tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types

@@ -0,0 +1,103 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardsInConditionalExpression.ts(93,22): error TS2349: Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardsInConditionalExpression.ts (1 errors) ====
+    // In the true expression of a conditional expression, 
+    // the type of a variable or parameter is narrowed by any type guard in the condition when true, 
+    // provided the true expression contains no assignments to the variable or parameter.
+    // In the false expression of a conditional expression, 
+    // the type of a variable or parameter is narrowed by any type guard in the condition when false, 
+    // provided the false expression contains no assignments to the variable or parameter.
+    
+    function foo(x: number | string) {
+        return typeof x === "string"
+            ? x.length // string
+            : x++; // number
+    }
+    function foo2(x: number | string) {
+        // x is assigned in the if true branch, the type is not narrowed
+        return typeof x === "string"
+            ? (x = 10 && x)// string | number
+            : x; // string | number
+    }
+    function foo3(x: number | string) {
+        // x is assigned in the if false branch, the type is not narrowed
+        // even though assigned using same type as narrowed expression
+        return typeof x === "string"
+            ? (x = "Hello" && x) // string | number
+            : x; // string | number
+    }
+    function foo4(x: number | string) {
+        // false branch updates the variable - so here it is not number
+        // even though assigned using same type as narrowed expression
+        return typeof x === "string"
+            ? x // string | number
+            : (x = 10 && x); // string | number
+    }
+    function foo5(x: number | string) {
+        // false branch updates the variable - so here it is not number
+        return typeof x === "string"
+            ? x // string | number
+            : (x = "hello" && x); // string | number
+    }
+    function foo6(x: number | string) {
+        // Modify in both branches
+        return typeof x === "string"
+            ? (x = 10 && x) // string | number
+            : (x = "hello" && x); // string | number
+    }
+    function foo7(x: number | string | boolean) {
+        return typeof x === "string"
+            ? x === "hello" // string
+            : typeof x === "boolean"
+            ? x // boolean
+            : x == 10; // number
+    }
+    function foo8(x: number | string | boolean) {
+        var b: number | boolean;
+        return typeof x === "string"
+            ? x === "hello"
+            : ((b = x) && //  number | boolean
+            (typeof x === "boolean"
+            ? x // boolean
+            : x == 10)); // number
+    }
+    function foo9(x: number | string) {
+        var y = 10;
+        // usage of x or assignment to separate variable shouldn't cause narrowing of type to stop
+        return typeof x === "string"
+            ? ((y = x.length) && x === "hello") // string
+            : x === 10; // number
+    }
+    function foo10(x: number | string | boolean) {
+        // Mixing typeguards
+        var b: boolean | number;
+        return typeof x === "string"
+            ? x // string
+            : ((b = x) // x is number | boolean
+            && typeof x === "number"
+            && x.toString()); // x is number
+    }
+    function foo11(x: number | string | boolean) {
+        // Mixing typeguards
+        // Assigning value to x deep inside another guard stops narrowing of type too
+        var b: number | boolean | string;
+        return typeof x === "string"
+            ? x // number | boolean | string - changed in the false branch
+            : ((b = x) // x is number | boolean | string - because the assignment changed it
+            && typeof x === "number"
+            && (x = 10) // assignment to x
+            && x); // x is number | boolean | string
+    }
+    function foo12(x: number | string | boolean) {
+        // Mixing typeguards
+        // Assigning value to x in outer guard shouldn't stop narrowing in the inner expression
+        var b: number | boolean | string;
+        return typeof x === "string"
+            ? (x = 10 && x.toString().length) // number | boolean | string - changed here
+                         ~~~~~~~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.
+            : ((b = x) // x is number | boolean | string  - changed in true branch
+            && typeof x === "number"
+            && x); // x is number
+    }