Higher order this parameter inference, like #31116

[Jack Bates (jablko)]

The following works since #31116/be88d53ab37453585b449b6ab1918134087b03cf

function identity<T>(value: T) {
    return value;
}

function call<T, R>(fn: (value: T) => R, value: T) {
    return fn(value);
}

const result: number = call(identity, 1);

however the following is still error TS2322: Type 'unknown' is not assignable to type 'number'.

function identity<T>(value: T) {
    return value;
}

identity.call = function<T, R>(this: (value: T) => R, value: T) {
    return this(value);
};

const result: number = identity.call(1);

Consequently while

const result: bigint[] = [1].map(BigInt);

works, the following

const result: bigint[] = Array.prototype.map.call([1], BigInt);

is error TS2322: Type 'unknown[]' is not assignable to type 'bigint[]'. (with --strictBindCallApply).

The following

Array.prototype.map
    .call(buf, BigInt)
    .reduce((result, byte) => (result << 8n) + byte);

is error TS2571: Object is of type 'unknown'.

This PR extends #31116 to the this parameter so the second case function(this, value) behaves like the first function call(fn, value).

This improves type inference for --strictBindCallApply and generic functions and resolves the errors in both of the above Array.prototype.map.call() examples.

[Nathan Shively-Sanders (sandersn)]

Unfortunately, we never finished reviewing this PR. It is pretty old now, so I'm going to close it to reduce the number of open PRs.

[TypeScript Bot (typescript-bot)]

This PR doesn't have any linked issues. Please open an issue that references this PR. From there we can discuss and prioritise.