return compareSignaturesRelated(source, target, /*checkAsCallback*/ false, ignoreReturnTypes, /*reportErrors*/ false,

/*errorReporter*/ undefined, compareTypesAssignable) !== Ternary.False;

checkAsCallback: boolean,

const sourceType = i < sourceMax ? getTypeOfParameter(sourceParams[i]) : getRestTypeOfSignature(source);

const targetType = i < targetMax ? getTypeOfParameter(targetParams[i]) : getRestTypeOfSignature(target);

const sourceSig = getSingleCallSignature(getNonNullableType(sourceType));

const targetSig = getSingleCallSignature(getNonNullableType(targetType));

// In order to ensure that any generic type Foo<T> is at least co-variant with respect to T no matter

// how Foo uses T, we need to relate parameters bi-variantly (given that parameters are input positions,

// they naturally relate only contra-variantly). However, if the source and target parameters both have

// function types with a single call signature, we known we are relating two callback parameters. In

// that case it is sufficient to only relate the parameters of the signatures co-variantly because,

// similar to return values, callback parameters are output positions. This means that a Promise<T>,

// where T is used only in callback parameter positions, will be co-variant (as opposed to bi-variant)

// with respect to T.

const callbacks = sourceSig && targetSig && !sourceSig.typePredicate && !targetSig.typePredicate &&

(getFalsyFlags(sourceType) & TypeFlags.Nullable) === (getFalsyFlags(targetType) & TypeFlags.Nullable);

const related = callbacks ?

compareSignaturesRelated(targetSig, sourceSig, /*checkAsCallback*/ true, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, compareTypes) :

!checkAsCallback && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors);

// When relating callback signatures, we still need to relate return types bi-variantly as otherwise

// the containing type wouldn't be co-variant. For example, interface Foo<T> { add(cb: () => T): void }

// wouldn't be co-variant for T without this rule.

result &= checkAsCallback && compareTypes(targetReturnType, sourceReturnType, /*reportErrors*/ false) ||

compareTypes(sourceReturnType, targetReturnType, reportErrors);

return compareSignaturesRelated(source, target, /*checkAsCallback*/ false, /*ignoreReturnTypes*/ false, reportErrors, reportError, isRelatedTo);

const visitNodes: (cb: ((node: Node) => T) | ((node: Node[]) => T), nodes: Node[]) => T = cbNodeArray ? visitNodeArray : visitEachNode;

const reduceNodes: (nodes: NodeArray<Node>, f: ((memo: T, node: Node) => T) | ((memo: T, node: NodeArray<Node>) => T), initial: T) => T = cbNodeArray ? reduceNodeArray : reduceLeft;

tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures3.ts(71,1): error TS2322: Type '(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived' is not assignable to type '<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U'.

Types of parameters 'y' and 'y' are incompatible.

Types of parameters 'arg2' and 'arg2' are incompatible.

Type 'Base' is not assignable to type '{ foo: string; bing: number; }'.

Property 'bing' is missing in type 'Base'.

==== tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithCallSignatures3.ts (1 errors) ====

// these are all permitted with the current rules, since we do not do contextual signature instantiation

class Base { foo: string; }

class Derived extends Base { bar: string; }

class Derived2 extends Derived { baz: string; }

class OtherDerived extends Base { bing: string; }

var a: (x: number) => number[];

var a2: (x: number) => string[];

var a3: (x: number) => void;

var a4: (x: string, y: number) => string;

var a5: (x: (arg: string) => number) => string;

var a6: (x: (arg: Base) => Derived) => Base;

var a7: (x: (arg: Base) => Derived) => (r: Base) => Derived;

var a8: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;

var a9: (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived;

var a10: (...x: Derived[]) => Derived;

var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base;

var a12: (x: Array<Base>, y: Array<Derived2>) => Array<Derived>;

var a13: (x: Array<Base>, y: Array<Derived>) => Array<Derived>;

var a14: (x: { a: string; b: number }) => Object;

var a15: {

(x: number): number[];

(x: string): string[];

}

var a16: {

<T extends Derived>(x: T): number[];

<U extends Base>(x: U): number[];

}

var a17: {

(x: (a: number) => number): number[];

(x: (a: string) => string): string[];

};

var a18: {

(x: {

(a: number): number;

(a: string): string;

}): any[];

(x: {

(a: boolean): boolean;

(a: Date): Date;

}): any[];

}

var b: <T>(x: T) => T[];

a = b; // ok

b = a; // ok

var b2: <T>(x: T) => string[];

a2 = b2; // ok

b2 = a2; // ok

var b3: <T>(x: T) => T;

a3 = b3; // ok

b3 = a3; // ok

var b4: <T, U>(x: T, y: U) => T;

a4 = b4; // ok

b4 = a4; // ok

var b5: <T, U>(x: (arg: T) => U) => T;

a5 = b5; // ok

b5 = a5; // ok

var b6: <T extends Base, U extends Derived>(x: (arg: T) => U) => T;

a6 = b6; // ok

b6 = a6; // ok

var b7: <T extends Base, U extends Derived>(x: (arg: T) => U) => (r: T) => U;

a7 = b7; // ok

b7 = a7; // ok

var b8: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: T) => U) => (r: T) => U;

a8 = b8; // ok

b8 = a8; // ok

var b9: <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number }) => U) => (r: T) => U;

a9 = b9; // ok

b9 = a9; // ok

~~

!!! error TS2322: Type '(x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived' is not assignable to type '<T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => (r: T) => U'.

!!! error TS2322: Types of parameters 'y' and 'y' are incompatible.

!!! error TS2322: Types of parameters 'arg2' and 'arg2' are incompatible.

!!! error TS2322: Type 'Base' is not assignable to type '{ foo: string; bing: number; }'.

!!! error TS2322: Property 'bing' is missing in type 'Base'.

var b10: <T extends Derived>(...x: T[]) => T;

a10 = b10; // ok

b10 = a10; // ok

var b11: <T extends Base>(x: T, y: T) => T;

a11 = b11; // ok

b11 = a11; // ok

var b12: <T extends Array<Base>>(x: Array<Base>, y: T) => Array<Derived>;

a12 = b12; // ok

b12 = a12; // ok

var b13: <T extends Array<Derived>>(x: Array<Base>, y: T) => T;

a13 = b13; // ok

b13 = a13; // ok

var b14: <T>(x: { a: T; b: T }) => T;

a14 = b14; // ok

b14 = a14; // ok

var b15: <T>(x: T) => T[];

a15 = b15; // ok

b15 = a15; // ok

var b16: <T extends Base>(x: T) => number[];

a16 = b16; // ok

b16 = a16; // ok

var b17: <T>(x: (a: T) => T) => T[]; // ok

a17 = b17; // ok

b17 = a17; // ok

var b18: <T>(x: (a: T) => T) => T[];

a18 = b18; // ok

b18 = a18; // ok

Types of parameters 'arg2' and 'arg2' are incompatible.

Type '{ foo: number; }' is not assignable to type 'Base'.

Types of property 'foo' are incompatible.

Type 'number' is not assignable to type 'string'.

Types of parameters 'arg2' and 'arg2' are incompatible.

Type 'Base' is not assignable to type '{ foo: number; }'.

Types of property 'foo' are incompatible.

Type 'string' is not assignable to type 'number'.

!!! error TS2322: Types of parameters 'arg2' and 'arg2' are incompatible.

!!! error TS2322: Type '{ foo: number; }' is not assignable to type 'Base'.

!!! error TS2322: Types of property 'foo' are incompatible.

!!! error TS2322: Type 'number' is not assignable to type 'string'.

!!! error TS2322: Types of parameters 'arg2' and 'arg2' are incompatible.

!!! error TS2322: Type 'Base' is not assignable to type '{ foo: number; }'.

!!! error TS2322: Types of property 'foo' are incompatible.

!!! error TS2322: Type 'string' is not assignable to type 'number'.