=== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures2.ts ===
// void returning call signatures can be assigned a non-void returning call signature that otherwise matches

interface T {
    f(x: number): void;
>f : (x: number) => void
>x : number
}
var t: T;
>t : T

var a: { f(x: number): void };
>a : { f(x: number): void; }
>f : (x: number) => void
>x : number

t = a;
>t = a : { f(x: number): void; }
>t : T
>a : { f(x: number): void; }

a = t;
>a = t : T
>a : { f(x: number): void; }
>t : T

interface S {
    f(x: number): string;
>f : (x: number) => string
>x : number
}
var s: S;
>s : S

var a2: { f(x: number): string };
>a2 : { f(x: number): string; }
>f : (x: number) => string
>x : number

t = s;
>t = s : S
>t : T
>s : S

t = a2;
>t = a2 : { f(x: number): string; }
>t : T
>a2 : { f(x: number): string; }

a = s;
>a = s : S
>a : { f(x: number): void; }
>s : S

a = a2;
>a = a2 : { f(x: number): string; }
>a : { f(x: number): void; }
>a2 : { f(x: number): string; }

t = { f: () => 1 };
>t = { f: () => 1 } : { f: () => number; }
>t : T
>{ f: () => 1 } : { f: () => number; }
>f : () => number
>() => 1 : () => number
>1 : 1

t = { f: <T>(x:T) => 1 };
>t = { f: <T>(x:T) => 1 } : { f: <T>(x: T) => number; }
>t : T
>{ f: <T>(x:T) => 1 } : { f: <T>(x: T) => number; }
>f : <T>(x: T) => number
><T>(x:T) => 1 : <T>(x: T) => number
>x : T
>1 : 1

t = { f: function f() { return 1 } };
>t = { f: function f() { return 1 } } : { f: () => number; }
>t : T
>{ f: function f() { return 1 } } : { f: () => number; }
>f : () => number
>function f() { return 1 } : () => number
>f : () => number
>1 : 1

t = { f(x: number) { return ''; } }
>t = { f(x: number) { return ''; } } : { f(x: number): string; }
>t : T
>{ f(x: number) { return ''; } } : { f(x: number): string; }
>f : (x: number) => string
>x : number
>'' : ""

a = { f: () => 1 }
>a = { f: () => 1 } : { f: () => number; }
>a : { f(x: number): void; }
>{ f: () => 1 } : { f: () => number; }
>f : () => number
>() => 1 : () => number
>1 : 1

a = { f: <T>(x: T) => 1 };
>a = { f: <T>(x: T) => 1 } : { f: <T>(x: T) => number; }
>a : { f(x: number): void; }
>{ f: <T>(x: T) => 1 } : { f: <T>(x: T) => number; }
>f : <T>(x: T) => number
><T>(x: T) => 1 : <T>(x: T) => number
>x : T
>1 : 1

a = { f: function (x: number) { return ''; } }
>a = { f: function (x: number) { return ''; } } : { f: (x: number) => string; }
>a : { f(x: number): void; }
>{ f: function (x: number) { return ''; } } : { f: (x: number) => string; }
>f : (x: number) => string
>function (x: number) { return ''; } : (x: number) => string
>x : number
>'' : ""

// errors
t = () => 1;
>t = () => 1 : () => number
>t : T
>() => 1 : () => number
>1 : 1

t = function (x: number) { return ''; }
>t = function (x: number) { return ''; } : (x: number) => string
>t : T
>function (x: number) { return ''; } : (x: number) => string
>x : number
>'' : ""

a = () => 1;
>a = () => 1 : () => number
>a : { f(x: number): void; }
>() => 1 : () => number
>1 : 1

a = function (x: number) { return ''; }
>a = function (x: number) { return ''; } : (x: number) => string
>a : { f(x: number): void; }
>function (x: number) { return ''; } : (x: number) => string
>x : number
>'' : ""

interface S2 {
    f(x: string): void;
>f : (x: string) => void
>x : string
}
var s2: S2;
>s2 : S2

var a3: { f(x: string): void };
>a3 : { f(x: string): void; }
>f : (x: string) => void
>x : string

// these are errors
t = s2;
>t = s2 : S2
>t : T
>s2 : S2

t = a3;
>t = a3 : { f(x: string): void; }
>t : T
>a3 : { f(x: string): void; }

t = (x: string) => 1;
>t = (x: string) => 1 : (x: string) => number
>t : T
>(x: string) => 1 : (x: string) => number
>x : string
>1 : 1

t = function (x: string) { return ''; }
>t = function (x: string) { return ''; } : (x: string) => string
>t : T
>function (x: string) { return ''; } : (x: string) => string
>x : string
>'' : ""

a = s2;
>a = s2 : S2
>a : { f(x: number): void; }
>s2 : S2

a = a3;
>a = a3 : { f(x: string): void; }
>a : { f(x: number): void; }
>a3 : { f(x: string): void; }

a = (x: string) => 1;
>a = (x: string) => 1 : (x: string) => number
>a : { f(x: number): void; }
>(x: string) => 1 : (x: string) => number
>x : string
>1 : 1

a = function (x: string) { return ''; }
>a = function (x: string) { return ''; } : (x: string) => string
>a : { f(x: number): void; }
>function (x: string) { return ''; } : (x: string) => string
>x : string
>'' : ""

