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

Fixes #62779

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

```typescript
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(); },
});
// Was: { a: number; b: T[string]; } (widened to unknown)
// Now: { a: number; b: number; }
```

The fix modifies `getContextualThisParameterType` to use the actual
object literal type when in an inference context, rather than the
contextual mapped type with unresolved type parameters. This allows
methods to see each other's already-inferred types when resolving
`this` references.

Author: thromel

src/compiler/checker.ts

@@ -31825,6 +31825,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // There was no contextual ThisType<T> for the containing object literal, so the contextual type
                 // for 'this' is the non-null form of the contextual type for the containing object literal or
                 // the type of the object literal itself.
+                // If we're in an inference context with a reverse mapped type, use the object literal type
+                // to allow proper inference of method return types that reference other methods via this.
+                // This avoids leaking type parameters like T[K] when methods call each other.
+                const inferenceContext = getInferenceContext(containingLiteral);
+                if (inferenceContext) {
+                    // Use the object literal type directly to break the cycle with the contextual type.
+                    // This allows methods to see each other's inferred types.
+                    return getWidenedType(checkExpressionCached(containingLiteral));
+                }
                 return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
             }
             // In an assignment of the form 'obj.xxx = function(...)' or 'obj[xxx] = function(...)', the

tests/baselines/reference/reverseMappedThisTypeInference.js

@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/reverseMappedThisTypeInference.ts] ////
+
+//// [reverseMappedThisTypeInference.ts]
+// Issue #62779: Type parameter leak caused by `this` and reverse mapped type
+declare function testReverseMapped<T extends Record<string, unknown>>(obj: {
+    [K in keyof T]: () => T[K];
+}): T;
+
+const obj = testReverseMapped({
+    a() {
+        return 0;
+    },
+    b() {
+        return this.a();
+    },
+});
+
+// Expected: { a: number; b: number; }
+// Actual bug: { a: number; b: T[string]; }
+
+
+//// [reverseMappedThisTypeInference.js]
+"use strict";
+var obj = testReverseMapped({
+    a: function () {
+        return 0;
+    },
+    b: function () {
+        return this.a();
+    },
+});
+// Expected: { a: number; b: number; }
+// Actual bug: { a: number; b: T[string]; }

tests/baselines/reference/reverseMappedThisTypeInference.symbols

@@ -0,0 +1,42 @@
+//// [tests/cases/compiler/reverseMappedThisTypeInference.ts] ////
+
+=== reverseMappedThisTypeInference.ts ===
+// Issue #62779: Type parameter leak caused by `this` and reverse mapped type
+declare function testReverseMapped<T extends Record<string, unknown>>(obj: {
+>testReverseMapped : Symbol(testReverseMapped, Decl(reverseMappedThisTypeInference.ts, 0, 0))
+>T : Symbol(T, Decl(reverseMappedThisTypeInference.ts, 1, 35))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>obj : Symbol(obj, Decl(reverseMappedThisTypeInference.ts, 1, 70))
+
+    [K in keyof T]: () => T[K];
+>K : Symbol(K, Decl(reverseMappedThisTypeInference.ts, 2, 5))
+>T : Symbol(T, Decl(reverseMappedThisTypeInference.ts, 1, 35))
+>T : Symbol(T, Decl(reverseMappedThisTypeInference.ts, 1, 35))
+>K : Symbol(K, Decl(reverseMappedThisTypeInference.ts, 2, 5))
+
+}): T;
+>T : Symbol(T, Decl(reverseMappedThisTypeInference.ts, 1, 35))
+
+const obj = testReverseMapped({
+>obj : Symbol(obj, Decl(reverseMappedThisTypeInference.ts, 5, 5))
+>testReverseMapped : Symbol(testReverseMapped, Decl(reverseMappedThisTypeInference.ts, 0, 0))
+
+    a() {
+>a : Symbol(a, Decl(reverseMappedThisTypeInference.ts, 5, 31))
+
+        return 0;
+    },
+    b() {
+>b : Symbol(b, Decl(reverseMappedThisTypeInference.ts, 8, 6))
+
+        return this.a();
+>this.a : Symbol(a, Decl(reverseMappedThisTypeInference.ts, 5, 31))
+>this : Symbol(__type, Decl(reverseMappedThisTypeInference.ts, 1, 74))
+>a : Symbol(a, Decl(reverseMappedThisTypeInference.ts, 5, 31))
+
+    },
+});
+
+// Expected: { a: number; b: number; }
+// Actual bug: { a: number; b: T[string]; }
+

tests/baselines/reference/reverseMappedThisTypeInference.types

@@ -0,0 +1,52 @@
+//// [tests/cases/compiler/reverseMappedThisTypeInference.ts] ////
+
+=== reverseMappedThisTypeInference.ts ===
+// Issue #62779: Type parameter leak caused by `this` and reverse mapped type
+declare function testReverseMapped<T extends Record<string, unknown>>(obj: {
+>testReverseMapped : <T extends Record<string, unknown>>(obj: { [K in keyof T]: () => T[K]; }) => T
+>                  : ^ ^^^^^^^^^                       ^^   ^^                               ^^^^^ 
+>obj : { [K in keyof T]: () => T[K]; }
+>    : ^^^ ^^^^^^^^^^^^^^^^^^^^    ^^^
+
+    [K in keyof T]: () => T[K];
+}): T;
+
+const obj = testReverseMapped({
+>obj : { a: number; b: number; }
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>testReverseMapped({    a() {        return 0;    },    b() {        return this.a();    },}) : { a: number; b: number; }
+>                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>testReverseMapped : <T extends Record<string, unknown>>(obj: { [K in keyof T]: () => T[K]; }) => T
+>                  : ^ ^^^^^^^^^                       ^^   ^^                               ^^^^^ 
+>{    a() {        return 0;    },    b() {        return this.a();    },} : { a(): number; b(): number; }
+>                                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    a() {
+>a : () => number
+>  : ^^^^^^^^^^^^
+
+        return 0;
+>0 : 0
+>  : ^
+
+    },
+    b() {
+>b : () => number
+>  : ^^^^^^^^^^^^
+
+        return this.a();
+>this.a() : number
+>         : ^^^^^^
+>this.a : () => number
+>       : ^^^^^^^^^^^^
+>this : { a: () => number; b: () => number; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>a : () => number
+>  : ^^^^^^^^^^^^
+
+    },
+});
+
+// Expected: { a: number; b: number; }
+// Actual bug: { a: number; b: T[string]; }
+

tests/cases/compiler/reverseMappedThisTypeInference.ts

@@ -0,0 +1,18 @@
+// @strict: true
+
+// Issue #62779: Type parameter leak caused by `this` and reverse mapped type
+declare function testReverseMapped<T extends Record<string, unknown>>(obj: {
+    [K in keyof T]: () => T[K];
+}): T;
+
+const obj = testReverseMapped({
+    a() {
+        return 0;
+    },
+    b() {
+        return this.a();
+    },
+});
+
+// Expected: { a: number; b: number; }
+// Actual bug: { a: number; b: T[string]; }