=== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts ===
// return type of a function with multiple returns is the BCT of each return statement
// no errors expected here

function f1() {
>f1 : () => number

    if (true) {
        return 1;
    } else {
        return null;
    }
}

function f2() {
>f2 : () => number

    if (true) {
        return 1;
    } else if (false) {
        return null;
    } else {
        return 2;
    }
}

function f4() {
>f4 : () => number

    try {
        return 1;
    }
    catch (e) {
>e : any

        return undefined;
>undefined : undefined
    }
    finally {
        return 1;
    }
}

function f5() {
>f5 : () => Object

    return 1;
    return new Object();
>new Object() : Object
>Object : { (): any; (value: any): any; new (value?: any): Object; prototype: Object; getPrototypeOf(o: any): any; getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor; getOwnPropertyNames(o: any): string[]; create(o: any, properties?: PropertyDescriptorMap): any; defineProperty(o: any, p: string, attributes: PropertyDescriptor): any; defineProperties(o: any, properties: PropertyDescriptorMap): any; seal(o: any): any; freeze(o: any): any; preventExtensions(o: any): any; isSealed(o: any): boolean; isFrozen(o: any): boolean; isExtensible(o: any): boolean; keys(o: any): string[]; }
}

function f6<T>(x: T) {
>f6 : <T>(x: T) => T
>T : T
>x : T
>T : T

    if (true) {
        return x;
>x : T

    } else {
        return null;
    }
}

//function f7<T extends U, U>(x: T, y: U) {
//    if (true) {
//        return x;
//    } else {
//        return y;
//    }
//}

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

// returns typeof a
function f9() {
>f9 : () => { x: number; y?: number; }

    if (true) {
        return a;
>a : { x: number; y?: number; }

    } else {
        return b;
>b : { x: number; z?: number; }
    }
}

// returns typeof b
function f10() {
>f10 : () => { x: number; z?: number; }

    if (true) {
        return b;
>b : { x: number; z?: number; }

    } else {
        return a;
>a : { x: number; y?: number; }
    }
}

// returns number => void
function f11() {
>f11 : () => (x: number) => void

    if (true) {
        return (x: number) => { }
>(x: number) => { } : (x: number) => void
>x : number

    } else {
        return (x: Object) => { }
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object
    }
}

// returns Object => void
function f12() {
>f12 : () => (x: Object) => void

    if (true) {
        return (x: Object) => { }
>(x: Object) => { } : (x: Object) => void
>x : Object
>Object : Object

    } else {
        return (x: number) => { }        
>(x: number) => { } : (x: number) => void
>x : number
    }
}