TypeScript/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types

=== tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts ===
// Call signatures without a return type should infer one from the function body (if present)

// Simple types
function foo(x) {
>foo : (x: any) => number
>x : any

    return 1;
}
var r = foo(1);
>r : number
>foo(1) : number
>foo : (x: any) => number

function foo2(x) {
>foo2 : (x: any) => number
>x : any

    return foo(x);
>foo(x) : number
>foo : (x: any) => number
>x : any
}
var r2 = foo2(1);
>r2 : number
>foo2(1) : number
>foo2 : (x: any) => number

function foo3() {
>foo3 : () => any

    return foo3();
>foo3() : any
>foo3 : () => any
}
var r3 = foo3();
>r3 : any
>foo3() : any
>foo3 : () => any

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

    return x;
>x : T
}
var r4 = foo4(1);
>r4 : number
>foo4(1) : number
>foo4 : <T>(x: T) => T

function foo5(x) {
>foo5 : (x: any) => number
>x : any

    if (true) {
        return 1;
    } else {
        return 2;
    }
}
var r5 = foo5(1);
>r5 : number
>foo5(1) : number
>foo5 : (x: any) => number

function foo6(x) {
>foo6 : (x: any) => any[]
>x : any

    try {
    }
    catch (e) {
>e : any

        return [];
>[] : undefined[]
    }
    finally {
        return [];
>[] : undefined[]
    }
}
var r6 = foo6(1);
>r6 : any[]
>foo6(1) : any[]
>foo6 : (x: any) => any[]

function foo7(x) {
>foo7 : (x: any) => string
>x : any

    return typeof x;
>typeof x : string
>x : any
}
var r7 = foo7(1);
>r7 : string
>foo7(1) : string
>foo7 : (x: any) => string

// object types
function foo8(x: number) {
>foo8 : (x: number) => { x: number; }
>x : number

    return { x: x };
>{ x: x } : { x: number; }
>x : number
>x : number
}
var r8 = foo8(1);
>r8 : { x: number; }
>foo8(1) : { x: number; }
>foo8 : (x: number) => { x: number; }

interface I {
>I : I

    foo: string;
>foo : string
}
function foo9(x: number) {
>foo9 : (x: number) => I
>x : number

    var i: I;
>i : I
>I : I

    return i;    
>i : I
}
var r9 = foo9(1);
>r9 : I
>foo9(1) : I
>foo9 : (x: number) => I

class C {
>C : C

    foo: string;
>foo : string
}
function foo10(x: number) {
>foo10 : (x: number) => C
>x : number

    var c: C;
>c : C
>C : C

    return c;
>c : C
}
var r10 = foo10(1);
>r10 : C
>foo10(1) : C
>foo10 : (x: number) => C

module M {
>M : typeof M

    export var x = 1;
>x : number

    export class C { foo: string }
>C : C
>foo : string
}
function foo11() {
>foo11 : () => typeof M

    return M;
>M : typeof M
}
var r11 = foo11();
>r11 : typeof M
>foo11() : typeof M
>foo11 : () => typeof M

// merged declarations
interface I2 {
>I2 : I2

    x: number;
>x : number
}
interface I2 {
>I2 : I2

    y: number;
>y : number
}
function foo12() {
>foo12 : () => I2

    var i2: I2;
>i2 : I2
>I2 : I2

    return i2;
>i2 : I2
}
var r12 = foo12();
>r12 : I2
>foo12() : I2
>foo12 : () => I2

function m1() { return 1; }
>m1 : typeof m1

module m1 { export var y = 2; }
>m1 : typeof m1
>y : number

function foo13() {
>foo13 : () => typeof m1

    return m1;
>m1 : typeof m1
}
var r13 = foo13();
>r13 : typeof m1
>foo13() : typeof m1
>foo13 : () => typeof m1

class c1 {
>c1 : c1

    foo: string;
>foo : string

    constructor(x) { }
>x : any
}
module c1 {
>c1 : typeof c1

    export var x = 1;
>x : number
}
function foo14() {
>foo14 : () => typeof c1

    return c1;
>c1 : typeof c1
}
var r14 = foo14();
>r14 : typeof c1
>foo14() : typeof c1
>foo14 : () => typeof c1

enum e1 { A }
>e1 : e1
>A : e1

module e1 { export var y = 1; }
>e1 : typeof e1
>y : number

function foo15() {
>foo15 : () => typeof e1

    return e1;
>e1 : typeof e1
}
var r15 = foo15();
>r15 : typeof e1
>foo15() : typeof e1
>foo15 : () => typeof e1