Fix type parameter leak when using 'this' in reverse mapped types

[thromel]

Fixes #62779

Problem

When object literal methods reference this inside a function with a reverse mapped type parameter, the type parameter T was leaking through:

declare function test<T extends Record<string, unknown>>(obj: {
    [K in keyof T]: () => T[K];
}): T;

const obj = test({
    a() { return 0; },
    b() { return this.a(); },
});
// Expected: { a: number; b: number; }
// Actual:   { a: number; b: T[string]; } (widened to unknown)

Cause

In getContextualThisParameterType, when computing the this type for method b, the code was using the contextual type (the mapped type { [K in keyof T]: () => T[K] }) with unresolved type parameters. This caused this.a() to be typed as T["a"] rather than the already-inferred number.

Solution

When in an inference context, use the actual object literal type via checkExpressionCached(containingLiteral) rather than the contextual mapped type. This allows methods to see each other's already-inferred types when resolving this references.

Test Plan

• Added test case reverseMappedThisTypeInference.ts demonstrating the fix
• Verified all existing contextual, inference, and reverse mapped type tests pass

[Andarist]

declare function testReverseMapped2<T extends Record<string, unknown>, T2>(
  obj: T2 & {
    [K in keyof T]: () => T[K];
  },
): T;

const obj2 = testReverseMapped2({
  a() {
    return 0;
  },
  b() {
    return this.a();
  },
});

declare function testReverseMapped3<T extends Record<string, unknown>, T2>(
  obj: T2 | {
    [K in keyof T]: () => T[K];
  },
): T;

const obj3 = testReverseMapped3({
  a() {
    return 0;
  },
  b() {
    // Property 'a' does not exist on type '{} | { [K in keyof T]: () => T[K]; }'.
    //   Property 'a' does not exist on type '{}'.(2339)
    return this.a();
  },
});

IMHO, at the very least - the type contained in this error message indicates the fix presented in this PR isn't quite right.

[thromel]

Thanks for the feedback! I've updated the fix to use someType to check if the contextual type contains a mapped type (not just IS a mapped type), which should handle both intersection and union cases.

With this change, both test cases now work:

• obj2 (intersection): { a: number; b: number; }
• obj3 (union): { a: number; b: number; }

Is this the behavior you were expecting, or did you have a different approach in mind?