TypeScript/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types

=== tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions.ts ===
// conditional expressions return the best common type of the branches plus contextual type (using the first candidate if multiple BCTs exist)
// no errors expected here

var a: { x: number; y?: number };
>a : { x: number; y?: number; }
>x : number
>y : number

var b: { x: number; z?: number };
>b : { x: number; z?: number; }
>x : number
>z : number

class Base { foo: string; }
>Base : Base
>foo : string

class Derived extends Base { bar: string; }
>Derived : Derived
>Base : Base
>bar : string

class Derived2 extends Base { baz: string; }
>Derived2 : Derived2
>Base : Base
>baz : string

var base: Base;
>base : Base
>Base : Base

var derived: Derived;
>derived : Derived
>Derived : Derived

var derived2: Derived2;
>derived2 : Derived2
>Derived2 : Derived2

var r = true ? 1 : 2;
>r : number
>true ? 1 : 2 : number
>true : boolean
>1 : number
>2 : number

var r3 = true ? 1 : {};
>r3 : {}
>true ? 1 : {} : {}
>true : boolean
>1 : number
>{} : {}

var r4 = true ? a : b; // typeof a
>r4 : { x: number; y?: number; } | { x: number; z?: number; }
>true ? a : b : { x: number; y?: number; } | { x: number; z?: number; }
>true : boolean
>a : { x: number; y?: number; }
>b : { x: number; z?: number; }

var r5 = true ? b : a; // typeof b
>r5 : { x: number; y?: number; } | { x: number; z?: number; }
>true ? b : a : { x: number; y?: number; } | { x: number; z?: number; }
>true : boolean
>b : { x: number; z?: number; }
>a : { x: number; y?: number; }

var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => void
>r6 : (x: number) => void
>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
>true : boolean
>(x: number) => { } : (x: number) => void
>x : number
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object

var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { }; 
>r7 : (x: Object) => void
>x : Object
>Object : Object
>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
>true : boolean
>(x: number) => { } : (x: number) => void
>x : number
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object

var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
>r8 : (x: Object) => void
>true ? (x: Object) => { } : (x: number) => { } : (x: Object) => void
>true : boolean
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object
>(x: number) => { } : (x: number) => void
>x : number

var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT
>r10 : Base
>Base : Base
>true ? derived : derived2 : Derived | Derived2
>true : boolean
>derived : Derived
>derived2 : Derived2

var r11 = true ? base : derived2;
>r11 : Base
>true ? base : derived2 : Base
>true : boolean
>base : Base
>derived2 : Derived2

function foo5<T, U>(t: T, u: U): Object {
>foo5 : <T, U>(t: T, u: U) => Object
>T : T
>U : U
>t : T
>T : T
>u : U
>U : U
>Object : Object

    return true ? t : u; // BCT is Object
>true ? t : u : T | U
>true : boolean
>t : T
>u : U
}