Accepting new baselines

Author: ahejlsberg

tests/baselines/reference/unionTypeInference.js

@@ -5,20 +5,31 @@
 function f<T>(x: T, y: string|T): T {
     return x;
 }
+
+var a1: number;
+var a1 = f(1, 2);
+var a2: number;
+var a2 = f(1, "hello");
+var a3: number;
+var a3 = f(1, a1 || "hello");
+var a4: any;
+var a4 = f(undefined, "abc");
+
 function g<T>(value: [string, T]): T {
     return value[1];
 }
 
-var a: number;
-var a = f(1, 2);
-var b: number;
-var b = f(1, "hello");
-var c: number;
-var c = f(1, a || "hello");
-var d: any;
-var d = f(undefined, "abc");
-var e: boolean;
-var e = g(["string", true]);
+var b1: boolean;
+var b1 = g(["string", true]);
+
+function h<T>(x: string|boolean|T): T {
+    return typeof x === "string" || typeof x === "boolean" ? undefined : x;
+}
+
+var c1: number;
+var c1 = h(5);
+var c2: string;
+var c2 = h("abc");
 
 
 //// [unionTypeInference.js]
@@ -27,16 +38,23 @@ var e = g(["string", true]);
 function f(x, y) {
     return x;
 }
+var a1;
+var a1 = f(1, 2);
+var a2;
+var a2 = f(1, "hello");
+var a3;
+var a3 = f(1, a1 || "hello");
+var a4;
+var a4 = f(undefined, "abc");
 function g(value) {
     return value[1];
 }
-var a;
-var a = f(1, 2);
-var b;
-var b = f(1, "hello");
-var c;
-var c = f(1, a || "hello");
-var d;
-var d = f(undefined, "abc");
-var e;
-var e = g(["string", true]);
+var b1;
+var b1 = g(["string", true]);
+function h(x) {
+    return typeof x === "string" || typeof x === "boolean" ? undefined : x;
+}
+var c1;
+var c1 = h(5);
+var c2;
+var c2 = h("abc");

tests/baselines/reference/unionTypeInference.types

@@ -14,59 +14,96 @@ function f<T>(x: T, y: string|T): T {
     return x;
 >x : T
 }
-function g<T>(value: [string, T]): T {
->g : <T>(value: [string, T]) => T
->T : T
->value : [string, T]
->T : T
->T : T
-
-    return value[1];
->value[1] : T
->value : [string, T]
-}
 
-var a: number;
->a : number
+var a1: number;
+>a1 : number
 
-var a = f(1, 2);
->a : number
+var a1 = f(1, 2);
+>a1 : number
 >f(1, 2) : number
 >f : <T>(x: T, y: string | T) => T
 
-var b: number;
->b : number
+var a2: number;
+>a2 : number
 
-var b = f(1, "hello");
->b : number
+var a2 = f(1, "hello");
+>a2 : number
 >f(1, "hello") : number
 >f : <T>(x: T, y: string | T) => T
 
-var c: number;
->c : number
+var a3: number;
+>a3 : number
 
-var c = f(1, a || "hello");
->c : number
->f(1, a || "hello") : number
+var a3 = f(1, a1 || "hello");
+>a3 : number
+>f(1, a1 || "hello") : number
 >f : <T>(x: T, y: string | T) => T
->a || "hello" : string | number
->a : number
+>a1 || "hello" : string | number
+>a1 : number
 
-var d: any;
->d : any
+var a4: any;
+>a4 : any
 
-var d = f(undefined, "abc");
->d : any
+var a4 = f(undefined, "abc");
+>a4 : any
 >f(undefined, "abc") : any
 >f : <T>(x: T, y: string | T) => T
 >undefined : undefined
 
-var e: boolean;
->e : boolean
+function g<T>(value: [string, T]): T {
+>g : <T>(value: [string, T]) => T
+>T : T
+>value : [string, T]
+>T : T
+>T : T
 
-var e = g(["string", true]);
->e : boolean
+    return value[1];
+>value[1] : T
+>value : [string, T]
+}
+
+var b1: boolean;
+>b1 : boolean
+
+var b1 = g(["string", true]);
+>b1 : boolean
 >g(["string", true]) : boolean
 >g : <T>(value: [string, T]) => T
 >["string", true] : [string, boolean]
 
+function h<T>(x: string|boolean|T): T {
+>h : <T>(x: string | boolean | T) => T
+>T : T
+>x : string | boolean | T
+>T : T
+>T : T
+
+    return typeof x === "string" || typeof x === "boolean" ? undefined : x;
+>typeof x === "string" || typeof x === "boolean" ? undefined : x : T
+>typeof x === "string" || typeof x === "boolean" : boolean
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | boolean | T
+>typeof x === "boolean" : boolean
+>typeof x : string
+>x : boolean | T
+>undefined : undefined
+>x : T
+}
+
+var c1: number;
+>c1 : number
+
+var c1 = h(5);
+>c1 : number
+>h(5) : number
+>h : <T>(x: string | boolean | T) => T
+
+var c2: string;
+>c2 : string
+
+var c2 = h("abc");
+>c2 : string
+>h("abc") : string
+>h : <T>(x: string | boolean | T) => T
+