diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 72b9e4acadedb..b01352968eb42 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1000,6 +1000,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
             const saveExceptionTarget = currentExceptionTarget;
             const saveActiveLabelList = activeLabelList;
             const saveHasExplicitReturn = hasExplicitReturn;
+            const saveSeenThisKeyword = seenThisKeyword;
             const isImmediatelyInvoked = (
                 containerFlags & ContainerFlags.IsFunctionExpression &&
                 !hasSyntacticModifier(node, ModifierFlags.Async) &&
@@ -1022,19 +1023,22 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
             currentContinueTarget = undefined;
             activeLabelList = undefined;
             hasExplicitReturn = false;
+            seenThisKeyword = false;
             bindChildren(node);
-            // Reset all reachability check related flags on node (for incremental scenarios)
-            node.flags &= ~NodeFlags.ReachabilityAndEmitFlags;
+            // Reset flags (for incremental scenarios)
+            node.flags &= ~(NodeFlags.ReachabilityAndEmitFlags | NodeFlags.ContainsThis);
             if (!(currentFlow.flags & FlowFlags.Unreachable) && containerFlags & ContainerFlags.IsFunctionLike && nodeIsPresent((node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).body)) {
                 node.flags |= NodeFlags.HasImplicitReturn;
                 if (hasExplicitReturn) node.flags |= NodeFlags.HasExplicitReturn;
                 (node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).endFlowNode = currentFlow;
             }
+            if (seenThisKeyword) {
+                node.flags |= NodeFlags.ContainsThis;
+            }
             if (node.kind === SyntaxKind.SourceFile) {
                 node.flags |= emitFlags;
                 (node as SourceFile).endFlowNode = currentFlow;
             }
-
             if (currentReturnTarget) {
                 addAntecedent(currentReturnTarget, currentFlow);
                 currentFlow = finishFlowLabel(currentReturnTarget);
@@ -1051,12 +1055,15 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
             currentExceptionTarget = saveExceptionTarget;
             activeLabelList = saveActiveLabelList;
             hasExplicitReturn = saveHasExplicitReturn;
+            seenThisKeyword = node.kind === SyntaxKind.ArrowFunction ? saveSeenThisKeyword || seenThisKeyword : saveSeenThisKeyword;
         }
         else if (containerFlags & ContainerFlags.IsInterface) {
+            const saveSeenThisKeyword = seenThisKeyword;
             seenThisKeyword = false;
             bindChildren(node);
             Debug.assertNotNode(node, isIdentifier); // ContainsThis cannot overlap with HasExtendedUnicodeEscape on Identifier
             node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis;
+            seenThisKeyword = saveSeenThisKeyword;
         }
         else {
             bindChildren(node);
@@ -2852,6 +2859,9 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void {
                 }
                 // falls through
             case SyntaxKind.ThisKeyword:
+                if (node.kind === SyntaxKind.ThisKeyword) {
+                    seenThisKeyword = true;
+                }
                 // TODO: Why use `isExpression` here? both Identifier and ThisKeyword are expressions.
                 if (currentFlow && (isExpression(node) || parent.kind === SyntaxKind.ShorthandPropertyAssignment)) {
                     (node as Identifier | ThisExpression).flowNode = currentFlow;
@@ -3833,6 +3843,8 @@ export function getContainerFlags(node: Node): ContainerFlags {
             // falls through
         case SyntaxKind.Constructor:
         case SyntaxKind.FunctionDeclaration:
+        case SyntaxKind.ClassStaticBlockDeclaration:
+            return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike;
         case SyntaxKind.MethodSignature:
         case SyntaxKind.CallSignature:
         case SyntaxKind.JSDocSignature:
@@ -3840,12 +3852,11 @@ export function getContainerFlags(node: Node): ContainerFlags {
         case SyntaxKind.FunctionType:
         case SyntaxKind.ConstructSignature:
         case SyntaxKind.ConstructorType:
-        case SyntaxKind.ClassStaticBlockDeclaration:
-            return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike;
+            return ContainerFlags.IsContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike;
 
         case SyntaxKind.JSDocImportTag:
             // treat as a container to prevent using an enclosing effective host, ensuring import bindings are scoped correctly
-            return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals;
+            return ContainerFlags.IsContainer | ContainerFlags.HasLocals;
 
         case SyntaxKind.FunctionExpression:
         case SyntaxKind.ArrowFunction:
@@ -3853,8 +3864,6 @@ export function getContainerFlags(node: Node): ContainerFlags {
 
         case SyntaxKind.ModuleBlock:
             return ContainerFlags.IsControlFlowContainer;
-        case SyntaxKind.PropertyDeclaration:
-            return (node as PropertyDeclaration).initializer ? ContainerFlags.IsControlFlowContainer : 0;
 
         case SyntaxKind.CatchClause:
         case SyntaxKind.ForStatement:
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 74663e107cc66..80ded1c22ffff 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -21143,9 +21143,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 const { initializer } = node as JsxAttribute;
                 return !!initializer && isContextSensitive(initializer);
             }
-            case SyntaxKind.JsxExpression: {
+            case SyntaxKind.JsxExpression:
+            case SyntaxKind.YieldExpression: {
                 // It is possible to that node.expression is undefined (e.g <div x={} />)
-                const { expression } = node as JsxExpression;
+                const { expression } = node as JsxExpression | YieldExpression;
                 return !!expression && isContextSensitive(expression);
             }
         }
@@ -21154,7 +21155,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     }
 
     function isContextSensitiveFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean {
-        return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node);
+        return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node) || !!(getFunctionFlags(node) & FunctionFlags.Generator && node.body && forEachYieldExpression(node.body as Block, isContextSensitive));
     }
 
     function hasContextSensitiveReturnExpression(node: FunctionLikeDeclaration) {
@@ -32629,7 +32630,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             if (inferenceContext && contextFlags! & ContextFlags.Signature && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
                 // For contextual signatures we incorporate all inferences made so far, e.g. from return
                 // types as well as arguments to the left in a function call.
-                return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+                const type = instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+                if (!(type.flags & TypeFlags.AnyOrUnknown)) {
+                    return type;
+                }
             }
             if (inferenceContext?.returnMapper) {
                 // For other purposes (e.g. determining whether to produce literal types) we only
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index cdf898ca8c3fc..5562f9f736397 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -2880,19 +2880,24 @@ export function forEachReturnStatement<T>(body: Block | Statement, visitor: (stm
     }
 }
 
+// Warning: This has the same semantics as the forEach family of functions,
+//          in that traversal terminates in the event that 'visitor' supplies a truthy value.
 /** @internal */
-export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpression) => void): void {
+export function forEachYieldExpression<T>(body: Block, visitor: (expr: YieldExpression) => T): T | undefined {
     return traverse(body);
 
-    function traverse(node: Node): void {
+    function traverse(node: Node): T | undefined {
         switch (node.kind) {
             case SyntaxKind.YieldExpression:
-                visitor(node as YieldExpression);
+                const value = visitor(node as YieldExpression);
+                if (value) {
+                    return value;
+                }
                 const operand = (node as YieldExpression).expression;
-                if (operand) {
-                    traverse(operand);
+                if (!operand) {
+                    return;
                 }
-                return;
+                return traverse(operand);
             case SyntaxKind.EnumDeclaration:
             case SyntaxKind.InterfaceDeclaration:
             case SyntaxKind.ModuleDeclaration:
@@ -2905,14 +2910,13 @@ export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpress
                     if (node.name && node.name.kind === SyntaxKind.ComputedPropertyName) {
                         // Note that we will not include methods/accessors of a class because they would require
                         // first descending into the class. This is by design.
-                        traverse(node.name.expression);
-                        return;
+                        return traverse(node.name.expression);
                     }
                 }
                 else if (!isPartOfTypeNode(node)) {
                     // This is the general case, which should include mostly expressions and statements.
                     // Also includes NodeArrays.
-                    forEachChild(node, traverse);
+                    return forEachChild(node, traverse);
                 }
         }
     }
@@ -10829,7 +10833,7 @@ export function hasContextSensitiveParameters(node: FunctionLikeDeclaration): bo
             // an implicit 'this' parameter which is subject to contextual typing.
             const parameter = firstOrUndefined(node.parameters);
             if (!(parameter && parameterIsThisKeyword(parameter))) {
-                return true;
+                return !!(node.flags & NodeFlags.ContainsThis);
             }
         }
     }
diff --git a/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types b/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types
index 29b958c768ad3..5aa7b5c308c6b 100644
--- a/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types
+++ b/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types
@@ -1,8 +1,5 @@
 //// [tests/cases/compiler/circularlySimplifyingConditionalTypesNoCrash.ts] ////
 
-=== Performance Stats ===
-Instantiation count: 1,000
-
 === circularlySimplifyingConditionalTypesNoCrash.ts ===
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 >Omit : Omit<T, K>
@@ -71,8 +68,8 @@ declare var connect: Connect;
 const myStoreConnect: Connect = function(
 >myStoreConnect : Connect
 >               : ^^^^^^^
->function(    mapStateToProps?: any,    mapDispatchToProps?: any,    mergeProps?: any,    options: unknown = {},) {    return connect(        mapStateToProps,        mapDispatchToProps,        mergeProps,        options,    );} : <TStateProps, TOwnProps>(mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps<TStateProps, Omit<P, Extract<keyof TStateProps, keyof P>> & TOwnProps>
->                                                                                                                                                                                                                                   : ^           ^^         ^^               ^^^   ^^                  ^^^   ^^          ^^^   ^^       ^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>function(    mapStateToProps?: any,    mapDispatchToProps?: any,    mergeProps?: any,    options: unknown = {},) {    return connect(        mapStateToProps,        mapDispatchToProps,        mergeProps,        options,    );} : (mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps<TStateProps, Omit<P, Extract<keyof TStateProps, keyof P>> & TOwnProps>
+>                                                                                                                                                                                                                                   : ^               ^^^   ^^                  ^^^   ^^          ^^^   ^^       ^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     mapStateToProps?: any,
 >mapStateToProps : any
diff --git a/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt b/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt
index 6be00dcf3fb7c..d7a29da097bae 100644
--- a/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt
+++ b/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt
@@ -1,6 +1,6 @@
 first.js(23,9): error TS2554: Expected 1 arguments, but got 0.
 first.js(31,5): error TS2416: Property 'load' in type 'Sql' is not assignable to the same property in base type 'Wagon'.
-  Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[]) => void'.
+  Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[] | undefined) => void'.
     Target signature provides too few arguments. Expected 2 or more, but got 1.
 first.js(47,24): error TS2507: Type '(numberEaten: number) => void' is not a constructor function type.
 generic.js(19,19): error TS2554: Expected 1 arguments, but got 0.
@@ -8,7 +8,7 @@ generic.js(20,32): error TS2345: Argument of type 'number' is not assignable to
 second.ts(8,25): error TS2507: Type '(numberEaten: number) => void' is not a constructor function type.
 second.ts(14,7): error TS2417: Class static side 'typeof Conestoga' incorrectly extends base class static side 'typeof Wagon'.
   Types of property 'circle' are incompatible.
-    Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[]) => number'.
+    Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[] | undefined) => number'.
       Types of parameters 'others' and 'wagons' are incompatible.
         Type 'Wagon[]' is not assignable to type '(typeof Wagon)[]'.
           Property 'circle' is missing in type 'Wagon' but required in type 'typeof Wagon'.
@@ -52,7 +52,7 @@ second.ts(17,15): error TS2345: Argument of type 'string' is not assignable to p
         load(files, format) {
         ~~~~
 !!! error TS2416: Property 'load' in type 'Sql' is not assignable to the same property in base type 'Wagon'.
-!!! error TS2416:   Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[]) => void'.
+!!! error TS2416:   Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[] | undefined) => void'.
 !!! error TS2416:     Target signature provides too few arguments. Expected 2 or more, but got 1.
             if (format === "xmlolololol") {
                 throw new Error("please do not use XML. It was a joke.");
@@ -95,7 +95,7 @@ second.ts(17,15): error TS2345: Argument of type 'string' is not assignable to p
           ~~~~~~~~~
 !!! error TS2417: Class static side 'typeof Conestoga' incorrectly extends base class static side 'typeof Wagon'.
 !!! error TS2417:   Types of property 'circle' are incompatible.
-!!! error TS2417:     Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[]) => number'.
+!!! error TS2417:     Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[] | undefined) => number'.
 !!! error TS2417:       Types of parameters 'others' and 'wagons' are incompatible.
 !!! error TS2417:         Type 'Wagon[]' is not assignable to type '(typeof Wagon)[]'.
 !!! error TS2417:           Property 'circle' is missing in type 'Wagon' but required in type 'typeof Wagon'.
diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types
index 6196ace757ddb..0a4b1e599cf2e 100644
--- a/tests/baselines/reference/generatorTypeCheck62.types
+++ b/tests/baselines/reference/generatorTypeCheck62.types
@@ -117,8 +117,8 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: St
 export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing3 : Strategy<State>
 >         : ^^^^^^^^^^^^^^^
->strategy("Nothing", function* (state: State) {    yield ;    return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator<State, void>
->                                                                                                                                                        : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>strategy("Nothing", function* (state: State) {    yield ;    return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: any) => IterableIterator<any, void>
+>                                                                                                                                                        : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T | undefined, void>) => (a: T) => IterableIterator<T | undefined, void>
 >         : ^ ^^^^^^^^^              ^^         ^^      ^^   ^^                                               ^^^^^                                               
 >"Nothing" : "Nothing"
diff --git a/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.symbols b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.symbols
new file mode 100644
index 0000000000000..d3772db880ab9
--- /dev/null
+++ b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.symbols
@@ -0,0 +1,181 @@
+//// [tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts] ////
+
+=== genericCallAtYieldExpressionInGenericCall3.ts ===
+type ReadonlyRecord<in out K extends string | symbol, out A> = {
+>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0))
+>K : Symbol(K, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 20))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 53))
+
+  readonly [P in K]: A;
+>P : Symbol(P, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 1, 12))
+>K : Symbol(K, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 20))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 53))
+
+};
+
+type Success<T> = T extends Micro<infer _A, infer _E, infer _R> ? _A : never;
+>Success : Symbol(Success, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 2, 2))
+>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 13))
+>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 13))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>_A : Symbol(_A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 39))
+>_E : Symbol(_E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 49))
+>_R : Symbol(_R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 59))
+>_A : Symbol(_A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 39))
+
+interface MicroIterator<T extends Micro<any, any, any>> {
+>MicroIterator : Symbol(MicroIterator, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 77))
+>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 24))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+
+  next(...args: ReadonlyArray<any>): IteratorResult<T, Success<T>>;
+>next : Symbol(MicroIterator.next, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 57))
+>args : Symbol(args, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 7, 7))
+>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more)
+>IteratorResult : Symbol(IteratorResult, Decl(lib.es2015.iterable.d.ts, --, --))
+>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 24))
+>Success : Symbol(Success, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 2, 2))
+>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 24))
+}
+
+interface Micro<out A, out E = never, out R = never> {
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 16))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 22))
+>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 37))
+
+  _A: A;
+>_A : Symbol(Micro._A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 54))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 16))
+
+  _E: E;
+>_E : Symbol(Micro._E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 11, 8))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 22))
+
+  _R: R;
+>_R : Symbol(Micro._R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 12, 8))
+>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 37))
+
+  [Symbol.iterator](): MicroIterator<Micro<A, E, R>>;
+>[Symbol.iterator] : Symbol(Micro[Symbol.iterator], Decl(genericCallAtYieldExpressionInGenericCall3.ts, 13, 8))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>MicroIterator : Symbol(MicroIterator, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 77))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 16))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 22))
+>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 37))
+}
+
+declare function runPromise<A, E>(effect: Micro<A, E>): Promise<A>;
+>runPromise : Symbol(runPromise, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 15, 1))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 28))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 30))
+>effect : Symbol(effect, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 34))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 28))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 30))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 28))
+
+declare function gen<Eff extends Micro<any, any, any>, AEff>(
+>gen : Symbol(gen, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 67))
+>Eff : Symbol(Eff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 21))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>AEff : Symbol(AEff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 54))
+
+  body: () => Generator<Eff, AEff, never>,
+>body : Symbol(body, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 61))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+>Eff : Symbol(Eff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 21))
+>AEff : Symbol(AEff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 54))
+
+): Micro<AEff, any, never>;
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>AEff : Symbol(AEff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 54))
+
+declare const traverse: {
+>traverse : Symbol(traverse, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 23, 13))
+
+  <A, R, O, E, B>(
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 3))
+>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 5))
+>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 8))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 11))
+>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 14))
+
+    f: (a: A) => Micro<B, E, O>,
+>f : Symbol(f, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 18))
+>a : Symbol(a, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 25, 8))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 3))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 14))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 11))
+>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 8))
+
+  ): (
+    self: ReadonlyRecord<string, A>,
+>self : Symbol(self, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 26, 6))
+>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 3))
+
+  ) => Micro<ReadonlyRecord<string, B>, E, O>;
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0))
+>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 14))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 11))
+>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 8))
+
+  <A, O, E, B>(
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 3))
+>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 5))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 8))
+>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 11))
+
+    self: ReadonlyRecord<string, A>,
+>self : Symbol(self, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 15))
+>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 3))
+
+    f: (a: A) => Micro<B, E, O>,
+>f : Symbol(f, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 30, 36))
+>a : Symbol(a, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 31, 8))
+>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 3))
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 11))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 8))
+>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 5))
+
+  ): Micro<ReadonlyRecord<string, B>, E, O>;
+>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1))
+>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0))
+>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 11))
+>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 8))
+>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 5))
+
+};
+
+runPromise(
+>runPromise : Symbol(runPromise, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 15, 1))
+
+  gen(function* () {
+>gen : Symbol(gen, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 67))
+
+    yield* traverse({ a: 1, b: 2 }, (n) =>
+>traverse : Symbol(traverse, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 23, 13))
+>a : Symbol(a, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 21))
+>b : Symbol(b, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 27))
+>n : Symbol(n, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 37))
+
+      gen(function* () {
+>gen : Symbol(gen, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 67))
+
+        return n + 1;
+>n : Symbol(n, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 37))
+
+      }),
+    );
+  }),
+);
+
diff --git a/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.types b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.types
new file mode 100644
index 0000000000000..6888c696198b1
--- /dev/null
+++ b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.types
@@ -0,0 +1,154 @@
+//// [tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts] ////
+
+=== Performance Stats ===
+Type Count: 1,000
+Instantiation count: 2,500
+
+=== genericCallAtYieldExpressionInGenericCall3.ts ===
+type ReadonlyRecord<in out K extends string | symbol, out A> = {
+>ReadonlyRecord : ReadonlyRecord<K, A>
+>               : ^^^^^^^^^^^^^^^^^^^^
+
+  readonly [P in K]: A;
+};
+
+type Success<T> = T extends Micro<infer _A, infer _E, infer _R> ? _A : never;
+>Success : Success<T>
+>        : ^^^^^^^^^^
+
+interface MicroIterator<T extends Micro<any, any, any>> {
+  next(...args: ReadonlyArray<any>): IteratorResult<T, Success<T>>;
+>next : (...args: ReadonlyArray<any>) => IteratorResult<T, Success<T>>
+>     : ^^^^    ^^                  ^^^^^                             
+>args : readonly any[]
+>     : ^^^^^^^^^^^^^^
+}
+
+interface Micro<out A, out E = never, out R = never> {
+  _A: A;
+>_A : A
+>   : ^
+
+  _E: E;
+>_E : E
+>   : ^
+
+  _R: R;
+>_R : R
+>   : ^
+
+  [Symbol.iterator](): MicroIterator<Micro<A, E, R>>;
+>[Symbol.iterator] : () => MicroIterator<Micro<A, E, R>>
+>                  : ^^^^^^                             
+>Symbol.iterator : unique symbol
+>                : ^^^^^^^^^^^^^
+>Symbol : SymbolConstructor
+>       : ^^^^^^^^^^^^^^^^^
+>iterator : unique symbol
+>         : ^^^^^^^^^^^^^
+}
+
+declare function runPromise<A, E>(effect: Micro<A, E>): Promise<A>;
+>runPromise : <A, E>(effect: Micro<A, E>) => Promise<A>
+>           : ^ ^^ ^^      ^^           ^^^^^          
+>effect : Micro<A, E, never>
+>       : ^^^^^^^^^^^^^^^^^^
+
+declare function gen<Eff extends Micro<any, any, any>, AEff>(
+>gen : <Eff extends Micro<any, any, any>, AEff>(body: () => Generator<Eff, AEff, never>) => Micro<AEff, any, never>
+>    : ^   ^^^^^^^^^                    ^^    ^^    ^^                                 ^^^^^                       
+
+  body: () => Generator<Eff, AEff, never>,
+>body : () => Generator<Eff, AEff, never>
+>     : ^^^^^^                           
+
+): Micro<AEff, any, never>;
+
+declare const traverse: {
+>traverse : { <A, R, O, E, B>(f: (a: A) => Micro<B, E, O>): (self: ReadonlyRecord<string, A>) => Micro<ReadonlyRecord<string, B>, E, O>; <A, O, E, B>(self: ReadonlyRecord<string, A>, f: (a: A) => Micro<B, E, O>): Micro<ReadonlyRecord<string, B>, E, O>; }
+>         : ^^^ ^^ ^^ ^^ ^^ ^^ ^^                        ^^^                                                                           ^^^ ^^ ^^ ^^ ^^    ^^                         ^^ ^^                        ^^^                                      ^^^
+
+  <A, R, O, E, B>(
+    f: (a: A) => Micro<B, E, O>,
+>f : (a: A) => Micro<B, E, O>
+>  : ^ ^^ ^^^^^              
+>a : A
+>  : ^
+
+  ): (
+    self: ReadonlyRecord<string, A>,
+>self : ReadonlyRecord<string, A>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  ) => Micro<ReadonlyRecord<string, B>, E, O>;
+  <A, O, E, B>(
+    self: ReadonlyRecord<string, A>,
+>self : ReadonlyRecord<string, A>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    f: (a: A) => Micro<B, E, O>,
+>f : (a: A) => Micro<B, E, O>
+>  : ^ ^^ ^^^^^              
+>a : A
+>  : ^
+
+  ): Micro<ReadonlyRecord<string, B>, E, O>;
+};
+
+runPromise(
+>runPromise(  gen(function* () {    yield* traverse({ a: 1, b: 2 }, (n) =>      gen(function* () {        return n + 1;      }),    );  }),) : Promise<void>
+>                                                                                                                                            : ^^^^^^^^^^^^^
+>runPromise : <A, E>(effect: Micro<A, E>) => Promise<A>
+>           : ^ ^^ ^^      ^^           ^^^^^          
+
+  gen(function* () {
+>gen(function* () {    yield* traverse({ a: 1, b: 2 }, (n) =>      gen(function* () {        return n + 1;      }),    );  }) : Micro<void, any, never>
+>                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^
+>gen : <Eff extends Micro<any, any, any>, AEff>(body: () => Generator<Eff, AEff, never>) => Micro<AEff, any, never>
+>    : ^   ^^^^^^^^^                    ^^    ^^    ^^                                 ^^^^^                       
+>function* () {    yield* traverse({ a: 1, b: 2 }, (n) =>      gen(function* () {        return n + 1;      }),    );  } : () => Generator<Micro<ReadonlyRecord<string, number>, any, never>, void, any>
+>                                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    yield* traverse({ a: 1, b: 2 }, (n) =>
+>yield* traverse({ a: 1, b: 2 }, (n) =>      gen(function* () {        return n + 1;      }),    ) : ReadonlyRecord<string, number>
+>                                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>traverse({ a: 1, b: 2 }, (n) =>      gen(function* () {        return n + 1;      }),    ) : Micro<ReadonlyRecord<string, number>, any, never>
+>                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>traverse : { <A, R, O, E, B>(f: (a: A) => Micro<B, E, O>): (self: ReadonlyRecord<string, A>) => Micro<ReadonlyRecord<string, B>, E, O>; <A, O, E, B>(self: ReadonlyRecord<string, A>, f: (a: A) => Micro<B, E, O>): Micro<ReadonlyRecord<string, B>, E, O>; }
+>         : ^^^ ^^ ^^ ^^ ^^ ^^ ^^                        ^^^                                                                           ^^^ ^^ ^^ ^^ ^^    ^^                         ^^ ^^                        ^^^                                      ^^^
+>{ a: 1, b: 2 } : { a: number; b: number; }
+>               : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>a : number
+>  : ^^^^^^
+>1 : 1
+>  : ^
+>b : number
+>  : ^^^^^^
+>2 : 2
+>  : ^
+>(n) =>      gen(function* () {        return n + 1;      }) : (n: number) => Micro<number, any, never>
+>                                                            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>n : number
+>  : ^^^^^^
+
+      gen(function* () {
+>gen(function* () {        return n + 1;      }) : Micro<number, any, never>
+>                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>gen : <Eff extends Micro<any, any, any>, AEff>(body: () => Generator<Eff, AEff, never>) => Micro<AEff, any, never>
+>    : ^   ^^^^^^^^^                    ^^    ^^    ^^                                 ^^^^^                       
+>function* () {        return n + 1;      } : () => Generator<never, number, never>
+>                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+        return n + 1;
+>n + 1 : number
+>      : ^^^^^^
+>n : number
+>  : ^^^^^^
+>1 : 1
+>  : ^
+
+      }),
+    );
+  }),
+);
+
diff --git a/tests/baselines/reference/jsdocTemplateTag.errors.txt b/tests/baselines/reference/jsdocTemplateTag.errors.txt
index 74a150c6e3cd0..308b9e4bd23c7 100644
--- a/tests/baselines/reference/jsdocTemplateTag.errors.txt
+++ b/tests/baselines/reference/jsdocTemplateTag.errors.txt
@@ -1,4 +1,4 @@
-forgot.js(23,1): error TS2322: Type '(keyframes: any[]) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'.
+forgot.js(23,1): error TS2322: Type '(keyframes: Array<any>) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'.
   Type 'void' is not assignable to type 'Animation'.
 
 
@@ -27,6 +27,6 @@ forgot.js(23,1): error TS2322: Type '(keyframes: any[]) => void' is not assignab
      */
     Element.prototype.animate = function(keyframes) {};
     ~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2322: Type '(keyframes: any[]) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'.
+!!! error TS2322: Type '(keyframes: Array<any>) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'.
 !!! error TS2322:   Type 'void' is not assignable to type 'Animation'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/redefineArray.errors.txt b/tests/baselines/reference/redefineArray.errors.txt
index 87a448e677a3f..b831151ee7922 100644
--- a/tests/baselines/reference/redefineArray.errors.txt
+++ b/tests/baselines/reference/redefineArray.errors.txt
@@ -1,7 +1,7 @@
-redefineArray.ts(1,1): error TS2739: Type '<T>(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species]
+redefineArray.ts(1,1): error TS2739: Type '(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species]
 
 
 ==== redefineArray.ts (1 errors) ====
     Array = function (n:number, s:string) {return n;};
     ~~~~~
-!!! error TS2739: Type '<T>(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species]
\ No newline at end of file
+!!! error TS2739: Type '(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species]
\ No newline at end of file
diff --git a/tests/baselines/reference/redefineArray.types b/tests/baselines/reference/redefineArray.types
index d4df39d46b393..221d20711fa31 100644
--- a/tests/baselines/reference/redefineArray.types
+++ b/tests/baselines/reference/redefineArray.types
@@ -2,12 +2,12 @@
 
 === redefineArray.ts ===
 Array = function (n:number, s:string) {return n;};
->Array = function (n:number, s:string) {return n;} : <T>(n: number, s: string) => number
->                                                  : ^ ^^ ^^      ^^ ^^      ^^^^^^^^^^^
+>Array = function (n:number, s:string) {return n;} : (n: number, s: string) => number
+>                                                  : ^ ^^      ^^ ^^      ^^^^^^^^^^^
 >Array : ArrayConstructor
 >      : ^^^^^^^^^^^^^^^^
->function (n:number, s:string) {return n;} : <T>(n: number, s: string) => number
->                                          : ^ ^^ ^^      ^^ ^^      ^^^^^^^^^^^
+>function (n:number, s:string) {return n;} : (n: number, s: string) => number
+>                                          : ^ ^^      ^^ ^^      ^^^^^^^^^^^
 >n : number
 >  : ^^^^^^
 >s : string
diff --git a/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.symbols b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.symbols
new file mode 100644
index 0000000000000..ef2a5fd660edc
--- /dev/null
+++ b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.symbols
@@ -0,0 +1,165 @@
+//// [tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts] ////
+
+=== returnTypeInferenceContextualParameterTypesInGenerator1.ts ===
+interface Effect<out A> {
+>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0))
+>A : Symbol(A, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 17))
+
+  readonly _A: A;
+>_A : Symbol(Effect._A, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 25))
+>A : Symbol(A, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 17))
+}
+
+declare function gen<Eff extends Effect<any>, AEff>(
+>gen : Symbol(gen, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 2, 1))
+>Eff : Symbol(Eff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 21))
+>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0))
+>AEff : Symbol(AEff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 45))
+
+  f: () => Generator<Eff, AEff>
+>f : Symbol(f, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 52))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+>Eff : Symbol(Eff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 21))
+>AEff : Symbol(AEff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 45))
+
+): Effect<AEff>;
+>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0))
+>AEff : Symbol(AEff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 45))
+
+interface Rpc<
+>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16))
+
+  in out Tag extends string,
+>Tag : Symbol(Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 8, 14))
+
+  out Payload = unknown,
+>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 9, 28))
+
+  out Success = unknown
+>Success : Symbol(Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 10, 24))
+
+> {
+  readonly _tag: Tag;
+>_tag : Symbol(Rpc._tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 12, 3))
+>Tag : Symbol(Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 8, 14))
+
+  readonly payloadSchema: Payload;
+>payloadSchema : Symbol(Rpc.payloadSchema, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 13, 21))
+>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 9, 28))
+
+  readonly successSchema: Success;
+>successSchema : Symbol(Rpc.successSchema, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 14, 34))
+>Success : Symbol(Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 10, 24))
+}
+
+interface RpcAny {
+>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1))
+
+  readonly _tag: string;
+>_tag : Symbol(RpcAny._tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 18, 18))
+}
+
+type Payload<R> = R extends Rpc<infer _Tag, infer _Payload, infer _Success>
+>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 20, 1))
+>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 13))
+>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 13))
+>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16))
+>_Tag : Symbol(_Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 37))
+>_Payload : Symbol(_Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 49))
+>_Success : Symbol(_Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 65))
+
+  ? _Payload
+>_Payload : Symbol(_Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 49))
+
+  : never;
+
+type ResultFrom<R extends RpcAny> = R extends Rpc<
+>ResultFrom : Symbol(ResultFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 24, 10))
+>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 26, 16))
+>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1))
+>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 26, 16))
+>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16))
+
+  infer _Tag,
+>_Tag : Symbol(_Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 27, 7))
+
+  infer _Payload,
+>_Payload : Symbol(_Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 28, 7))
+
+  infer _Success
+>_Success : Symbol(_Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 29, 7))
+
+>
+  ? _Success
+>_Success : Symbol(_Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 29, 7))
+
+  : never;
+
+type ToHandlerFn<Current extends RpcAny> = (
+>ToHandlerFn : Symbol(ToHandlerFn, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 32, 10))
+>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 17))
+>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1))
+
+  payload: Payload<Current>
+>payload : Symbol(payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 44))
+>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 20, 1))
+>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 17))
+
+) => ResultFrom<Current>;
+>ResultFrom : Symbol(ResultFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 24, 10))
+>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 17))
+
+type HandlersFrom<Rpc extends RpcAny> = {
+>HandlersFrom : Symbol(HandlersFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 36, 25))
+>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 38, 18))
+>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1))
+
+  readonly [Current in Rpc as Current["_tag"]]: ToHandlerFn<Current>;
+>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 39, 12))
+>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 38, 18))
+>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 39, 12))
+>ToHandlerFn : Symbol(ToHandlerFn, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 32, 10))
+>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 39, 12))
+
+};
+
+interface RpcGroup<in out R extends RpcAny> {
+>RpcGroup : Symbol(RpcGroup, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 40, 2))
+>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 19))
+>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1))
+
+  toLayer<Handlers extends HandlersFrom<R>>(build: Effect<Handlers>): unknown;
+>toLayer : Symbol(RpcGroup.toLayer, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 45))
+>Handlers : Symbol(Handlers, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 43, 10))
+>HandlersFrom : Symbol(HandlersFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 36, 25))
+>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 19))
+>build : Symbol(build, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 43, 44))
+>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0))
+>Handlers : Symbol(Handlers, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 43, 10))
+}
+
+declare const Rpcs: RpcGroup<Rpc<"Register", number, string>>;
+>Rpcs : Symbol(Rpcs, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 46, 13))
+>RpcGroup : Symbol(RpcGroup, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 40, 2))
+>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16))
+
+export const layerServerHandlers = Rpcs.toLayer(
+>layerServerHandlers : Symbol(layerServerHandlers, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 48, 12))
+>Rpcs.toLayer : Symbol(RpcGroup.toLayer, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 45))
+>Rpcs : Symbol(Rpcs, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 46, 13))
+>toLayer : Symbol(RpcGroup.toLayer, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 45))
+
+  gen(function* () {
+>gen : Symbol(gen, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 2, 1))
+
+    return {
+      Register: (id) => String(id),
+>Register : Symbol(Register, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 50, 12))
+>id : Symbol(id, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 51, 17))
+>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 7 more)
+>id : Symbol(id, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 51, 17))
+
+    };
+  })
+);
+
diff --git a/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.types b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.types
new file mode 100644
index 0000000000000..71a5b114a505e
--- /dev/null
+++ b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.types
@@ -0,0 +1,136 @@
+//// [tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts] ////
+
+=== Performance Stats ===
+Type Count: 1,000
+Instantiation count: 2,500
+
+=== returnTypeInferenceContextualParameterTypesInGenerator1.ts ===
+interface Effect<out A> {
+  readonly _A: A;
+>_A : A
+>   : ^
+}
+
+declare function gen<Eff extends Effect<any>, AEff>(
+>gen : <Eff extends Effect<any>, AEff>(f: () => Generator<Eff, AEff>) => Effect<AEff>
+>    : ^   ^^^^^^^^^           ^^    ^^ ^^                          ^^^^^            
+
+  f: () => Generator<Eff, AEff>
+>f : () => Generator<Eff, AEff>
+>  : ^^^^^^                    
+
+): Effect<AEff>;
+
+interface Rpc<
+  in out Tag extends string,
+  out Payload = unknown,
+  out Success = unknown
+> {
+  readonly _tag: Tag;
+>_tag : Tag
+>     : ^^^
+
+  readonly payloadSchema: Payload;
+>payloadSchema : Payload
+>              : ^^^^^^^
+
+  readonly successSchema: Success;
+>successSchema : Success
+>              : ^^^^^^^
+}
+
+interface RpcAny {
+  readonly _tag: string;
+>_tag : string
+>     : ^^^^^^
+}
+
+type Payload<R> = R extends Rpc<infer _Tag, infer _Payload, infer _Success>
+>Payload : Payload<R>
+>        : ^^^^^^^^^^
+
+  ? _Payload
+  : never;
+
+type ResultFrom<R extends RpcAny> = R extends Rpc<
+>ResultFrom : ResultFrom<R>
+>           : ^^^^^^^^^^^^^
+
+  infer _Tag,
+  infer _Payload,
+  infer _Success
+>
+  ? _Success
+  : never;
+
+type ToHandlerFn<Current extends RpcAny> = (
+>ToHandlerFn : ToHandlerFn<Current>
+>            : ^^^^^^^^^^^^^^^^^^^^
+
+  payload: Payload<Current>
+>payload : Payload<Current>
+>        : ^^^^^^^^^^^^^^^^
+
+) => ResultFrom<Current>;
+
+type HandlersFrom<Rpc extends RpcAny> = {
+>HandlersFrom : HandlersFrom<Rpc>
+>             : ^^^^^^^^^^^^^^^^^
+
+  readonly [Current in Rpc as Current["_tag"]]: ToHandlerFn<Current>;
+};
+
+interface RpcGroup<in out R extends RpcAny> {
+  toLayer<Handlers extends HandlersFrom<R>>(build: Effect<Handlers>): unknown;
+>toLayer : <Handlers extends HandlersFrom<R>>(build: Effect<Handlers>) => unknown
+>        : ^        ^^^^^^^^^               ^^     ^^                ^^^^^       
+>build : Effect<Handlers>
+>      : ^^^^^^^^^^^^^^^^
+}
+
+declare const Rpcs: RpcGroup<Rpc<"Register", number, string>>;
+>Rpcs : RpcGroup<Rpc<"Register", number, string>>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+export const layerServerHandlers = Rpcs.toLayer(
+>layerServerHandlers : unknown
+>                    : ^^^^^^^
+>Rpcs.toLayer(  gen(function* () {    return {      Register: (id) => String(id),    };  })) : unknown
+>                                                                                            : ^^^^^^^
+>Rpcs.toLayer : <Handlers extends HandlersFrom<Rpc<"Register", number, string>>>(build: Effect<Handlers>) => unknown
+>             : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       
+>Rpcs : RpcGroup<Rpc<"Register", number, string>>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>toLayer : <Handlers extends HandlersFrom<Rpc<"Register", number, string>>>(build: Effect<Handlers>) => unknown
+>        : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^       
+
+  gen(function* () {
+>gen(function* () {    return {      Register: (id) => String(id),    };  }) : Effect<{ Register: (id: number) => string; }>
+>                                                                            : ^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^
+>gen : <Eff extends Effect<any>, AEff>(f: () => Generator<Eff, AEff>) => Effect<AEff>
+>    : ^   ^^^^^^^^^           ^^    ^^ ^^                          ^^^^^            
+>function* () {    return {      Register: (id) => String(id),    };  } : () => Generator<never, { Register: (id: number) => string; }, any>
+>                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    return {
+>{      Register: (id) => String(id),    } : { Register: (id: number) => string; }
+>                                          : ^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^
+
+      Register: (id) => String(id),
+>Register : (id: number) => string
+>         : ^  ^^^^^^^^^^^^^^^^^^^
+>(id) => String(id) : (id: number) => string
+>                   : ^  ^^^^^^^^^^^^^^^^^^^
+>id : number
+>   : ^^^^^^
+>String(id) : string
+>           : ^^^^^^
+>String : StringConstructor
+>       : ^^^^^^^^^^^^^^^^^
+>id : number
+>   : ^^^^^^
+
+    };
+  })
+);
+
diff --git a/tests/baselines/reference/thisTypeInFunctions.types b/tests/baselines/reference/thisTypeInFunctions.types
index 1f704de6562eb..26dbe2202d918 100644
--- a/tests/baselines/reference/thisTypeInFunctions.types
+++ b/tests/baselines/reference/thisTypeInFunctions.types
@@ -203,8 +203,8 @@ function implicitThis(n: number): number {
 let impl: I = {
 >impl : I
 >     : ^
->{    a: 12,    explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?)    explicitVoid1() { return 12; },    explicitStructural() {        return this.a;    },    explicitInterface() {        return this.a;    },    explicitThis() {        return this.a;    },} : { a: number; explicitVoid2: () => any; explicitVoid1(this: void): number; explicitStructural(this: { a: number; }): number; explicitInterface(this: I): number; explicitThis(this: I): number; }
->                                                                                                                                                                                                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^ ^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^
+>{    a: 12,    explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?)    explicitVoid1() { return 12; },    explicitStructural() {        return this.a;    },    explicitInterface() {        return this.a;    },    explicitThis() {        return this.a;    },} : { a: number; explicitVoid2: () => any; explicitVoid1(): number; explicitStructural(this: { a: number; }): number; explicitInterface(this: I): number; explicitThis(this: I): number; }
+>                                                                                                                                                                                                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^ ^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^
 
     a: 12,
 >a : number
@@ -225,8 +225,8 @@ let impl: I = {
 >  : ^^^
 
     explicitVoid1() { return 12; },
->explicitVoid1 : (this: void) => number
->              : ^    ^^    ^^^^^^^^^^^
+>explicitVoid1 : () => number
+>              : ^^^^^^^^^^^^
 >12 : 12
 >   : ^^
 
@@ -271,16 +271,16 @@ let impl: I = {
     },
 }
 impl.explicitVoid1 = function () { return 12; };
->impl.explicitVoid1 = function () { return 12; } : (this: void) => number
->                                                : ^    ^^    ^^^^^^^^^^^
+>impl.explicitVoid1 = function () { return 12; } : () => number
+>                                                : ^^^^^^^^^^^^
 >impl.explicitVoid1 : (this: void) => number
 >                   : ^    ^^    ^^^^^      
 >impl : I
 >     : ^
 >explicitVoid1 : (this: void) => number
 >              : ^    ^^    ^^^^^      
->function () { return 12; } : (this: void) => number
->                           : ^    ^^    ^^^^^^^^^^^
+>function () { return 12; } : () => number
+>                           : ^^^^^^^^^^^^
 >12 : 12
 >   : ^^
 
@@ -736,8 +736,8 @@ let anyToSpecified: (this: { y: number }, x: number) => number = function(x: num
 >  : ^^^^^^
 >x : number
 >  : ^^^^^^
->function(x: number): number { return x + 12; } : (this: { y: number; }, x: number) => number
->                                               : ^    ^^              ^^ ^^      ^^^^^      
+>function(x: number): number { return x + 12; } : (x: number) => number
+>                                               : ^ ^^      ^^^^^      
 >x : number
 >  : ^^^^^^
 >x + 12 : number
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive1.errors.txt b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.errors.txt
new file mode 100644
index 0000000000000..f3ad16d09ea13
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.errors.txt
@@ -0,0 +1,252 @@
+thislessFunctionsNotContextSensitive1.ts(25,3): error TS2345: Argument of type 'false' is not assignable to parameter of type 'true'.
+thislessFunctionsNotContextSensitive1.ts(143,13): error TS2345: Argument of type '"value"' is not assignable to parameter of type 'never'.
+thislessFunctionsNotContextSensitive1.ts(176,3): error TS2820: Type '"$test6"' is not assignable to type 'ExtractFields<{ target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }> | undefined'. Did you mean '"$test4"'?
+
+
+==== thislessFunctionsNotContextSensitive1.ts (3 errors) ====
+    // https://github.com/microsoft/TypeScript/issues/62204
+    
+    declare function TestConfig<const TConfig extends { a?: any; b?: any; c?: any }>(
+      config: TConfig,
+      test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false,
+    ): void;
+    
+    TestConfig(
+      {
+        a: "hello",
+        b: function () {
+          return 123;
+        },
+      },
+      true,
+    );
+    
+    TestConfig(
+      {
+        a: "hello",
+        b: function () {
+          return 123;
+        },
+      },
+      false, // error
+      ~~~~~
+!!! error TS2345: Argument of type 'false' is not assignable to parameter of type 'true'.
+    );
+    
+    // https://github.com/microsoft/TypeScript/issues/60986
+    interface SubscribeFieldOptions<Event> {
+      subscribe: () => Event;
+      resolve: (event: Event) => number;
+    }
+    
+    declare function defineOptions<Event>(
+      options: SubscribeFieldOptions<Event>,
+    ): void;
+    
+    defineOptions({
+      resolve: (event) => event, // number
+      subscribe() {
+        return 123;
+      },
+    });
+    
+    defineOptions({
+      resolve: (event) => event, // number
+      subscribe: function () {
+        return 123;
+      },
+    });
+    
+    // https://github.com/microsoft/TypeScript/issues/58630
+    
+    export type StateFunction<State> = (s: State, ...args: any[]) => any;
+    
+    export type VuexStoreOptions<State, Modules> = {
+      state?: State | (() => State) | { (): State };
+      mutations?: Record<string, StateFunction<State>>;
+      modules?: {
+        [k in keyof Modules]: VuexStoreOptions<Modules[k], never>;
+      };
+    };
+    
+    export function createStore<
+      State extends Record<string, unknown>,
+      Modules extends Record<string, Record<string, unknown>>,
+    >(options: VuexStoreOptions<State, Modules>) {}
+    
+    const store = createStore({
+      state() {
+        return { bar2: 1 };
+      },
+      mutations: { inc: (state123) => state123.bar2++ },
+      modules: {
+        foo: {
+          state() {
+            return { bar2: 1 };
+          },
+          mutations: { inc: (state) => state.bar2++ },
+        },
+      },
+    });
+    
+    // https://github.com/microsoft/TypeScript/issues/57572
+    
+    type C = <Methods, Attached = (methods: Methods) => void>(options: {
+      methods: Methods;
+      attached: Attached;
+    }) => any;
+    
+    var Component: C = () => {};
+    
+    Component({
+      attached(methods) {
+        methods.bbb(); // ok
+      },
+      methods: {
+        bbb() {},
+      },
+    });
+    
+    Component({
+      attached(methods) {
+        methods.bbb(); // ok
+      },
+      methods: {
+        bbb: () => {},
+      },
+    });
+    
+    // https://github.com/microsoft/TypeScript/issues/56067
+    
+    declare function create56067<
+      State extends Record<string, any>,
+      Data extends Record<string, any>,
+      Actions extends (state: State, data: Data) => Record<string, any>,
+    >(args: { getState: () => State; actions: Actions; getData: () => Data }): void;
+    
+    create56067({
+      getState() {
+        return { a: 1 };
+      },
+      getData: () => {
+        return { b: 2 };
+      },
+      actions(state, data) {
+        state // { a: number }
+        data; // { b: number }
+        return {
+          z: 1,
+        };
+      },
+    });
+    
+    // https://github.com/microsoft/TypeScript/issues/55489
+    type NonStringIterable<T> = 
+      T extends string ? never : T extends Iterable<any> ? T : never;
+    
+    declare function doSomething<T>(value: NonStringIterable<T>): T;
+    
+    const o = { foo() {} };
+    
+    doSomething('value'); // error
+                ~~~~~~~
+!!! error TS2345: Argument of type '"value"' is not assignable to parameter of type 'never'.
+    doSomething(['v']); // ok
+    doSomething([o]); // ok
+    doSomething([{ foo() {} }]); // ok
+    
+    // https://github.com/microsoft/TypeScript/issues/55124
+    type Values<T> = T[keyof T];
+    type ExtractFields<Options> = Values<{
+      [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never;
+    }>;
+    type SetType<Options> = {
+      [key: string]: any;
+      target?: ExtractFields<Options>;
+    };
+    
+    declare function test55124<OptionsData extends SetType<OptionsData>>(
+      options: OptionsData,
+    ): void;
+    
+    test55124({
+      target: "$test4", // ok
+      data1: {
+        $test1: 111,
+        $test2: null,
+      },
+      data2: {
+        $test3: {},
+        $test4: () => {},
+        $test5() {},
+      },
+    });
+    
+    test55124({
+      target: "$test6", // error
+      ~~~~~~
+!!! error TS2820: Type '"$test6"' is not assignable to type 'ExtractFields<{ target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }> | undefined'. Did you mean '"$test4"'?
+!!! related TS6500 thislessFunctionsNotContextSensitive1.ts:155:3: The expected type comes from property 'target' which is declared here on type 'SetType<{ target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }>'
+      data1: {
+        $test1: 111,
+        $test2: null,
+      },
+      data2: {
+        $test3: {},
+        $test4: () => {},
+        $test5() {},
+      },
+    });
+    
+    // https://github.com/microsoft/TypeScript/issues/53924
+    function test53924<T = unknown>(options: { a: (c: T) => void; b: () => T }) {}
+    
+    test53924({
+      a: (c) => {
+        c; // number;
+      },
+      b: () => 123,
+    });
+    
+    test53924({
+      b: () => 123,
+      a: (c) => {
+        return c; // number
+      },
+    });
+    
+    test53924({
+      b() {
+        return 123;
+      },
+      a(c) {
+        return c; // number
+      },
+    });
+    
+    test53924({
+      a(c) {
+        return c; // number
+      },
+      b() {
+        return 123;
+      },
+    });
+    
+    // https://github.com/microsoft/TypeScript/issues/50258
+    declare function monitor<T extends (...args: any) => any>(
+      extractor: (...args: Parameters<T>) => Record<string, unknown>,
+      executor: T,
+    ): (...args: Parameters<T>) => ReturnType<T>;
+    
+    monitor(
+      (p) => ({ p }), // { p: number }
+      (p: number) => p,
+    );
+    monitor(
+      (p) => ({ p }), // { p: number }
+      function (p: number) {
+        return p;
+      },
+    );
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive1.symbols b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.symbols
new file mode 100644
index 0000000000000..133cc720cbab1
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.symbols
@@ -0,0 +1,621 @@
+//// [tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts] ////
+
+=== thislessFunctionsNotContextSensitive1.ts ===
+// https://github.com/microsoft/TypeScript/issues/62204
+
+declare function TestConfig<const TConfig extends { a?: any; b?: any; c?: any }>(
+>TestConfig : Symbol(TestConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 0, 0))
+>TConfig : Symbol(TConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 28))
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 51))
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 60))
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 69))
+
+  config: TConfig,
+>config : Symbol(config, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 81))
+>TConfig : Symbol(TConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 28))
+
+  test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false,
+>test : Symbol(test, Decl(thislessFunctionsNotContextSensitive1.ts, 3, 18))
+>Omit : Symbol(Omit, Decl(lib.es5.d.ts, --, --))
+>TConfig : Symbol(TConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 28))
+
+): void;
+
+TestConfig(
+>TestConfig : Symbol(TestConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 0, 0))
+  {
+    a: "hello",
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 8, 3))
+
+    b: function () {
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 9, 15))
+
+      return 123;
+    },
+  },
+  true,
+);
+
+TestConfig(
+>TestConfig : Symbol(TestConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 0, 0))
+  {
+    a: "hello",
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 18, 3))
+
+    b: function () {
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 19, 15))
+
+      return 123;
+    },
+  },
+  false, // error
+);
+
+// https://github.com/microsoft/TypeScript/issues/60986
+interface SubscribeFieldOptions<Event> {
+>SubscribeFieldOptions : Symbol(SubscribeFieldOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 25, 2))
+>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 32))
+
+  subscribe: () => Event;
+>subscribe : Symbol(SubscribeFieldOptions.subscribe, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 40))
+>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 32))
+
+  resolve: (event: Event) => number;
+>resolve : Symbol(SubscribeFieldOptions.resolve, Decl(thislessFunctionsNotContextSensitive1.ts, 29, 25))
+>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 30, 12))
+>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 32))
+}
+
+declare function defineOptions<Event>(
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 31, 1))
+>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 33, 31))
+
+  options: SubscribeFieldOptions<Event>,
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 33, 38))
+>SubscribeFieldOptions : Symbol(SubscribeFieldOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 25, 2))
+>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 33, 31))
+
+): void;
+
+defineOptions({
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 31, 1))
+
+  resolve: (event) => event, // number
+>resolve : Symbol(resolve, Decl(thislessFunctionsNotContextSensitive1.ts, 37, 15))
+>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 38, 12))
+>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 38, 12))
+
+  subscribe() {
+>subscribe : Symbol(subscribe, Decl(thislessFunctionsNotContextSensitive1.ts, 38, 28))
+
+    return 123;
+  },
+});
+
+defineOptions({
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 31, 1))
+
+  resolve: (event) => event, // number
+>resolve : Symbol(resolve, Decl(thislessFunctionsNotContextSensitive1.ts, 44, 15))
+>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 45, 12))
+>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 45, 12))
+
+  subscribe: function () {
+>subscribe : Symbol(subscribe, Decl(thislessFunctionsNotContextSensitive1.ts, 45, 28))
+
+    return 123;
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/58630
+
+export type StateFunction<State> = (s: State, ...args: any[]) => any;
+>StateFunction : Symbol(StateFunction, Decl(thislessFunctionsNotContextSensitive1.ts, 49, 3))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 26))
+>s : Symbol(s, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 36))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 26))
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 45))
+
+export type VuexStoreOptions<State, Modules> = {
+>VuexStoreOptions : Symbol(VuexStoreOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 69))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29))
+>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 35))
+
+  state?: State | (() => State) | { (): State };
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 48))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29))
+
+  mutations?: Record<string, StateFunction<State>>;
+>mutations : Symbol(mutations, Decl(thislessFunctionsNotContextSensitive1.ts, 56, 48))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>StateFunction : Symbol(StateFunction, Decl(thislessFunctionsNotContextSensitive1.ts, 49, 3))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29))
+
+  modules?: {
+>modules : Symbol(modules, Decl(thislessFunctionsNotContextSensitive1.ts, 57, 51))
+
+    [k in keyof Modules]: VuexStoreOptions<Modules[k], never>;
+>k : Symbol(k, Decl(thislessFunctionsNotContextSensitive1.ts, 59, 5))
+>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 35))
+>VuexStoreOptions : Symbol(VuexStoreOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 69))
+>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 35))
+>k : Symbol(k, Decl(thislessFunctionsNotContextSensitive1.ts, 59, 5))
+
+  };
+};
+
+export function createStore<
+>createStore : Symbol(createStore, Decl(thislessFunctionsNotContextSensitive1.ts, 61, 2))
+
+  State extends Record<string, unknown>,
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 63, 28))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+  Modules extends Record<string, Record<string, unknown>>,
+>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 64, 40))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+>(options: VuexStoreOptions<State, Modules>) {}
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 66, 2))
+>VuexStoreOptions : Symbol(VuexStoreOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 69))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 63, 28))
+>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 64, 40))
+
+const store = createStore({
+>store : Symbol(store, Decl(thislessFunctionsNotContextSensitive1.ts, 68, 5))
+>createStore : Symbol(createStore, Decl(thislessFunctionsNotContextSensitive1.ts, 61, 2))
+
+  state() {
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 68, 27))
+
+    return { bar2: 1 };
+>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 70, 12))
+
+  },
+  mutations: { inc: (state123) => state123.bar2++ },
+>mutations : Symbol(mutations, Decl(thislessFunctionsNotContextSensitive1.ts, 71, 4))
+>inc : Symbol(inc, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 14))
+>state123 : Symbol(state123, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 21))
+>state123.bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 70, 12))
+>state123 : Symbol(state123, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 21))
+>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 70, 12))
+
+  modules: {
+>modules : Symbol(modules, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 52))
+
+    foo: {
+>foo : Symbol(foo, Decl(thislessFunctionsNotContextSensitive1.ts, 73, 12))
+
+      state() {
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 74, 10))
+
+        return { bar2: 1 };
+>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 76, 16))
+
+      },
+      mutations: { inc: (state) => state.bar2++ },
+>mutations : Symbol(mutations, Decl(thislessFunctionsNotContextSensitive1.ts, 77, 8))
+>inc : Symbol(inc, Decl(thislessFunctionsNotContextSensitive1.ts, 78, 18))
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 78, 25))
+>state.bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 76, 16))
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 78, 25))
+>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 76, 16))
+
+    },
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/57572
+
+type C = <Methods, Attached = (methods: Methods) => void>(options: {
+>C : Symbol(C, Decl(thislessFunctionsNotContextSensitive1.ts, 81, 3))
+>Methods : Symbol(Methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 10))
+>Attached : Symbol(Attached, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 18))
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 31))
+>Methods : Symbol(Methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 10))
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 58))
+
+  methods: Methods;
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 68))
+>Methods : Symbol(Methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 10))
+
+  attached: Attached;
+>attached : Symbol(attached, Decl(thislessFunctionsNotContextSensitive1.ts, 86, 19))
+>Attached : Symbol(Attached, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 18))
+
+}) => any;
+
+var Component: C = () => {};
+>Component : Symbol(Component, Decl(thislessFunctionsNotContextSensitive1.ts, 90, 3))
+>C : Symbol(C, Decl(thislessFunctionsNotContextSensitive1.ts, 81, 3))
+
+Component({
+>Component : Symbol(Component, Decl(thislessFunctionsNotContextSensitive1.ts, 90, 3))
+
+  attached(methods) {
+>attached : Symbol(attached, Decl(thislessFunctionsNotContextSensitive1.ts, 92, 11))
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 93, 11))
+
+    methods.bbb(); // ok
+>methods.bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 96, 12))
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 93, 11))
+>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 96, 12))
+
+  },
+  methods: {
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 95, 4))
+
+    bbb() {},
+>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 96, 12))
+
+  },
+});
+
+Component({
+>Component : Symbol(Component, Decl(thislessFunctionsNotContextSensitive1.ts, 90, 3))
+
+  attached(methods) {
+>attached : Symbol(attached, Decl(thislessFunctionsNotContextSensitive1.ts, 101, 11))
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 102, 11))
+
+    methods.bbb(); // ok
+>methods.bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 105, 12))
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 102, 11))
+>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 105, 12))
+
+  },
+  methods: {
+>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 104, 4))
+
+    bbb: () => {},
+>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 105, 12))
+
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/56067
+
+declare function create56067<
+>create56067 : Symbol(create56067, Decl(thislessFunctionsNotContextSensitive1.ts, 108, 3))
+
+  State extends Record<string, any>,
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 112, 29))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+  Data extends Record<string, any>,
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive1.ts, 113, 36))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+  Actions extends (state: State, data: Data) => Record<string, any>,
+>Actions : Symbol(Actions, Decl(thislessFunctionsNotContextSensitive1.ts, 114, 35))
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 115, 19))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 112, 29))
+>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive1.ts, 115, 32))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive1.ts, 113, 36))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+>(args: { getState: () => State; actions: Actions; getData: () => Data }): void;
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 2))
+>getState : Symbol(getState, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 9))
+>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 112, 29))
+>actions : Symbol(actions, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 32))
+>Actions : Symbol(Actions, Decl(thislessFunctionsNotContextSensitive1.ts, 114, 35))
+>getData : Symbol(getData, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 50))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive1.ts, 113, 36))
+
+create56067({
+>create56067 : Symbol(create56067, Decl(thislessFunctionsNotContextSensitive1.ts, 108, 3))
+
+  getState() {
+>getState : Symbol(getState, Decl(thislessFunctionsNotContextSensitive1.ts, 118, 13))
+
+    return { a: 1 };
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 120, 12))
+
+  },
+  getData: () => {
+>getData : Symbol(getData, Decl(thislessFunctionsNotContextSensitive1.ts, 121, 4))
+
+    return { b: 2 };
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 123, 12))
+
+  },
+  actions(state, data) {
+>actions : Symbol(actions, Decl(thislessFunctionsNotContextSensitive1.ts, 124, 4))
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 10))
+>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 16))
+
+    state // { a: number }
+>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 10))
+
+    data; // { b: number }
+>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 16))
+
+    return {
+      z: 1,
+>z : Symbol(z, Decl(thislessFunctionsNotContextSensitive1.ts, 128, 12))
+
+    };
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/55489
+type NonStringIterable<T> = 
+>NonStringIterable : Symbol(NonStringIterable, Decl(thislessFunctionsNotContextSensitive1.ts, 132, 3))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23))
+
+  T extends string ? never : T extends Iterable<any> ? T : never;
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23))
+>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23))
+
+declare function doSomething<T>(value: NonStringIterable<T>): T;
+>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 29))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 32))
+>NonStringIterable : Symbol(NonStringIterable, Decl(thislessFunctionsNotContextSensitive1.ts, 132, 3))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 29))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 29))
+
+const o = { foo() {} };
+>o : Symbol(o, Decl(thislessFunctionsNotContextSensitive1.ts, 140, 5))
+>foo : Symbol(foo, Decl(thislessFunctionsNotContextSensitive1.ts, 140, 11))
+
+doSomething('value'); // error
+>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65))
+
+doSomething(['v']); // ok
+>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65))
+
+doSomething([o]); // ok
+>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65))
+>o : Symbol(o, Decl(thislessFunctionsNotContextSensitive1.ts, 140, 5))
+
+doSomething([{ foo() {} }]); // ok
+>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65))
+>foo : Symbol(foo, Decl(thislessFunctionsNotContextSensitive1.ts, 145, 14))
+
+// https://github.com/microsoft/TypeScript/issues/55124
+type Values<T> = T[keyof T];
+>Values : Symbol(Values, Decl(thislessFunctionsNotContextSensitive1.ts, 145, 28))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 12))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 12))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 12))
+
+type ExtractFields<Options> = Values<{
+>ExtractFields : Symbol(ExtractFields, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 28))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19))
+>Values : Symbol(Values, Decl(thislessFunctionsNotContextSensitive1.ts, 145, 28))
+
+  [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never;
+>K : Symbol(K, Decl(thislessFunctionsNotContextSensitive1.ts, 150, 3))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19))
+>K : Symbol(K, Decl(thislessFunctionsNotContextSensitive1.ts, 150, 3))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19))
+>K : Symbol(K, Decl(thislessFunctionsNotContextSensitive1.ts, 150, 3))
+
+}>;
+type SetType<Options> = {
+>SetType : Symbol(SetType, Decl(thislessFunctionsNotContextSensitive1.ts, 151, 3))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 152, 13))
+
+  [key: string]: any;
+>key : Symbol(key, Decl(thislessFunctionsNotContextSensitive1.ts, 153, 3))
+
+  target?: ExtractFields<Options>;
+>target : Symbol(target, Decl(thislessFunctionsNotContextSensitive1.ts, 153, 21))
+>ExtractFields : Symbol(ExtractFields, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 28))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 152, 13))
+
+};
+
+declare function test55124<OptionsData extends SetType<OptionsData>>(
+>test55124 : Symbol(test55124, Decl(thislessFunctionsNotContextSensitive1.ts, 155, 2))
+>OptionsData : Symbol(OptionsData, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 27))
+>SetType : Symbol(SetType, Decl(thislessFunctionsNotContextSensitive1.ts, 151, 3))
+>OptionsData : Symbol(OptionsData, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 27))
+
+  options: OptionsData,
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 69))
+>OptionsData : Symbol(OptionsData, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 27))
+
+): void;
+
+test55124({
+>test55124 : Symbol(test55124, Decl(thislessFunctionsNotContextSensitive1.ts, 155, 2))
+
+  target: "$test4", // ok
+>target : Symbol(target, Decl(thislessFunctionsNotContextSensitive1.ts, 161, 11))
+
+  data1: {
+>data1 : Symbol(data1, Decl(thislessFunctionsNotContextSensitive1.ts, 162, 19))
+
+    $test1: 111,
+>$test1 : Symbol($test1, Decl(thislessFunctionsNotContextSensitive1.ts, 163, 10))
+
+    $test2: null,
+>$test2 : Symbol($test2, Decl(thislessFunctionsNotContextSensitive1.ts, 164, 16))
+
+  },
+  data2: {
+>data2 : Symbol(data2, Decl(thislessFunctionsNotContextSensitive1.ts, 166, 4))
+
+    $test3: {},
+>$test3 : Symbol($test3, Decl(thislessFunctionsNotContextSensitive1.ts, 167, 10))
+
+    $test4: () => {},
+>$test4 : Symbol($test4, Decl(thislessFunctionsNotContextSensitive1.ts, 168, 15))
+
+    $test5() {},
+>$test5 : Symbol($test5, Decl(thislessFunctionsNotContextSensitive1.ts, 169, 21))
+
+  },
+});
+
+test55124({
+>test55124 : Symbol(test55124, Decl(thislessFunctionsNotContextSensitive1.ts, 155, 2))
+
+  target: "$test6", // error
+>target : Symbol(target, Decl(thislessFunctionsNotContextSensitive1.ts, 174, 11))
+
+  data1: {
+>data1 : Symbol(data1, Decl(thislessFunctionsNotContextSensitive1.ts, 175, 19))
+
+    $test1: 111,
+>$test1 : Symbol($test1, Decl(thislessFunctionsNotContextSensitive1.ts, 176, 10))
+
+    $test2: null,
+>$test2 : Symbol($test2, Decl(thislessFunctionsNotContextSensitive1.ts, 177, 16))
+
+  },
+  data2: {
+>data2 : Symbol(data2, Decl(thislessFunctionsNotContextSensitive1.ts, 179, 4))
+
+    $test3: {},
+>$test3 : Symbol($test3, Decl(thislessFunctionsNotContextSensitive1.ts, 180, 10))
+
+    $test4: () => {},
+>$test4 : Symbol($test4, Decl(thislessFunctionsNotContextSensitive1.ts, 181, 15))
+
+    $test5() {},
+>$test5 : Symbol($test5, Decl(thislessFunctionsNotContextSensitive1.ts, 182, 21))
+
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/53924
+function test53924<T = unknown>(options: { a: (c: T) => void; b: () => T }) {}
+>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 19))
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 32))
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 42))
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 47))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 19))
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 61))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 19))
+
+test53924({
+>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3))
+
+  a: (c) => {
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 190, 11))
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 191, 6))
+
+    c; // number;
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 191, 6))
+
+  },
+  b: () => 123,
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 193, 4))
+
+});
+
+test53924({
+>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3))
+
+  b: () => 123,
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 197, 11))
+
+  a: (c) => {
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 198, 15))
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 199, 6))
+
+    return c; // number
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 199, 6))
+
+  },
+});
+
+test53924({
+>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3))
+
+  b() {
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 204, 11))
+
+    return 123;
+  },
+  a(c) {
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 207, 4))
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 208, 4))
+
+    return c; // number
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 208, 4))
+
+  },
+});
+
+test53924({
+>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3))
+
+  a(c) {
+>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 213, 11))
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 214, 4))
+
+    return c; // number
+>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 214, 4))
+
+  },
+  b() {
+>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 216, 4))
+
+    return 123;
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/50258
+declare function monitor<T extends (...args: any) => any>(
+>monitor : Symbol(monitor, Decl(thislessFunctionsNotContextSensitive1.ts, 220, 3))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25))
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 36))
+
+  extractor: (...args: Parameters<T>) => Record<string, unknown>,
+>extractor : Symbol(extractor, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 58))
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 224, 14))
+>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+  executor: T,
+>executor : Symbol(executor, Decl(thislessFunctionsNotContextSensitive1.ts, 224, 65))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25))
+
+): (...args: Parameters<T>) => ReturnType<T>;
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 226, 4))
+>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25))
+>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25))
+
+monitor(
+>monitor : Symbol(monitor, Decl(thislessFunctionsNotContextSensitive1.ts, 220, 3))
+
+  (p) => ({ p }), // { p: number }
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 229, 3))
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 229, 11))
+
+  (p: number) => p,
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 230, 3))
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 230, 3))
+
+);
+monitor(
+>monitor : Symbol(monitor, Decl(thislessFunctionsNotContextSensitive1.ts, 220, 3))
+
+  (p) => ({ p }), // { p: number }
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 233, 3))
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 233, 11))
+
+  function (p: number) {
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 234, 12))
+
+    return p;
+>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 234, 12))
+
+  },
+);
+
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive1.types b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.types
new file mode 100644
index 0000000000000..54eac35ad5070
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.types
@@ -0,0 +1,926 @@
+//// [tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts] ////
+
+=== thislessFunctionsNotContextSensitive1.ts ===
+// https://github.com/microsoft/TypeScript/issues/62204
+
+declare function TestConfig<const TConfig extends { a?: any; b?: any; c?: any }>(
+>TestConfig : <const TConfig extends { a?: any; b?: any; c?: any; }>(config: TConfig, test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false) => void
+>           : ^^^^^^^       ^^^^^^^^^                              ^^      ^^       ^^    ^^                                                           ^^^^^    
+>a : any
+>  : ^^^
+>b : any
+>  : ^^^
+>c : any
+>  : ^^^
+
+  config: TConfig,
+>config : TConfig
+>       : ^^^^^^^
+
+  test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false,
+>test : Exclude<keyof TConfig, "a" | "b"> extends never ? true : false
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>true : true
+>     : ^^^^
+>false : false
+>      : ^^^^^
+
+): void;
+
+TestConfig(
+>TestConfig(  {    a: "hello",    b: function () {      return 123;    },  },  true,) : void
+>                                                                                     : ^^^^
+>TestConfig : <const TConfig extends { a?: any; b?: any; c?: any; }>(config: TConfig, test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false) => void
+>           : ^^^^^^^       ^^^^^^^^^                              ^^      ^^       ^^    ^^                                                           ^^^^^    
+  {
+>{    a: "hello",    b: function () {      return 123;    },  } : { a: "hello"; b: () => 123; }
+>                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    a: "hello",
+>a : "hello"
+>  : ^^^^^^^
+>"hello" : "hello"
+>        : ^^^^^^^
+
+    b: function () {
+>b : () => 123
+>  : ^^^^^^^^^
+>function () {      return 123;    } : () => 123
+>                                    : ^^^^^^^^^
+
+      return 123;
+>123 : 123
+>    : ^^^
+
+    },
+  },
+  true,
+>true : true
+>     : ^^^^
+
+);
+
+TestConfig(
+>TestConfig(  {    a: "hello",    b: function () {      return 123;    },  },  false, // error) : void
+>                                                                                               : ^^^^
+>TestConfig : <const TConfig extends { a?: any; b?: any; c?: any; }>(config: TConfig, test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false) => void
+>           : ^^^^^^^       ^^^^^^^^^                              ^^      ^^       ^^    ^^                                                           ^^^^^    
+  {
+>{    a: "hello",    b: function () {      return 123;    },  } : { a: "hello"; b: () => 123; }
+>                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    a: "hello",
+>a : "hello"
+>  : ^^^^^^^
+>"hello" : "hello"
+>        : ^^^^^^^
+
+    b: function () {
+>b : () => 123
+>  : ^^^^^^^^^
+>function () {      return 123;    } : () => 123
+>                                    : ^^^^^^^^^
+
+      return 123;
+>123 : 123
+>    : ^^^
+
+    },
+  },
+  false, // error
+>false : false
+>      : ^^^^^
+
+);
+
+// https://github.com/microsoft/TypeScript/issues/60986
+interface SubscribeFieldOptions<Event> {
+  subscribe: () => Event;
+>subscribe : () => Event
+>          : ^^^^^^     
+
+  resolve: (event: Event) => number;
+>resolve : (event: Event) => number
+>        : ^     ^^     ^^^^^      
+>event : Event
+>      : ^^^^^
+}
+
+declare function defineOptions<Event>(
+>defineOptions : <Event>(options: SubscribeFieldOptions<Event>) => void
+>              : ^     ^^       ^^                            ^^^^^    
+
+  options: SubscribeFieldOptions<Event>,
+>options : SubscribeFieldOptions<Event>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+): void;
+
+defineOptions({
+>defineOptions({  resolve: (event) => event, // number  subscribe() {    return 123;  },}) : void
+>                                                                                          : ^^^^
+>defineOptions : <Event>(options: SubscribeFieldOptions<Event>) => void
+>              : ^     ^^       ^^                            ^^^^^    
+>{  resolve: (event) => event, // number  subscribe() {    return 123;  },} : { resolve: (event: number) => number; subscribe(): number; }
+>                                                                           : ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  resolve: (event) => event, // number
+>resolve : (event: number) => number
+>        : ^     ^^^^^^^^^^^^^^^^^^^
+>(event) => event : (event: number) => number
+>                 : ^     ^^^^^^^^^^^^^^^^^^^
+>event : number
+>      : ^^^^^^
+>event : number
+>      : ^^^^^^
+
+  subscribe() {
+>subscribe : () => number
+>          : ^^^^^^^^^^^^
+
+    return 123;
+>123 : 123
+>    : ^^^
+
+  },
+});
+
+defineOptions({
+>defineOptions({  resolve: (event) => event, // number  subscribe: function () {    return 123;  },}) : void
+>                                                                                                     : ^^^^
+>defineOptions : <Event>(options: SubscribeFieldOptions<Event>) => void
+>              : ^     ^^       ^^                            ^^^^^    
+>{  resolve: (event) => event, // number  subscribe: function () {    return 123;  },} : { resolve: (event: number) => number; subscribe: () => number; }
+>                                                                                      : ^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  resolve: (event) => event, // number
+>resolve : (event: number) => number
+>        : ^     ^^^^^^^^^^^^^^^^^^^
+>(event) => event : (event: number) => number
+>                 : ^     ^^^^^^^^^^^^^^^^^^^
+>event : number
+>      : ^^^^^^
+>event : number
+>      : ^^^^^^
+
+  subscribe: function () {
+>subscribe : () => number
+>          : ^^^^^^^^^^^^
+>function () {    return 123;  } : () => number
+>                                : ^^^^^^^^^^^^
+
+    return 123;
+>123 : 123
+>    : ^^^
+
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/58630
+
+export type StateFunction<State> = (s: State, ...args: any[]) => any;
+>StateFunction : StateFunction<State>
+>              : ^^^^^^^^^^^^^^^^^^^^
+>s : State
+>  : ^^^^^
+>args : any[]
+>     : ^^^^^
+
+export type VuexStoreOptions<State, Modules> = {
+>VuexStoreOptions : VuexStoreOptions<State, Modules>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  state?: State | (() => State) | { (): State };
+>state : State | (() => State) | (() => State) | undefined
+>      : ^^^^^^^^^^^^^^^     ^^^^^^^^^^^     ^^^^^^^^^^^^^
+
+  mutations?: Record<string, StateFunction<State>>;
+>mutations : Record<string, StateFunction<State>> | undefined
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  modules?: {
+>modules : { [k in keyof Modules]: VuexStoreOptions<Modules[k], never>; } | undefined
+>        : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    [k in keyof Modules]: VuexStoreOptions<Modules[k], never>;
+  };
+};
+
+export function createStore<
+>createStore : <State extends Record<string, unknown>, Modules extends Record<string, Record<string, unknown>>>(options: VuexStoreOptions<State, Modules>) => void
+>            : ^     ^^^^^^^^^                       ^^       ^^^^^^^^^                                       ^^       ^^                                ^^^^^^^^^
+
+  State extends Record<string, unknown>,
+  Modules extends Record<string, Record<string, unknown>>,
+>(options: VuexStoreOptions<State, Modules>) {}
+>options : VuexStoreOptions<State, Modules>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+const store = createStore({
+>store : void
+>      : ^^^^
+>createStore({  state() {    return { bar2: 1 };  },  mutations: { inc: (state123) => state123.bar2++ },  modules: {    foo: {      state() {        return { bar2: 1 };      },      mutations: { inc: (state) => state.bar2++ },    },  },}) : void
+>                                                                                                                                                                                                                                              : ^^^^
+>createStore : <State extends Record<string, unknown>, Modules extends Record<string, Record<string, unknown>>>(options: VuexStoreOptions<State, Modules>) => void
+>            : ^     ^^^^^^^^^                       ^^       ^^^^^^^^^                                       ^^       ^^                                ^^^^^^^^^
+>{  state() {    return { bar2: 1 };  },  mutations: { inc: (state123) => state123.bar2++ },  modules: {    foo: {      state() {        return { bar2: 1 };      },      mutations: { inc: (state) => state.bar2++ },    },  },} : { state(): { bar2: number; }; mutations: { inc: (state123: { bar2: number; }) => number; }; modules: { foo: { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }; }; }
+>                                                                                                                                                                                                                                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  state() {
+>state : () => { bar2: number; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^
+
+    return { bar2: 1 };
+>{ bar2: 1 } : { bar2: number; }
+>            : ^^^^^^^^^^^^^^^^^
+>bar2 : number
+>     : ^^^^^^
+>1 : 1
+>  : ^
+
+  },
+  mutations: { inc: (state123) => state123.bar2++ },
+>mutations : { inc: (state123: { bar2: number; }) => number; }
+>          : ^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ inc: (state123) => state123.bar2++ } : { inc: (state123: { bar2: number; }) => number; }
+>                                       : ^^^^^^^^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>inc : (state123: { bar2: number; }) => number
+>    : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>(state123) => state123.bar2++ : (state123: { bar2: number; }) => number
+>                              : ^        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>state123 : { bar2: number; }
+>         : ^^^^^^^^^^^^^^^^^
+>state123.bar2++ : number
+>                : ^^^^^^
+>state123.bar2 : number
+>              : ^^^^^^
+>state123 : { bar2: number; }
+>         : ^^^^^^^^^^^^^^^^^
+>bar2 : number
+>     : ^^^^^^
+
+  modules: {
+>modules : { foo: { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    foo: {      state() {        return { bar2: 1 };      },      mutations: { inc: (state) => state.bar2++ },    },  } : { foo: { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }; }
+>                                                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    foo: {
+>foo : { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{      state() {        return { bar2: 1 };      },      mutations: { inc: (state) => state.bar2++ },    } : { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }
+>                                                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+      state() {
+>state : () => { bar2: number; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^
+
+        return { bar2: 1 };
+>{ bar2: 1 } : { bar2: number; }
+>            : ^^^^^^^^^^^^^^^^^
+>bar2 : number
+>     : ^^^^^^
+>1 : 1
+>  : ^
+
+      },
+      mutations: { inc: (state) => state.bar2++ },
+>mutations : { inc: (state: { bar2: number; }) => number; }
+>          : ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ inc: (state) => state.bar2++ } : { inc: (state: { bar2: number; }) => number; }
+>                                 : ^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>inc : (state: { bar2: number; }) => number
+>    : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>(state) => state.bar2++ : (state: { bar2: number; }) => number
+>                        : ^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>state : { bar2: number; }
+>      : ^^^^^^^^^^^^^^^^^
+>state.bar2++ : number
+>             : ^^^^^^
+>state.bar2 : number
+>           : ^^^^^^
+>state : { bar2: number; }
+>      : ^^^^^^^^^^^^^^^^^
+>bar2 : number
+>     : ^^^^^^
+
+    },
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/57572
+
+type C = <Methods, Attached = (methods: Methods) => void>(options: {
+>C : C
+>  : ^
+>methods : Methods
+>        : ^^^^^^^
+>options : { methods: Methods; attached: Attached; }
+>        : ^^^^^^^^^^^       ^^^^^^^^^^^^        ^^^
+
+  methods: Methods;
+>methods : Methods
+>        : ^^^^^^^
+
+  attached: Attached;
+>attached : Attached
+>         : ^^^^^^^^
+
+}) => any;
+
+var Component: C = () => {};
+>Component : C
+>          : ^
+>() => {} : () => void
+>         : ^^^^^^^^^^
+
+Component({
+>Component({  attached(methods) {    methods.bbb(); // ok  },  methods: {    bbb() {},  },}) : any
+>                                                                                            : ^^^
+>Component : C
+>          : ^
+>{  attached(methods) {    methods.bbb(); // ok  },  methods: {    bbb() {},  },} : { attached(methods: { bbb(): void; }): void; methods: { bbb(): void; }; }
+>                                                                                 : ^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  attached(methods) {
+>attached : (methods: { bbb(): void; }) => void
+>         : ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>methods : { bbb(): void; }
+>        : ^^^^^^^^^^^^^^^^
+
+    methods.bbb(); // ok
+>methods.bbb() : void
+>              : ^^^^
+>methods.bbb : () => void
+>            : ^^^^^^^^^^
+>methods : { bbb(): void; }
+>        : ^^^^^^^^^^^^^^^^
+>bbb : () => void
+>    : ^^^^^^^^^^
+
+  },
+  methods: {
+>methods : { bbb(): void; }
+>        : ^^^^^^^^^^^^^^^^
+>{    bbb() {},  } : { bbb(): void; }
+>                  : ^^^^^^^^^^^^^^^^
+
+    bbb() {},
+>bbb : () => void
+>    : ^^^^^^^^^^
+
+  },
+});
+
+Component({
+>Component({  attached(methods) {    methods.bbb(); // ok  },  methods: {    bbb: () => {},  },}) : any
+>                                                                                                 : ^^^
+>Component : C
+>          : ^
+>{  attached(methods) {    methods.bbb(); // ok  },  methods: {    bbb: () => {},  },} : { attached(methods: { bbb: () => void; }): void; methods: { bbb: () => void; }; }
+>                                                                                      : ^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  attached(methods) {
+>attached : (methods: { bbb: () => void; }) => void
+>         : ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>methods : { bbb: () => void; }
+>        : ^^^^^^^^^^^^^^^^^^^^
+
+    methods.bbb(); // ok
+>methods.bbb() : void
+>              : ^^^^
+>methods.bbb : () => void
+>            : ^^^^^^^^^^
+>methods : { bbb: () => void; }
+>        : ^^^^^^^^^^^^^^^^^^^^
+>bbb : () => void
+>    : ^^^^^^^^^^
+
+  },
+  methods: {
+>methods : { bbb: () => void; }
+>        : ^^^^^^^^^^^^^^^^^^^^
+>{    bbb: () => {},  } : { bbb: () => void; }
+>                       : ^^^^^^^^^^^^^^^^^^^^
+
+    bbb: () => {},
+>bbb : () => void
+>    : ^^^^^^^^^^
+>() => {} : () => void
+>         : ^^^^^^^^^^
+
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/56067
+
+declare function create56067<
+>create56067 : <State extends Record<string, any>, Data extends Record<string, any>, Actions extends (state: State, data: Data) => Record<string, any>>(args: { getState: () => State; actions: Actions; getData: () => Data; }) => void
+>            : ^     ^^^^^^^^^                   ^^    ^^^^^^^^^                   ^^       ^^^^^^^^^                                                 ^^    ^^                                                                 ^^^^^    
+
+  State extends Record<string, any>,
+  Data extends Record<string, any>,
+  Actions extends (state: State, data: Data) => Record<string, any>,
+>state : State
+>      : ^^^^^
+>data : Data
+>     : ^^^^
+
+>(args: { getState: () => State; actions: Actions; getData: () => Data }): void;
+>args : { getState: () => State; actions: Actions; getData: () => Data; }
+>     : ^^^^^^^^^^^^           ^^^^^^^^^^^       ^^^^^^^^^^^          ^^^
+>getState : () => State
+>         : ^^^^^^     
+>actions : Actions
+>        : ^^^^^^^
+>getData : () => Data
+>        : ^^^^^^    
+
+create56067({
+>create56067({  getState() {    return { a: 1 };  },  getData: () => {    return { b: 2 };  },  actions(state, data) {    state // { a: number }    data; // { b: number }    return {      z: 1,    };  },}) : void
+>                                                                                                                                                                                                             : ^^^^
+>create56067 : <State extends Record<string, any>, Data extends Record<string, any>, Actions extends (state: State, data: Data) => Record<string, any>>(args: { getState: () => State; actions: Actions; getData: () => Data; }) => void
+>            : ^     ^^^^^^^^^                   ^^    ^^^^^^^^^                   ^^       ^^^^^^^^^                                                 ^^    ^^                                                                 ^^^^^    
+>{  getState() {    return { a: 1 };  },  getData: () => {    return { b: 2 };  },  actions(state, data) {    state // { a: number }    data; // { b: number }    return {      z: 1,    };  },} : { getState(): { a: number; }; getData: () => { b: number; }; actions(state: { a: number; }, data: { b: number; }): { z: number; }; }
+>                                                                                                                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  getState() {
+>getState : () => { a: number; }
+>         : ^^^^^^^^^^^^^^^^^^^^
+
+    return { a: 1 };
+>{ a: 1 } : { a: number; }
+>         : ^^^^^^^^^^^^^^
+>a : number
+>  : ^^^^^^
+>1 : 1
+>  : ^
+
+  },
+  getData: () => {
+>getData : () => { b: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^
+>() => {    return { b: 2 };  } : () => { b: number; }
+>                               : ^^^^^^^^^^^^^^^^^^^^
+
+    return { b: 2 };
+>{ b: 2 } : { b: number; }
+>         : ^^^^^^^^^^^^^^
+>b : number
+>  : ^^^^^^
+>2 : 2
+>  : ^
+
+  },
+  actions(state, data) {
+>actions : (state: { a: number; }, data: { b: number; }) => { z: number; }
+>        : ^     ^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>state : { a: number; }
+>      : ^^^^^^^^^^^^^^
+>data : { b: number; }
+>     : ^^^^^^^^^^^^^^
+
+    state // { a: number }
+>state : { a: number; }
+>      : ^^^^^^^^^^^^^^
+
+    data; // { b: number }
+>data : { b: number; }
+>     : ^^^^^^^^^^^^^^
+
+    return {
+>{      z: 1,    } : { z: number; }
+>                  : ^^^^^^^^^^^^^^
+
+      z: 1,
+>z : number
+>  : ^^^^^^
+>1 : 1
+>  : ^
+
+    };
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/55489
+type NonStringIterable<T> = 
+>NonStringIterable : NonStringIterable<T>
+>                  : ^^^^^^^^^^^^^^^^^^^^
+
+  T extends string ? never : T extends Iterable<any> ? T : never;
+
+declare function doSomething<T>(value: NonStringIterable<T>): T;
+>doSomething : <T>(value: NonStringIterable<T>) => T
+>            : ^ ^^     ^^                    ^^^^^ 
+>value : NonStringIterable<T>
+>      : ^^^^^^^^^^^^^^^^^^^^
+
+const o = { foo() {} };
+>o : { foo(): void; }
+>  : ^^^^^^^^^^^^^^^^
+>{ foo() {} } : { foo(): void; }
+>             : ^^^^^^^^^^^^^^^^
+>foo : () => void
+>    : ^^^^^^^^^^
+
+doSomething('value'); // error
+>doSomething('value') : "value"
+>                     : ^^^^^^^
+>doSomething : <T>(value: NonStringIterable<T>) => T
+>            : ^ ^^     ^^                    ^^^^^ 
+>'value' : "value"
+>        : ^^^^^^^
+
+doSomething(['v']); // ok
+>doSomething(['v']) : string[]
+>                   : ^^^^^^^^
+>doSomething : <T>(value: NonStringIterable<T>) => T
+>            : ^ ^^     ^^                    ^^^^^ 
+>['v'] : string[]
+>      : ^^^^^^^^
+>'v' : "v"
+>    : ^^^
+
+doSomething([o]); // ok
+>doSomething([o]) : { foo(): void; }[]
+>                 : ^^^^^^^^^^^^^^^^^^
+>doSomething : <T>(value: NonStringIterable<T>) => T
+>            : ^ ^^     ^^                    ^^^^^ 
+>[o] : { foo(): void; }[]
+>    : ^^^^^^^^^^^^^^^^^^
+>o : { foo(): void; }
+>  : ^^^^^^^^^^^^^^^^
+
+doSomething([{ foo() {} }]); // ok
+>doSomething([{ foo() {} }]) : { foo(): void; }[]
+>                            : ^^^^^^^^^^^^^^^^^^
+>doSomething : <T>(value: NonStringIterable<T>) => T
+>            : ^ ^^     ^^                    ^^^^^ 
+>[{ foo() {} }] : { foo(): void; }[]
+>               : ^^^^^^^^^^^^^^^^^^
+>{ foo() {} } : { foo(): void; }
+>             : ^^^^^^^^^^^^^^^^
+>foo : () => void
+>    : ^^^^^^^^^^
+
+// https://github.com/microsoft/TypeScript/issues/55124
+type Values<T> = T[keyof T];
+>Values : Values<T>
+>       : ^^^^^^^^^
+
+type ExtractFields<Options> = Values<{
+>ExtractFields : ExtractFields<Options>
+>              : ^^^^^^^^^^^^^^^^^^^^^^
+
+  [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never;
+}>;
+type SetType<Options> = {
+>SetType : SetType<Options>
+>        : ^^^^^^^^^^^^^^^^
+
+  [key: string]: any;
+>key : string
+>    : ^^^^^^
+
+  target?: ExtractFields<Options>;
+>target : ExtractFields<Options> | undefined
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+};
+
+declare function test55124<OptionsData extends SetType<OptionsData>>(
+>test55124 : <OptionsData extends SetType<OptionsData>>(options: OptionsData) => void
+>          : ^           ^^^^^^^^^                    ^^       ^^           ^^^^^    
+
+  options: OptionsData,
+>options : OptionsData
+>        : ^^^^^^^^^^^
+
+): void;
+
+test55124({
+>test55124({  target: "$test4", // ok  data1: {    $test1: 111,    $test2: null,  },  data2: {    $test3: {},    $test4: () => {},    $test5() {},  },}) : void
+>                                                                                                                                                        : ^^^^
+>test55124 : <OptionsData extends SetType<OptionsData>>(options: OptionsData) => void
+>          : ^           ^^^^^^^^^                    ^^       ^^           ^^^^^    
+>{  target: "$test4", // ok  data1: {    $test1: 111,    $test2: null,  },  data2: {    $test3: {},    $test4: () => {},    $test5() {},  },} : { target: "$test4"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }
+>                                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  target: "$test4", // ok
+>target : "$test4"
+>       : ^^^^^^^^
+>"$test4" : "$test4"
+>         : ^^^^^^^^
+
+  data1: {
+>data1 : { $test1: number; $test2: null; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    $test1: 111,    $test2: null,  } : { $test1: number; $test2: null; }
+>                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    $test1: 111,
+>$test1 : number
+>       : ^^^^^^
+>111 : 111
+>    : ^^^
+
+    $test2: null,
+>$test2 : null
+>       : ^^^^
+
+  },
+  data2: {
+>data2 : { $test3: {}; $test4: () => void; $test5(): void; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    $test3: {},    $test4: () => {},    $test5() {},  } : { $test3: {}; $test4: () => void; $test5(): void; }
+>                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    $test3: {},
+>$test3 : {}
+>       : ^^
+>{} : {}
+>   : ^^
+
+    $test4: () => {},
+>$test4 : () => void
+>       : ^^^^^^^^^^
+>() => {} : () => void
+>         : ^^^^^^^^^^
+
+    $test5() {},
+>$test5 : () => void
+>       : ^^^^^^^^^^
+
+  },
+});
+
+test55124({
+>test55124({  target: "$test6", // error  data1: {    $test1: 111,    $test2: null,  },  data2: {    $test3: {},    $test4: () => {},    $test5() {},  },}) : void
+>                                                                                                                                                           : ^^^^
+>test55124 : <OptionsData extends SetType<OptionsData>>(options: OptionsData) => void
+>          : ^           ^^^^^^^^^                    ^^       ^^           ^^^^^    
+>{  target: "$test6", // error  data1: {    $test1: 111,    $test2: null,  },  data2: {    $test3: {},    $test4: () => {},    $test5() {},  },} : { target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }
+>                                                                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  target: "$test6", // error
+>target : "$test6"
+>       : ^^^^^^^^
+>"$test6" : "$test6"
+>         : ^^^^^^^^
+
+  data1: {
+>data1 : { $test1: number; $test2: null; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    $test1: 111,    $test2: null,  } : { $test1: number; $test2: null; }
+>                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    $test1: 111,
+>$test1 : number
+>       : ^^^^^^
+>111 : 111
+>    : ^^^
+
+    $test2: null,
+>$test2 : null
+>       : ^^^^
+
+  },
+  data2: {
+>data2 : { $test3: {}; $test4: () => void; $test5(): void; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    $test3: {},    $test4: () => {},    $test5() {},  } : { $test3: {}; $test4: () => void; $test5(): void; }
+>                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    $test3: {},
+>$test3 : {}
+>       : ^^
+>{} : {}
+>   : ^^
+
+    $test4: () => {},
+>$test4 : () => void
+>       : ^^^^^^^^^^
+>() => {} : () => void
+>         : ^^^^^^^^^^
+
+    $test5() {},
+>$test5 : () => void
+>       : ^^^^^^^^^^
+
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/53924
+function test53924<T = unknown>(options: { a: (c: T) => void; b: () => T }) {}
+>test53924 : <T = unknown>(options: { a: (c: T) => void; b: () => T; }) => void
+>          : ^ ^^^^^^^^^^^^       ^^                                  ^^^^^^^^^
+>options : { a: (c: T) => void; b: () => T; }
+>        : ^^^^^              ^^^^^       ^^^
+>a : (c: T) => void
+>  : ^ ^^ ^^^^^    
+>c : T
+>  : ^
+>b : () => T
+>  : ^^^^^^ 
+
+test53924({
+>test53924({  a: (c) => {    c; // number;  },  b: () => 123,}) : void
+>                                                               : ^^^^
+>test53924 : <T = unknown>(options: { a: (c: T) => void; b: () => T; }) => void
+>          : ^ ^^^^^^^^^^^^       ^^                                  ^^^^^^^^^
+>{  a: (c) => {    c; // number;  },  b: () => 123,} : { a: (c: number) => void; b: () => number; }
+>                                                    : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  a: (c) => {
+>a : (c: number) => void
+>  : ^ ^^^^^^^^^^^^^^^^^
+>(c) => {    c; // number;  } : (c: number) => void
+>                             : ^ ^^^^^^^^^^^^^^^^^
+>c : number
+>  : ^^^^^^
+
+    c; // number;
+>c : number
+>  : ^^^^^^
+
+  },
+  b: () => 123,
+>b : () => number
+>  : ^^^^^^^^^^^^
+>() => 123 : () => number
+>          : ^^^^^^^^^^^^
+>123 : 123
+>    : ^^^
+
+});
+
+test53924({
+>test53924({  b: () => 123,  a: (c) => {    return c; // number  },}) : void
+>                                                                     : ^^^^
+>test53924 : <T = unknown>(options: { a: (c: T) => void; b: () => T; }) => void
+>          : ^ ^^^^^^^^^^^^       ^^                                  ^^^^^^^^^
+>{  b: () => 123,  a: (c) => {    return c; // number  },} : { b: () => number; a: (c: number) => number; }
+>                                                          : ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
+
+  b: () => 123,
+>b : () => number
+>  : ^^^^^^^^^^^^
+>() => 123 : () => number
+>          : ^^^^^^^^^^^^
+>123 : 123
+>    : ^^^
+
+  a: (c) => {
+>a : (c: number) => number
+>  : ^ ^^^^^^^^^^^^^^^^^^^
+>(c) => {    return c; // number  } : (c: number) => number
+>                                   : ^ ^^^^^^^^^^^^^^^^^^^
+>c : number
+>  : ^^^^^^
+
+    return c; // number
+>c : number
+>  : ^^^^^^
+
+  },
+});
+
+test53924({
+>test53924({  b() {    return 123;  },  a(c) {    return c; // number  },}) : void
+>                                                                           : ^^^^
+>test53924 : <T = unknown>(options: { a: (c: T) => void; b: () => T; }) => void
+>          : ^ ^^^^^^^^^^^^       ^^                                  ^^^^^^^^^
+>{  b() {    return 123;  },  a(c) {    return c; // number  },} : { b(): number; a(c: number): number; }
+>                                                                : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
+
+  b() {
+>b : () => number
+>  : ^^^^^^^^^^^^
+
+    return 123;
+>123 : 123
+>    : ^^^
+
+  },
+  a(c) {
+>a : (c: number) => number
+>  : ^ ^^^^^^^^^^^^^^^^^^^
+>c : number
+>  : ^^^^^^
+
+    return c; // number
+>c : number
+>  : ^^^^^^
+
+  },
+});
+
+test53924({
+>test53924({  a(c) {    return c; // number  },  b() {    return 123;  },}) : void
+>                                                                           : ^^^^
+>test53924 : <T = unknown>(options: { a: (c: T) => void; b: () => T; }) => void
+>          : ^ ^^^^^^^^^^^^       ^^                                  ^^^^^^^^^
+>{  a(c) {    return c; // number  },  b() {    return 123;  },} : { a(c: number): number; b(): number; }
+>                                                                : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  a(c) {
+>a : (c: number) => number
+>  : ^ ^^^^^^^^^^^^^^^^^^^
+>c : number
+>  : ^^^^^^
+
+    return c; // number
+>c : number
+>  : ^^^^^^
+
+  },
+  b() {
+>b : () => number
+>  : ^^^^^^^^^^^^
+
+    return 123;
+>123 : 123
+>    : ^^^
+
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/50258
+declare function monitor<T extends (...args: any) => any>(
+>monitor : <T extends (...args: any) => any>(extractor: (...args: Parameters<T>) => Record<string, unknown>, executor: T) => (...args: Parameters<T>) => ReturnType<T>
+>        : ^ ^^^^^^^^^                     ^^         ^^                                                   ^^        ^^ ^^^^^                                         
+>args : any
+>     : ^^^
+
+  extractor: (...args: Parameters<T>) => Record<string, unknown>,
+>extractor : (...args: Parameters<T>) => Record<string, unknown>
+>          : ^^^^    ^^             ^^^^^                       
+>args : Parameters<T>
+>     : ^^^^^^^^^^^^^
+
+  executor: T,
+>executor : T
+>         : ^
+
+): (...args: Parameters<T>) => ReturnType<T>;
+>args : Parameters<T>
+>     : ^^^^^^^^^^^^^
+
+monitor(
+>monitor(  (p) => ({ p }), // { p: number }  (p: number) => p,) : (p: number) => number
+>                                                               : ^^^^^^^^^^^^^^^^^^^^^
+>monitor : <T extends (...args: any) => any>(extractor: (...args: Parameters<T>) => Record<string, unknown>, executor: T) => (...args: Parameters<T>) => ReturnType<T>
+>        : ^ ^^^^^^^^^                     ^^         ^^                                                   ^^        ^^ ^^^^^                                         
+
+  (p) => ({ p }), // { p: number }
+>(p) => ({ p }) : (p: number) => { p: number; }
+>               : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>p : number
+>  : ^^^^^^
+>({ p }) : { p: number; }
+>        : ^^^^^^^^^^^^^^
+>{ p } : { p: number; }
+>      : ^^^^^^^^^^^^^^
+>p : number
+>  : ^^^^^^
+
+  (p: number) => p,
+>(p: number) => p : (p: number) => number
+>                 : ^ ^^      ^^^^^^^^^^^
+>p : number
+>  : ^^^^^^
+>p : number
+>  : ^^^^^^
+
+);
+monitor(
+>monitor(  (p) => ({ p }), // { p: number }  function (p: number) {    return p;  },) : (p: number) => number
+>                                                                                     : ^^^^^^^^^^^^^^^^^^^^^
+>monitor : <T extends (...args: any) => any>(extractor: (...args: Parameters<T>) => Record<string, unknown>, executor: T) => (...args: Parameters<T>) => ReturnType<T>
+>        : ^ ^^^^^^^^^                     ^^         ^^                                                   ^^        ^^ ^^^^^                                         
+
+  (p) => ({ p }), // { p: number }
+>(p) => ({ p }) : (p: number) => { p: number; }
+>               : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>p : number
+>  : ^^^^^^
+>({ p }) : { p: number; }
+>        : ^^^^^^^^^^^^^^
+>{ p } : { p: number; }
+>      : ^^^^^^^^^^^^^^
+>p : number
+>  : ^^^^^^
+
+  function (p: number) {
+>function (p: number) {    return p;  } : (p: number) => number
+>                                       : ^ ^^      ^^^^^^^^^^^
+>p : number
+>  : ^^^^^^
+
+    return p;
+>p : number
+>  : ^^^^^^
+
+  },
+);
+
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive2.errors.txt b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.errors.txt
new file mode 100644
index 0000000000000..299f833b65a1b
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.errors.txt
@@ -0,0 +1,132 @@
+thislessFunctionsNotContextSensitive2.ts(52,14): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation.
+thislessFunctionsNotContextSensitive2.ts(83,12): error TS7041: The containing arrow function captures the global value of 'this'.
+
+
+==== thislessFunctionsNotContextSensitive2.ts (2 errors) ====
+    interface Options<Context, Data> {
+      context: Context;
+      produce(this: Context): Data;
+      consume(this: Context, data: Data): void;
+    }
+    
+    declare function defineOptions<Context, Data>(
+      options: Options<Context, Data>,
+    ): [Context, Data];
+    
+    const result1 = defineOptions({
+      context: { tag: "A", value: 1 },
+      consume(_data) {},
+      produce() {
+        return 42;
+      },
+    });
+    
+    const result2 = defineOptions({
+      context: { tag: "B", value: 2 },
+      consume(_data) {},
+      produce() {
+        return this.value;
+      },
+    });
+    
+    const result3 = defineOptions({
+      context: { tag: "C", value: 3 },
+      consume(_data) {},
+      produce: () => 123,
+    });
+    
+    const result4 = defineOptions({
+      context: { tag: "D", value: 4 },
+      consume(_data) {},
+      produce() {
+        class Local {
+          value = 'foo';
+          get() {
+            return this.value;
+          }
+        }
+        return new Local().get();;
+      },
+    });
+    
+    const result5 = defineOptions({
+      context: { tag: "E", value: 5 },
+      consume(_data) {},
+      produce() {
+        function inner() {
+          return this;
+                 ~~~~
+!!! error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation.
+!!! related TS2738 thislessFunctionsNotContextSensitive2.ts:51:14: An outer value of 'this' is shadowed by this container.
+        }
+        return inner();
+      },
+    });
+    
+    const result6 = defineOptions({
+      context: { tag: "F", value: 6 },
+      consume(_data) {},
+      produce() {
+        const arrow = () => this.value;
+        return arrow();
+      },
+    });
+    
+    const result7 = defineOptions({
+      context: { tag: "G", value: 7 },
+      consume(_data) {},
+      produce() {
+        const self = this;
+        function inner() {
+          return self.value;
+        }
+        return inner();
+      },
+    });
+    
+    const result8 = defineOptions({
+      context: { tag: "H", value: 8 },
+      consume(_data) {},
+      produce: () => {
+        return this;
+               ~~~~
+!!! error TS7041: The containing arrow function captures the global value of 'this'.
+      },
+    });
+    
+    const result9 = defineOptions({
+      context: { tag: "I", value: 9 },
+      consume(_data) {},
+      produce() {
+        const obj = {
+          value: 'foo',
+          get() {
+            return this.value;
+          },
+        };
+        return obj.get();
+      },
+    });
+    
+    const result10 = defineOptions({
+      context: { tag: "I", value: 9 },
+      consume(_data) {},
+      produce() {
+        interface Foo {
+            prop: this;
+        }
+        return {} as Foo;
+      },
+    });
+    
+    const result11 = defineOptions({
+      context: { tag: "I", value: 9 },
+      consume(_data) {},
+      produce() {
+        function fn(this: { prop: string }) {
+          return this.prop;
+        }
+        return fn;
+      },
+    });
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive2.symbols b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.symbols
new file mode 100644
index 0000000000000..29d0c190d417f
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.symbols
@@ -0,0 +1,353 @@
+//// [tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts] ////
+
+=== thislessFunctionsNotContextSensitive2.ts ===
+interface Options<Context, Data> {
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 0))
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 26))
+
+  context: Context;
+>context : Symbol(Options.context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 34))
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18))
+
+  produce(this: Context): Data;
+>produce : Symbol(Options.produce, Decl(thislessFunctionsNotContextSensitive2.ts, 1, 19))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10))
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 26))
+
+  consume(this: Context, data: Data): void;
+>consume : Symbol(Options.consume, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 31))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 3, 10))
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18))
+>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive2.ts, 3, 24))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 26))
+}
+
+declare function defineOptions<Context, Data>(
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 31))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 39))
+
+  options: Options<Context, Data>,
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 46))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 0))
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 31))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 39))
+
+): [Context, Data];
+>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 31))
+>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 39))
+
+const result1 = defineOptions({
+>result1 : Symbol(result1, Decl(thislessFunctionsNotContextSensitive2.ts, 10, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "A", value: 1 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 10, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 11, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 11, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 11, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 12, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 12, 20))
+
+    return 42;
+  },
+});
+
+const result2 = defineOptions({
+>result2 : Symbol(result2, Decl(thislessFunctionsNotContextSensitive2.ts, 18, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "B", value: 2 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 18, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 20, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 20, 20))
+
+    return this.value;
+>this.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 22))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 22))
+
+  },
+});
+
+const result3 = defineOptions({
+>result3 : Symbol(result3, Decl(thislessFunctionsNotContextSensitive2.ts, 26, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "C", value: 3 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 26, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 27, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 27, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 27, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 28, 10))
+
+  produce: () => 123,
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 28, 20))
+
+});
+
+const result4 = defineOptions({
+>result4 : Symbol(result4, Decl(thislessFunctionsNotContextSensitive2.ts, 32, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "D", value: 4 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 32, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 33, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 33, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 33, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 34, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 34, 20))
+
+    class Local {
+>Local : Symbol(Local, Decl(thislessFunctionsNotContextSensitive2.ts, 35, 13))
+
+      value = 'foo';
+>value : Symbol(Local.value, Decl(thislessFunctionsNotContextSensitive2.ts, 36, 17))
+
+      get() {
+>get : Symbol(Local.get, Decl(thislessFunctionsNotContextSensitive2.ts, 37, 20))
+
+        return this.value;
+>this.value : Symbol(Local.value, Decl(thislessFunctionsNotContextSensitive2.ts, 36, 17))
+>this : Symbol(Local, Decl(thislessFunctionsNotContextSensitive2.ts, 35, 13))
+>value : Symbol(Local.value, Decl(thislessFunctionsNotContextSensitive2.ts, 36, 17))
+      }
+    }
+    return new Local().get();;
+>new Local().get : Symbol(Local.get, Decl(thislessFunctionsNotContextSensitive2.ts, 37, 20))
+>Local : Symbol(Local, Decl(thislessFunctionsNotContextSensitive2.ts, 35, 13))
+>get : Symbol(Local.get, Decl(thislessFunctionsNotContextSensitive2.ts, 37, 20))
+
+  },
+});
+
+const result5 = defineOptions({
+>result5 : Symbol(result5, Decl(thislessFunctionsNotContextSensitive2.ts, 46, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "E", value: 5 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 46, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 47, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 47, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 47, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 48, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 48, 20))
+
+    function inner() {
+>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 49, 13))
+
+      return this;
+    }
+    return inner();
+>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 49, 13))
+
+  },
+});
+
+const result6 = defineOptions({
+>result6 : Symbol(result6, Decl(thislessFunctionsNotContextSensitive2.ts, 57, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "F", value: 6 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 57, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 59, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 59, 20))
+
+    const arrow = () => this.value;
+>arrow : Symbol(arrow, Decl(thislessFunctionsNotContextSensitive2.ts, 61, 9))
+>this.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 22))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 22))
+
+    return arrow();
+>arrow : Symbol(arrow, Decl(thislessFunctionsNotContextSensitive2.ts, 61, 9))
+
+  },
+});
+
+const result7 = defineOptions({
+>result7 : Symbol(result7, Decl(thislessFunctionsNotContextSensitive2.ts, 66, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "G", value: 7 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 66, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 68, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 68, 20))
+
+    const self = this;
+>self : Symbol(self, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 9))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10))
+
+    function inner() {
+>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 22))
+
+      return self.value;
+>self.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 22))
+>self : Symbol(self, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 9))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 22))
+    }
+    return inner();
+>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 22))
+
+  },
+});
+
+const result8 = defineOptions({
+>result8 : Symbol(result8, Decl(thislessFunctionsNotContextSensitive2.ts, 78, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "H", value: 8 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 78, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 79, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 79, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 79, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 80, 10))
+
+  produce: () => {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 80, 20))
+
+    return this;
+>this : Symbol(globalThis)
+
+  },
+});
+
+const result9 = defineOptions({
+>result9 : Symbol(result9, Decl(thislessFunctionsNotContextSensitive2.ts, 86, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "I", value: 9 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 86, 31))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 87, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 87, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 87, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 88, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 88, 20))
+
+    const obj = {
+>obj : Symbol(obj, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 9))
+
+      value: 'foo',
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 17))
+
+      get() {
+>get : Symbol(get, Decl(thislessFunctionsNotContextSensitive2.ts, 91, 19))
+
+        return this.value;
+>this.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 17))
+>this : Symbol(obj, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 15))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 17))
+
+      },
+    };
+    return obj.get();
+>obj.get : Symbol(get, Decl(thislessFunctionsNotContextSensitive2.ts, 91, 19))
+>obj : Symbol(obj, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 9))
+>get : Symbol(get, Decl(thislessFunctionsNotContextSensitive2.ts, 91, 19))
+
+  },
+});
+
+const result10 = defineOptions({
+>result10 : Symbol(result10, Decl(thislessFunctionsNotContextSensitive2.ts, 100, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "I", value: 9 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 100, 32))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 101, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 101, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 101, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 102, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 102, 20))
+
+    interface Foo {
+>Foo : Symbol(Foo, Decl(thislessFunctionsNotContextSensitive2.ts, 103, 13))
+
+        prop: this;
+>prop : Symbol(Foo.prop, Decl(thislessFunctionsNotContextSensitive2.ts, 104, 19))
+    }
+    return {} as Foo;
+>Foo : Symbol(Foo, Decl(thislessFunctionsNotContextSensitive2.ts, 103, 13))
+
+  },
+});
+
+const result11 = defineOptions({
+>result11 : Symbol(result11, Decl(thislessFunctionsNotContextSensitive2.ts, 111, 5))
+>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1))
+
+  context: { tag: "I", value: 9 },
+>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 111, 32))
+>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 112, 12))
+>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 112, 22))
+
+  consume(_data) {},
+>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 112, 34))
+>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 113, 10))
+
+  produce() {
+>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 113, 20))
+
+    function fn(this: { prop: string }) {
+>fn : Symbol(fn, Decl(thislessFunctionsNotContextSensitive2.ts, 114, 13))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 16))
+>prop : Symbol(prop, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 23))
+
+      return this.prop;
+>this.prop : Symbol(prop, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 23))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 16))
+>prop : Symbol(prop, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 23))
+    }
+    return fn;
+>fn : Symbol(fn, Decl(thislessFunctionsNotContextSensitive2.ts, 114, 13))
+
+  },
+});
+
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive2.types b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.types
new file mode 100644
index 0000000000000..9d035d78b6451
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.types
@@ -0,0 +1,619 @@
+//// [tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts] ////
+
+=== thislessFunctionsNotContextSensitive2.ts ===
+interface Options<Context, Data> {
+  context: Context;
+>context : Context
+>        : ^^^^^^^
+
+  produce(this: Context): Data;
+>produce : (this: Context) => Data
+>        : ^    ^^       ^^^^^    
+>this : Context
+>     : ^^^^^^^
+
+  consume(this: Context, data: Data): void;
+>consume : (this: Context, data: Data) => void
+>        : ^    ^^       ^^    ^^    ^^^^^    
+>this : Context
+>     : ^^^^^^^
+>data : Data
+>     : ^^^^
+}
+
+declare function defineOptions<Context, Data>(
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+
+  options: Options<Context, Data>,
+>options : Options<Context, Data>
+>        : ^^^^^^^^^^^^^^^^^^^^^^
+
+): [Context, Data];
+
+const result1 = defineOptions({
+>result1 : [{ tag: string; value: number; }, number]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "A", value: 1 },  consume(_data) {},  produce() {    return 42;  },}) : [{ tag: string; value: number; }, number]
+>                                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "A", value: 1 },  consume(_data) {},  produce() {    return 42;  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: number): void; produce(): number; }
+>                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "A", value: 1 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "A", value: 1 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"A" : "A"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>1 : 1
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: number) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^
+>_data : number
+>      : ^^^^^^
+
+  produce() {
+>produce : () => number
+>        : ^^^^^^^^^^^^
+
+    return 42;
+>42 : 42
+>   : ^^
+
+  },
+});
+
+const result2 = defineOptions({
+>result2 : [{ tag: string; value: number; }, unknown]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "B", value: 2 },  consume(_data) {},  produce() {    return this.value;  },}) : [{ tag: string; value: number; }, unknown]
+>                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "B", value: 2 },  consume(_data) {},  produce() {    return this.value;  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: unknown): void; produce(this: { tag: string; value: number; }): number; }
+>                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "B", value: 2 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "B", value: 2 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"B" : "B"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>2 : 2
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: unknown) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
+>_data : unknown
+>      : ^^^^^^^
+
+  produce() {
+>produce : (this: { tag: string; value: number; }) => number
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    return this.value;
+>this.value : number
+>           : ^^^^^^
+>this : { tag: string; value: number; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>value : number
+>      : ^^^^^^
+
+  },
+});
+
+const result3 = defineOptions({
+>result3 : [{ tag: string; value: number; }, number]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "C", value: 3 },  consume(_data) {},  produce: () => 123,}) : [{ tag: string; value: number; }, number]
+>                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "C", value: 3 },  consume(_data) {},  produce: () => 123,} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: number): void; produce: () => number; }
+>                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "C", value: 3 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "C", value: 3 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"C" : "C"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>3 : 3
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: number) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^
+>_data : number
+>      : ^^^^^^
+
+  produce: () => 123,
+>produce : () => number
+>        : ^^^^^^^^^^^^
+>() => 123 : () => number
+>          : ^^^^^^^^^^^^
+>123 : 123
+>    : ^^^
+
+});
+
+const result4 = defineOptions({
+>result4 : [{ tag: string; value: number; }, string]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "D", value: 4 },  consume(_data) {},  produce() {    class Local {      value = 'foo';      get() {        return this.value;      }    }    return new Local().get();;  },}) : [{ tag: string; value: number; }, string]
+>                                                                                                                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "D", value: 4 },  consume(_data) {},  produce() {    class Local {      value = 'foo';      get() {        return this.value;      }    }    return new Local().get();;  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: string): void; produce(): string; }
+>                                                                                                                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "D", value: 4 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "D", value: 4 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"D" : "D"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>4 : 4
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: string) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^
+>_data : string
+>      : ^^^^^^
+
+  produce() {
+>produce : () => string
+>        : ^^^^^^^^^^^^
+
+    class Local {
+>Local : Local
+>      : ^^^^^
+
+      value = 'foo';
+>value : string
+>      : ^^^^^^
+>'foo' : "foo"
+>      : ^^^^^
+
+      get() {
+>get : () => string
+>    : ^^^^^^^^^^^^
+
+        return this.value;
+>this.value : string
+>           : ^^^^^^
+>this : this
+>     : ^^^^
+>value : string
+>      : ^^^^^^
+      }
+    }
+    return new Local().get();;
+>new Local().get() : string
+>                  : ^^^^^^
+>new Local().get : () => string
+>                : ^^^^^^^^^^^^
+>new Local() : Local
+>            : ^^^^^
+>Local : typeof Local
+>      : ^^^^^^^^^^^^
+>get : () => string
+>    : ^^^^^^^^^^^^
+
+  },
+});
+
+const result5 = defineOptions({
+>result5 : [{ tag: string; value: number; }, any]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "E", value: 5 },  consume(_data) {},  produce() {    function inner() {      return this;    }    return inner();  },}) : [{ tag: string; value: number; }, any]
+>                                                                                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "E", value: 5 },  consume(_data) {},  produce() {    function inner() {      return this;    }    return inner();  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: any): void; produce(): any; }
+>                                                                                                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "E", value: 5 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "E", value: 5 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"E" : "E"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>5 : 5
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: any) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^
+>_data : any
+>      : ^^^
+
+  produce() {
+>produce : () => any
+>        : ^^^^^^^^^
+
+    function inner() {
+>inner : () => any
+>      : ^^^^^^^^^
+
+      return this;
+>this : any
+>     : ^^^
+    }
+    return inner();
+>inner() : any
+>        : ^^^
+>inner : () => any
+>      : ^^^^^^^^^
+
+  },
+});
+
+const result6 = defineOptions({
+>result6 : [{ tag: string; value: number; }, unknown]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "F", value: 6 },  consume(_data) {},  produce() {    const arrow = () => this.value;    return arrow();  },}) : [{ tag: string; value: number; }, unknown]
+>                                                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "F", value: 6 },  consume(_data) {},  produce() {    const arrow = () => this.value;    return arrow();  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: unknown): void; produce(this: { tag: string; value: number; }): number; }
+>                                                                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "F", value: 6 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "F", value: 6 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"F" : "F"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>6 : 6
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: unknown) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
+>_data : unknown
+>      : ^^^^^^^
+
+  produce() {
+>produce : (this: { tag: string; value: number; }) => number
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    const arrow = () => this.value;
+>arrow : () => number
+>      : ^^^^^^^^^^^^
+>() => this.value : () => number
+>                 : ^^^^^^^^^^^^
+>this.value : number
+>           : ^^^^^^
+>this : { tag: string; value: number; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>value : number
+>      : ^^^^^^
+
+    return arrow();
+>arrow() : number
+>        : ^^^^^^
+>arrow : () => number
+>      : ^^^^^^^^^^^^
+
+  },
+});
+
+const result7 = defineOptions({
+>result7 : [{ tag: string; value: number; }, unknown]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "G", value: 7 },  consume(_data) {},  produce() {    const self = this;    function inner() {      return self.value;    }    return inner();  },}) : [{ tag: string; value: number; }, unknown]
+>                                                                                                                                                                                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "G", value: 7 },  consume(_data) {},  produce() {    const self = this;    function inner() {      return self.value;    }    return inner();  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: unknown): void; produce(this: { tag: string; value: number; }): number; }
+>                                                                                                                                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "G", value: 7 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "G", value: 7 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"G" : "G"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>7 : 7
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: unknown) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^
+>_data : unknown
+>      : ^^^^^^^
+
+  produce() {
+>produce : (this: { tag: string; value: number; }) => number
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    const self = this;
+>self : { tag: string; value: number; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>this : { tag: string; value: number; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    function inner() {
+>inner : () => number
+>      : ^^^^^^^^^^^^
+
+      return self.value;
+>self.value : number
+>           : ^^^^^^
+>self : { tag: string; value: number; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>value : number
+>      : ^^^^^^
+    }
+    return inner();
+>inner() : number
+>        : ^^^^^^
+>inner : () => number
+>      : ^^^^^^^^^^^^
+
+  },
+});
+
+const result8 = defineOptions({
+>result8 : [{ tag: string; value: number; }, typeof globalThis]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "H", value: 8 },  consume(_data) {},  produce: () => {    return this;  },}) : [{ tag: string; value: number; }, typeof globalThis]
+>                                                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "H", value: 8 },  consume(_data) {},  produce: () => {    return this;  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: typeof globalThis): void; produce: () => typeof globalThis; }
+>                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "H", value: 8 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "H", value: 8 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"H" : "H"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>8 : 8
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: typeof globalThis) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>_data : typeof globalThis
+>      : ^^^^^^^^^^^^^^^^^
+
+  produce: () => {
+>produce : () => typeof globalThis
+>        : ^^^^^^^^^^^^^^^^^^^^^^^
+>() => {    return this;  } : () => typeof globalThis
+>                           : ^^^^^^^^^^^^^^^^^^^^^^^
+
+    return this;
+>this : typeof globalThis
+>     : ^^^^^^^^^^^^^^^^^
+
+  },
+});
+
+const result9 = defineOptions({
+>result9 : [{ tag: string; value: number; }, string]
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "I", value: 9 },  consume(_data) {},  produce() {    const obj = {      value: 'foo',      get() {        return this.value;      },    };    return obj.get();  },}) : [{ tag: string; value: number; }, string]
+>                                                                                                                                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "I", value: 9 },  consume(_data) {},  produce() {    const obj = {      value: 'foo',      get() {        return this.value;      },    };    return obj.get();  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: string): void; produce(): string; }
+>                                                                                                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "I", value: 9 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "I", value: 9 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"I" : "I"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>9 : 9
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: string) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^
+>_data : string
+>      : ^^^^^^
+
+  produce() {
+>produce : () => string
+>        : ^^^^^^^^^^^^
+
+    const obj = {
+>obj : { value: string; get(): string; }
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{      value: 'foo',      get() {        return this.value;      },    } : { value: string; get(): string; }
+>                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+      value: 'foo',
+>value : string
+>      : ^^^^^^
+>'foo' : "foo"
+>      : ^^^^^
+
+      get() {
+>get : () => string
+>    : ^^^^^^^^^^^^
+
+        return this.value;
+>this.value : string
+>           : ^^^^^^
+>this : { value: string; get(): string; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>value : string
+>      : ^^^^^^
+
+      },
+    };
+    return obj.get();
+>obj.get() : string
+>          : ^^^^^^
+>obj.get : () => string
+>        : ^^^^^^^^^^^^
+>obj : { value: string; get(): string; }
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>get : () => string
+>    : ^^^^^^^^^^^^
+
+  },
+});
+
+const result10 = defineOptions({
+>result10 : [{ tag: string; value: number; }, Foo]
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions({  context: { tag: "I", value: 9 },  consume(_data) {},  produce() {    interface Foo {        prop: this;    }    return {} as Foo;  },}) : [{ tag: string; value: number; }, Foo]
+>                                                                                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "I", value: 9 },  consume(_data) {},  produce() {    interface Foo {        prop: this;    }    return {} as Foo;  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: Foo): void; produce(): Foo; }
+>                                                                                                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  context: { tag: "I", value: 9 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "I", value: 9 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"I" : "I"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>9 : 9
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: Foo) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^
+>_data : Foo
+>      : ^^^
+
+  produce() {
+>produce : () => Foo
+>        : ^^^^^^^^^
+
+    interface Foo {
+        prop: this;
+>prop : this
+>     : ^^^^
+    }
+    return {} as Foo;
+>{} as Foo : Foo
+>          : ^^^
+>{} : {}
+>   : ^^
+
+  },
+});
+
+const result11 = defineOptions({
+>result11 : [{ tag: string; value: number; }, (this: { prop: string; }) => string]
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^^^^^^^^^^^
+>defineOptions({  context: { tag: "I", value: 9 },  consume(_data) {},  produce() {    function fn(this: { prop: string }) {      return this.prop;    }    return fn;  },}) : [{ tag: string; value: number; }, (this: { prop: string; }) => string]
+>                                                                                                                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^^^^^^^^^^^
+>defineOptions : <Context, Data>(options: Options<Context, Data>) => [Context, Data]
+>              : ^       ^^    ^^       ^^                      ^^^^^               
+>{  context: { tag: "I", value: 9 },  consume(_data) {},  produce() {    function fn(this: { prop: string }) {      return this.prop;    }    return fn;  },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: (this: { prop: string; }) => string): void; produce(): (this: { prop: string; }) => string; }
+>                                                                                                                                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^    ^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^                 ^^^^^^^^^^^^^^
+
+  context: { tag: "I", value: 9 },
+>context : { tag: string; value: number; }
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{ tag: "I", value: 9 } : { tag: string; value: number; }
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tag : string
+>    : ^^^^^^
+>"I" : "I"
+>    : ^^^
+>value : number
+>      : ^^^^^^
+>9 : 9
+>  : ^
+
+  consume(_data) {},
+>consume : (this: { tag: string; value: number; }, _data: (this: { prop: string; }) => string) => void
+>        : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^    ^^                 ^^^^^^^^^^^^^^^^^^^^
+>_data : (this: { prop: string; }) => string
+>      : ^    ^^                 ^^^^^^^^^^^
+
+  produce() {
+>produce : () => (this: { prop: string; }) => string
+>        : ^^^^^^^    ^^                 ^^^^^^^^^^^
+
+    function fn(this: { prop: string }) {
+>fn : (this: { prop: string; }) => string
+>   : ^    ^^                 ^^^^^^^^^^^
+>this : { prop: string; }
+>     : ^^^^^^^^      ^^^
+>prop : string
+>     : ^^^^^^
+
+      return this.prop;
+>this.prop : string
+>          : ^^^^^^
+>this : { prop: string; }
+>     : ^^^^^^^^      ^^^
+>prop : string
+>     : ^^^^^^
+    }
+    return fn;
+>fn : (this: { prop: string; }) => string
+>   : ^    ^^                 ^^^^^^^^^^^
+
+  },
+});
+
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive3.errors.txt b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.errors.txt
new file mode 100644
index 0000000000000..7a4df0dd82493
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.errors.txt
@@ -0,0 +1,130 @@
+thislessFunctionsNotContextSensitive3.ts(62,9): error TS2783: 'editor' is specified more than once, so this usage will be overwritten.
+thislessFunctionsNotContextSensitive3.ts(81,9): error TS2783: 'editor' is specified more than once, so this usage will be overwritten.
+thislessFunctionsNotContextSensitive3.ts(96,3): error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'.
+thislessFunctionsNotContextSensitive3.ts(108,3): error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'.
+
+
+==== thislessFunctionsNotContextSensitive3.ts (4 errors) ====
+    declare class Editor {
+      private _editor;
+    }
+    
+    declare class Plugin {
+      private _plugin;
+    }
+    
+    type ParentConfig<T> = Partial<{
+      [P in keyof T]: Required<T>[P] extends (...args: any) => any
+        ? (...args: Parameters<Required<T>[P]>) => ReturnType<Required<T>[P]>
+        : T[P];
+    }>;
+    
+    interface ExtendableConfig<
+      Options = any,
+      Config extends
+        | ExtensionConfig<Options>
+        | ExtendableConfig<Options> = ExtendableConfig<Options, any>,
+    > {
+      name: string;
+      addOptions?: (this: {
+        name: string;
+        parent: ParentConfig<Config>["addOptions"];
+      }) => Options;
+      addProseMirrorPlugins?: (this: {
+        options: Options;
+        editor: Editor;
+      }) => Plugin[];
+    }
+    
+    interface ExtensionConfig<Options = any>
+      extends ExtendableConfig<Options, ExtensionConfig<Options>> {}
+    
+    declare class Extension<Options = any> {
+      _options: Options;
+    
+      static create<O = any>(config: Partial<ExtensionConfig<O>>): Extension<O>;
+    
+      configure(options?: Partial<Options>): Extension<Options>;
+    }
+    
+    interface SuggestionOptions {
+      editor: Editor;
+      char?: string;
+    }
+    
+    declare function Suggestion(options: SuggestionOptions): Plugin;
+    
+    Extension.create({
+      name: "slash-command",
+      addOptions() {
+        return {
+          suggestion: {
+            char: "/",
+          } as SuggestionOptions,
+        };
+      },
+      addProseMirrorPlugins() {
+        return [
+          Suggestion({
+            editor: this.editor, // error
+            ~~~~~~~~~~~~~~~~~~~
+!!! error TS2783: 'editor' is specified more than once, so this usage will be overwritten.
+!!! related TS2785 thislessFunctionsNotContextSensitive3.ts:63:9: This spread always overwrites this property.
+            ...this.options.suggestion,
+          }),
+        ];
+      },
+    });
+    
+    Extension.create({
+      name: "slash-command",
+      addOptions: () => {
+        return {
+          suggestion: {
+            char: "/",
+          } as SuggestionOptions,
+        };
+      },
+      addProseMirrorPlugins() {
+        return [
+          Suggestion({
+            editor: this.editor, // error
+            ~~~~~~~~~~~~~~~~~~~
+!!! error TS2783: 'editor' is specified more than once, so this usage will be overwritten.
+!!! related TS2785 thislessFunctionsNotContextSensitive3.ts:82:9: This spread always overwrites this property.
+            ...this.options.suggestion,
+          }),
+        ];
+      },
+    });
+    
+    const parentExtension = Extension.create({
+      name: "parentExtension",
+      addOptions() {
+        return { parent: "exists", overwrite: "parent" };
+      },
+    });
+    
+    const childExtension = parentExtension.configure({
+      child: "exists-too", // error
+      ~~~~~
+!!! error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'.
+      overwrite: "child",
+    });
+    
+    const parentExtension2 = Extension.create({
+      name: "parentExtension2",
+      addOptions: () => {
+        return { parent: "exists", overwrite: "parent" };
+      },
+    });
+    
+    const childExtension2 = parentExtension2.configure({
+      child: "exists-too", // error
+      ~~~~~
+!!! error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'.
+      overwrite: "child",
+    });
+    
+    export {};
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive3.symbols b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.symbols
new file mode 100644
index 0000000000000..8bb3cff42e1d1
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.symbols
@@ -0,0 +1,319 @@
+//// [tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts] ////
+
+=== thislessFunctionsNotContextSensitive3.ts ===
+declare class Editor {
+>Editor : Symbol(Editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 0))
+
+  private _editor;
+>_editor : Symbol(Editor._editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 22))
+}
+
+declare class Plugin {
+>Plugin : Symbol(Plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 2, 1))
+
+  private _plugin;
+>_plugin : Symbol(Plugin._plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 4, 22))
+}
+
+type ParentConfig<T> = Partial<{
+>ParentConfig : Symbol(ParentConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 6, 1))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18))
+>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
+
+  [P in keyof T]: Required<T>[P] extends (...args: any) => any
+>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18))
+>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18))
+>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3))
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 42))
+
+    ? (...args: Parameters<Required<T>[P]>) => ReturnType<Required<T>[P]>
+>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive3.ts, 10, 7))
+>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --))
+>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18))
+>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3))
+>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --))
+>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18))
+>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3))
+
+    : T[P];
+>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18))
+>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3))
+
+}>;
+
+interface ExtendableConfig<
+>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3))
+
+  Options = any,
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27))
+
+  Config extends
+>Config : Symbol(Config, Decl(thislessFunctionsNotContextSensitive3.ts, 15, 16))
+
+    | ExtensionConfig<Options>
+>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27))
+
+    | ExtendableConfig<Options> = ExtendableConfig<Options, any>,
+>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27))
+>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27))
+
+> {
+  name: string;
+>name : Symbol(ExtendableConfig.name, Decl(thislessFunctionsNotContextSensitive3.ts, 19, 3))
+
+  addOptions?: (this: {
+>addOptions : Symbol(ExtendableConfig.addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 20, 15))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 21, 16))
+
+    name: string;
+>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 21, 23))
+
+    parent: ParentConfig<Config>["addOptions"];
+>parent : Symbol(parent, Decl(thislessFunctionsNotContextSensitive3.ts, 22, 17))
+>ParentConfig : Symbol(ParentConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 6, 1))
+>Config : Symbol(Config, Decl(thislessFunctionsNotContextSensitive3.ts, 15, 16))
+
+  }) => Options;
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27))
+
+  addProseMirrorPlugins?: (this: {
+>addProseMirrorPlugins : Symbol(ExtendableConfig.addProseMirrorPlugins, Decl(thislessFunctionsNotContextSensitive3.ts, 24, 16))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27))
+
+    options: Options;
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27))
+
+    editor: Editor;
+>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21))
+>Editor : Symbol(Editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 0))
+
+  }) => Plugin[];
+>Plugin : Symbol(Plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 2, 1))
+}
+
+interface ExtensionConfig<Options = any>
+>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 31, 26))
+
+  extends ExtendableConfig<Options, ExtensionConfig<Options>> {}
+>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 31, 26))
+>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 31, 26))
+
+declare class Extension<Options = any> {
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24))
+
+  _options: Options;
+>_options : Symbol(Extension._options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 40))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24))
+
+  static create<O = any>(config: Partial<ExtensionConfig<O>>): Extension<O>;
+>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+>O : Symbol(O, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 16))
+>config : Symbol(config, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 25))
+>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
+>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1))
+>O : Symbol(O, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 16))
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>O : Symbol(O, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 16))
+
+  configure(options?: Partial<Options>): Extension<Options>;
+>configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76))
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 39, 12))
+>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24))
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24))
+}
+
+interface SuggestionOptions {
+>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1))
+
+  editor: Editor;
+>editor : Symbol(SuggestionOptions.editor, Decl(thislessFunctionsNotContextSensitive3.ts, 42, 29))
+>Editor : Symbol(Editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 0))
+
+  char?: string;
+>char : Symbol(SuggestionOptions.char, Decl(thislessFunctionsNotContextSensitive3.ts, 43, 17))
+}
+
+declare function Suggestion(options: SuggestionOptions): Plugin;
+>Suggestion : Symbol(Suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 45, 1))
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 47, 28))
+>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1))
+>Plugin : Symbol(Plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 2, 1))
+
+Extension.create({
+>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+
+  name: "slash-command",
+>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 49, 18))
+
+  addOptions() {
+>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 50, 24))
+
+    return {
+      suggestion: {
+>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 52, 12))
+
+        char: "/",
+>char : Symbol(char, Decl(thislessFunctionsNotContextSensitive3.ts, 53, 19))
+
+      } as SuggestionOptions,
+>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1))
+
+    };
+  },
+  addProseMirrorPlugins() {
+>addProseMirrorPlugins : Symbol(addProseMirrorPlugins, Decl(thislessFunctionsNotContextSensitive3.ts, 57, 4))
+
+    return [
+      Suggestion({
+>Suggestion : Symbol(Suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 45, 1))
+
+        editor: this.editor, // error
+>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 60, 18))
+>this.editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27))
+>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21))
+
+        ...this.options.suggestion,
+>this.options.suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 52, 12))
+>this.options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27))
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34))
+>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 52, 12))
+
+      }),
+    ];
+  },
+});
+
+Extension.create({
+>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+
+  name: "slash-command",
+>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 68, 18))
+
+  addOptions: () => {
+>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 69, 24))
+
+    return {
+      suggestion: {
+>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 71, 12))
+
+        char: "/",
+>char : Symbol(char, Decl(thislessFunctionsNotContextSensitive3.ts, 72, 19))
+
+      } as SuggestionOptions,
+>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1))
+
+    };
+  },
+  addProseMirrorPlugins() {
+>addProseMirrorPlugins : Symbol(addProseMirrorPlugins, Decl(thislessFunctionsNotContextSensitive3.ts, 76, 4))
+
+    return [
+      Suggestion({
+>Suggestion : Symbol(Suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 45, 1))
+
+        editor: this.editor, // error
+>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 79, 18))
+>this.editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27))
+>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21))
+
+        ...this.options.suggestion,
+>this.options.suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 71, 12))
+>this.options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34))
+>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27))
+>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34))
+>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 71, 12))
+
+      }),
+    ];
+  },
+});
+
+const parentExtension = Extension.create({
+>parentExtension : Symbol(parentExtension, Decl(thislessFunctionsNotContextSensitive3.ts, 87, 5))
+>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+
+  name: "parentExtension",
+>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 87, 42))
+
+  addOptions() {
+>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 88, 26))
+
+    return { parent: "exists", overwrite: "parent" };
+>parent : Symbol(parent, Decl(thislessFunctionsNotContextSensitive3.ts, 90, 12))
+>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 90, 30))
+
+  },
+});
+
+const childExtension = parentExtension.configure({
+>childExtension : Symbol(childExtension, Decl(thislessFunctionsNotContextSensitive3.ts, 94, 5))
+>parentExtension.configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76))
+>parentExtension : Symbol(parentExtension, Decl(thislessFunctionsNotContextSensitive3.ts, 87, 5))
+>configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76))
+
+  child: "exists-too", // error
+>child : Symbol(child, Decl(thislessFunctionsNotContextSensitive3.ts, 94, 50))
+
+  overwrite: "child",
+>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 95, 22))
+
+});
+
+const parentExtension2 = Extension.create({
+>parentExtension2 : Symbol(parentExtension2, Decl(thislessFunctionsNotContextSensitive3.ts, 99, 5))
+>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64))
+>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20))
+
+  name: "parentExtension2",
+>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 99, 43))
+
+  addOptions: () => {
+>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 100, 27))
+
+    return { parent: "exists", overwrite: "parent" };
+>parent : Symbol(parent, Decl(thislessFunctionsNotContextSensitive3.ts, 102, 12))
+>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 102, 30))
+
+  },
+});
+
+const childExtension2 = parentExtension2.configure({
+>childExtension2 : Symbol(childExtension2, Decl(thislessFunctionsNotContextSensitive3.ts, 106, 5))
+>parentExtension2.configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76))
+>parentExtension2 : Symbol(parentExtension2, Decl(thislessFunctionsNotContextSensitive3.ts, 99, 5))
+>configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76))
+
+  child: "exists-too", // error
+>child : Symbol(child, Decl(thislessFunctionsNotContextSensitive3.ts, 106, 52))
+
+  overwrite: "child",
+>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 107, 22))
+
+});
+
+export {};
+
diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive3.types b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.types
new file mode 100644
index 0000000000000..b443986aa7b10
--- /dev/null
+++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.types
@@ -0,0 +1,430 @@
+//// [tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts] ////
+
+=== thislessFunctionsNotContextSensitive3.ts ===
+declare class Editor {
+>Editor : Editor
+>       : ^^^^^^
+
+  private _editor;
+>_editor : any
+>        : ^^^
+}
+
+declare class Plugin {
+>Plugin : Plugin
+>       : ^^^^^^
+
+  private _plugin;
+>_plugin : any
+>        : ^^^
+}
+
+type ParentConfig<T> = Partial<{
+>ParentConfig : Partial<{ [P in keyof T]: Required<T>[P] extends (...args: any) => any ? (...args: Parameters<Required<T>[P]>) => ReturnType<Required<T>[P]> : T[P]; }>
+>             : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^   ^^^^^   ^^^^^^^    ^^                          ^^^^^                          ^^^^^^^^^^^
+
+  [P in keyof T]: Required<T>[P] extends (...args: any) => any
+>args : any
+>     : ^^^
+
+    ? (...args: Parameters<Required<T>[P]>) => ReturnType<Required<T>[P]>
+>args : Parameters<Required<T>[P]>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    : T[P];
+}>;
+
+interface ExtendableConfig<
+  Options = any,
+  Config extends
+    | ExtensionConfig<Options>
+    | ExtendableConfig<Options> = ExtendableConfig<Options, any>,
+> {
+  name: string;
+>name : string
+>     : ^^^^^^
+
+  addOptions?: (this: {
+>addOptions : ((this: { name: string; parent: ParentConfig<Config>["addOptions"]; }) => Options) | undefined
+>           : ^^    ^^                                                             ^^^^^       ^^^^^^^^^^^^^
+>this : { name: string; parent: ParentConfig<Config>["addOptions"]; }
+>     : ^^^^^^^^      ^^^^^^^^^^                                  ^^^
+
+    name: string;
+>name : string
+>     : ^^^^^^
+
+    parent: ParentConfig<Config>["addOptions"];
+>parent : Partial<{ [P in keyof Config]: Required<Config>[P] extends (...args: any) => any ? (...args: Parameters<Required<Config>[P]>) => ReturnType<Required<Config>[P]> : Config[P]; }>["addOptions"]
+>       : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^   ^^^^^   ^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  }) => Options;
+  addProseMirrorPlugins?: (this: {
+>addProseMirrorPlugins : ((this: { options: Options; editor: Editor; }) => Plugin[]) | undefined
+>                      : ^^    ^^                                     ^^^^^        ^^^^^^^^^^^^^
+>this : { options: Options; editor: Editor; }
+>     : ^^^^^^^^^^^       ^^^^^^^^^^      ^^^
+
+    options: Options;
+>options : Options
+>        : ^^^^^^^
+
+    editor: Editor;
+>editor : Editor
+>       : ^^^^^^
+
+  }) => Plugin[];
+}
+
+interface ExtensionConfig<Options = any>
+  extends ExtendableConfig<Options, ExtensionConfig<Options>> {}
+
+declare class Extension<Options = any> {
+>Extension : Extension<Options>
+>          : ^^^^^^^^^^^^^^^^^^
+
+  _options: Options;
+>_options : Options
+>         : ^^^^^^^
+
+  static create<O = any>(config: Partial<ExtensionConfig<O>>): Extension<O>;
+>create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>       : ^ ^^^^^^^^      ^^                           ^^^^^            
+>config : Partial<ExtensionConfig<O>>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  configure(options?: Partial<Options>): Extension<Options>;
+>configure : (options?: Partial<Options>) => Extension<Options>
+>          : ^       ^^^                ^^^^^                  
+>options : Partial<Options> | undefined
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+}
+
+interface SuggestionOptions {
+  editor: Editor;
+>editor : Editor
+>       : ^^^^^^
+
+  char?: string;
+>char : string | undefined
+>     : ^^^^^^^^^^^^^^^^^^
+}
+
+declare function Suggestion(options: SuggestionOptions): Plugin;
+>Suggestion : (options: SuggestionOptions) => Plugin
+>           : ^       ^^                 ^^^^^      
+>options : SuggestionOptions
+>        : ^^^^^^^^^^^^^^^^^
+
+Extension.create({
+>Extension.create({  name: "slash-command",  addOptions() {    return {      suggestion: {        char: "/",      } as SuggestionOptions,    };  },  addProseMirrorPlugins() {    return [      Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }),    ];  },}) : Extension<{ suggestion: SuggestionOptions; }>
+>                                                                                                                                                                                                                                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^
+>Extension.create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>                 : ^ ^^^^^^^^      ^^                           ^^^^^            
+>Extension : typeof Extension
+>          : ^^^^^^^^^^^^^^^^
+>create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>       : ^ ^^^^^^^^      ^^                           ^^^^^            
+>{  name: "slash-command",  addOptions() {    return {      suggestion: {        char: "/",      } as SuggestionOptions,    };  },  addProseMirrorPlugins() {    return [      Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }),    ];  },} : { name: string; addOptions(): { suggestion: SuggestionOptions; }; addProseMirrorPlugins(this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }): Plugin[]; }
+>                                                                                                                                                                                                                                                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^
+
+  name: "slash-command",
+>name : string
+>     : ^^^^^^
+>"slash-command" : "slash-command"
+>                : ^^^^^^^^^^^^^^^
+
+  addOptions() {
+>addOptions : () => { suggestion: SuggestionOptions; }
+>           : ^^^^^^^^^^^^^^^^^^^^                 ^^^
+
+    return {
+>{      suggestion: {        char: "/",      } as SuggestionOptions,    } : { suggestion: SuggestionOptions; }
+>                                                                         : ^^^^^^^^^^^^^^                 ^^^
+
+      suggestion: {
+>suggestion : SuggestionOptions
+>           : ^^^^^^^^^^^^^^^^^
+>{        char: "/",      } as SuggestionOptions : SuggestionOptions
+>                                                : ^^^^^^^^^^^^^^^^^
+>{        char: "/",      } : { char: string; }
+>                           : ^^^^^^^^^^^^^^^^^
+
+        char: "/",
+>char : string
+>     : ^^^^^^
+>"/" : "/"
+>    : ^^^
+
+      } as SuggestionOptions,
+    };
+  },
+  addProseMirrorPlugins() {
+>addProseMirrorPlugins : (this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }) => Plugin[]
+>                      : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^
+
+    return [
+>[      Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }),    ] : Plugin[]
+>                                                                                                          : ^^^^^^^^
+
+      Suggestion({
+>Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }) : Plugin
+>                                                                                             : ^^^^^^
+>Suggestion : (options: SuggestionOptions) => Plugin
+>           : ^       ^^                 ^^^^^      
+>{        editor: this.editor, // error        ...this.options.suggestion,      } : { editor: Editor; char?: string; }
+>                                                                                 : ^^^^^^^^^^      ^^^^^^^^^      ^^^
+
+        editor: this.editor, // error
+>editor : Editor
+>       : ^^^^^^
+>this.editor : Editor
+>            : ^^^^^^
+>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^
+>editor : Editor
+>       : ^^^^^^
+
+        ...this.options.suggestion,
+>this.options.suggestion : SuggestionOptions
+>                        : ^^^^^^^^^^^^^^^^^
+>this.options : { suggestion: SuggestionOptions; }
+>             : ^^^^^^^^^^^^^^                 ^^^
+>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^
+>options : { suggestion: SuggestionOptions; }
+>        : ^^^^^^^^^^^^^^                 ^^^
+>suggestion : SuggestionOptions
+>           : ^^^^^^^^^^^^^^^^^
+
+      }),
+    ];
+  },
+});
+
+Extension.create({
+>Extension.create({  name: "slash-command",  addOptions: () => {    return {      suggestion: {        char: "/",      } as SuggestionOptions,    };  },  addProseMirrorPlugins() {    return [      Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }),    ];  },}) : Extension<{ suggestion: SuggestionOptions; }>
+>                                                                                                                                                                                                                                                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^
+>Extension.create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>                 : ^ ^^^^^^^^      ^^                           ^^^^^            
+>Extension : typeof Extension
+>          : ^^^^^^^^^^^^^^^^
+>create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>       : ^ ^^^^^^^^      ^^                           ^^^^^            
+>{  name: "slash-command",  addOptions: () => {    return {      suggestion: {        char: "/",      } as SuggestionOptions,    };  },  addProseMirrorPlugins() {    return [      Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }),    ];  },} : { name: string; addOptions: () => { suggestion: SuggestionOptions; }; addProseMirrorPlugins(this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }): Plugin[]; }
+>                                                                                                                                                                                                                                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^
+
+  name: "slash-command",
+>name : string
+>     : ^^^^^^
+>"slash-command" : "slash-command"
+>                : ^^^^^^^^^^^^^^^
+
+  addOptions: () => {
+>addOptions : () => { suggestion: SuggestionOptions; }
+>           : ^^^^^^^^^^^^^^^^^^^^                 ^^^
+>() => {    return {      suggestion: {        char: "/",      } as SuggestionOptions,    };  } : () => { suggestion: SuggestionOptions; }
+>                                                                                               : ^^^^^^^^^^^^^^^^^^^^                 ^^^
+
+    return {
+>{      suggestion: {        char: "/",      } as SuggestionOptions,    } : { suggestion: SuggestionOptions; }
+>                                                                         : ^^^^^^^^^^^^^^                 ^^^
+
+      suggestion: {
+>suggestion : SuggestionOptions
+>           : ^^^^^^^^^^^^^^^^^
+>{        char: "/",      } as SuggestionOptions : SuggestionOptions
+>                                                : ^^^^^^^^^^^^^^^^^
+>{        char: "/",      } : { char: string; }
+>                           : ^^^^^^^^^^^^^^^^^
+
+        char: "/",
+>char : string
+>     : ^^^^^^
+>"/" : "/"
+>    : ^^^
+
+      } as SuggestionOptions,
+    };
+  },
+  addProseMirrorPlugins() {
+>addProseMirrorPlugins : (this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }) => Plugin[]
+>                      : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^
+
+    return [
+>[      Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }),    ] : Plugin[]
+>                                                                                                          : ^^^^^^^^
+
+      Suggestion({
+>Suggestion({        editor: this.editor, // error        ...this.options.suggestion,      }) : Plugin
+>                                                                                             : ^^^^^^
+>Suggestion : (options: SuggestionOptions) => Plugin
+>           : ^       ^^                 ^^^^^      
+>{        editor: this.editor, // error        ...this.options.suggestion,      } : { editor: Editor; char?: string; }
+>                                                                                 : ^^^^^^^^^^      ^^^^^^^^^      ^^^
+
+        editor: this.editor, // error
+>editor : Editor
+>       : ^^^^^^
+>this.editor : Editor
+>            : ^^^^^^
+>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^
+>editor : Editor
+>       : ^^^^^^
+
+        ...this.options.suggestion,
+>this.options.suggestion : SuggestionOptions
+>                        : ^^^^^^^^^^^^^^^^^
+>this.options : { suggestion: SuggestionOptions; }
+>             : ^^^^^^^^^^^^^^                 ^^^
+>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^      ^^^
+>options : { suggestion: SuggestionOptions; }
+>        : ^^^^^^^^^^^^^^                 ^^^
+>suggestion : SuggestionOptions
+>           : ^^^^^^^^^^^^^^^^^
+
+      }),
+    ];
+  },
+});
+
+const parentExtension = Extension.create({
+>parentExtension : Extension<{ parent: string; overwrite: string; }>
+>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Extension.create({  name: "parentExtension",  addOptions() {    return { parent: "exists", overwrite: "parent" };  },}) : Extension<{ parent: string; overwrite: string; }>
+>                                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Extension.create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>                 : ^ ^^^^^^^^      ^^                           ^^^^^            
+>Extension : typeof Extension
+>          : ^^^^^^^^^^^^^^^^
+>create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>       : ^ ^^^^^^^^      ^^                           ^^^^^            
+>{  name: "parentExtension",  addOptions() {    return { parent: "exists", overwrite: "parent" };  },} : { name: string; addOptions(): { parent: string; overwrite: string; }; }
+>                                                                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  name: "parentExtension",
+>name : string
+>     : ^^^^^^
+>"parentExtension" : "parentExtension"
+>                  : ^^^^^^^^^^^^^^^^^
+
+  addOptions() {
+>addOptions : () => { parent: string; overwrite: string; }
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    return { parent: "exists", overwrite: "parent" };
+>{ parent: "exists", overwrite: "parent" } : { parent: string; overwrite: string; }
+>                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parent : string
+>       : ^^^^^^
+>"exists" : "exists"
+>         : ^^^^^^^^
+>overwrite : string
+>          : ^^^^^^
+>"parent" : "parent"
+>         : ^^^^^^^^
+
+  },
+});
+
+const childExtension = parentExtension.configure({
+>childExtension : Extension<{ parent: string; overwrite: string; }>
+>               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parentExtension.configure({  child: "exists-too", // error  overwrite: "child",}) : Extension<{ parent: string; overwrite: string; }>
+>                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parentExtension.configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }>
+>                          : ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parentExtension : Extension<{ parent: string; overwrite: string; }>
+>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }>
+>          : ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{  child: "exists-too", // error  overwrite: "child",} : { child: string; overwrite: string; }
+>                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  child: "exists-too", // error
+>child : string
+>      : ^^^^^^
+>"exists-too" : "exists-too"
+>             : ^^^^^^^^^^^^
+
+  overwrite: "child",
+>overwrite : string
+>          : ^^^^^^
+>"child" : "child"
+>        : ^^^^^^^
+
+});
+
+const parentExtension2 = Extension.create({
+>parentExtension2 : Extension<{ parent: string; overwrite: string; }>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Extension.create({  name: "parentExtension2",  addOptions: () => {    return { parent: "exists", overwrite: "parent" };  },}) : Extension<{ parent: string; overwrite: string; }>
+>                                                                                                                              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Extension.create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>                 : ^ ^^^^^^^^      ^^                           ^^^^^            
+>Extension : typeof Extension
+>          : ^^^^^^^^^^^^^^^^
+>create : <O = any>(config: Partial<ExtensionConfig<O>>) => Extension<O>
+>       : ^ ^^^^^^^^      ^^                           ^^^^^            
+>{  name: "parentExtension2",  addOptions: () => {    return { parent: "exists", overwrite: "parent" };  },} : { name: string; addOptions: () => { parent: string; overwrite: string; }; }
+>                                                                                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  name: "parentExtension2",
+>name : string
+>     : ^^^^^^
+>"parentExtension2" : "parentExtension2"
+>                   : ^^^^^^^^^^^^^^^^^^
+
+  addOptions: () => {
+>addOptions : () => { parent: string; overwrite: string; }
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>() => {    return { parent: "exists", overwrite: "parent" };  } : () => { parent: string; overwrite: string; }
+>                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    return { parent: "exists", overwrite: "parent" };
+>{ parent: "exists", overwrite: "parent" } : { parent: string; overwrite: string; }
+>                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parent : string
+>       : ^^^^^^
+>"exists" : "exists"
+>         : ^^^^^^^^
+>overwrite : string
+>          : ^^^^^^
+>"parent" : "parent"
+>         : ^^^^^^^^
+
+  },
+});
+
+const childExtension2 = parentExtension2.configure({
+>childExtension2 : Extension<{ parent: string; overwrite: string; }>
+>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parentExtension2.configure({  child: "exists-too", // error  overwrite: "child",}) : Extension<{ parent: string; overwrite: string; }>
+>                                                                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parentExtension2.configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }>
+>                           : ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>parentExtension2 : Extension<{ parent: string; overwrite: string; }>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }>
+>          : ^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{  child: "exists-too", // error  overwrite: "child",} : { child: string; overwrite: string; }
+>                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  child: "exists-too", // error
+>child : string
+>      : ^^^^^^
+>"exists-too" : "exists-too"
+>             : ^^^^^^^^^^^^
+
+  overwrite: "child",
+>overwrite : string
+>          : ^^^^^^
+>"child" : "child"
+>        : ^^^^^^^
+
+});
+
+export {};
+
diff --git a/tests/baselines/reference/vueLikeDataAndPropsInference.types b/tests/baselines/reference/vueLikeDataAndPropsInference.types
index f71eba5d8bf66..84cb8efb7b79c 100644
--- a/tests/baselines/reference/vueLikeDataAndPropsInference.types
+++ b/tests/baselines/reference/vueLikeDataAndPropsInference.types
@@ -72,8 +72,8 @@ test({
 >                                                                                                                                                                                                                                     : ^^^^
 >test : { <Data, Props>(fn: ThisTypedOptions<Data, Props>): void; (fn: Options): void; }
 >     : ^^^    ^^     ^^  ^^                             ^^^    ^^^  ^^       ^^^    ^^^
->{    props: {        foo: ''    },    data(): { bar: boolean } {        return {            bar: true        }    },    watch: {        foo(newVal: string, oldVal: string): void {            this.bar = false        }    }} : { props: { foo: string; }; data(this: Readonly<{ foo: string; }> & Instance): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; }
->                                                                                                                                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^      ^^      ^^      ^^      ^^^    ^^^^^^
+>{    props: {        foo: ''    },    data(): { bar: boolean } {        return {            bar: true        }    },    watch: {        foo(newVal: string, oldVal: string): void {            this.bar = false        }    }} : { props: { foo: string; }; data(): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; }
+>                                                                                                                                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^      ^^      ^^      ^^      ^^^    ^^^^^^
 
     props: {
 >props : { foo: string; }
@@ -90,8 +90,8 @@ test({
     },
 
     data(): { bar: boolean } {
->data : (this: Readonly<{ foo: string; }> & Instance) => { bar: boolean; }
->     : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 
+>data : () => { bar: boolean; }
+>     : ^^^^^^                 
 >bar : boolean
 >    : ^^^^^^^
 
diff --git a/tests/baselines/reference/vueLikeDataAndPropsInference2.types b/tests/baselines/reference/vueLikeDataAndPropsInference2.types
index 206646398de17..ffacfe540217f 100644
--- a/tests/baselines/reference/vueLikeDataAndPropsInference2.types
+++ b/tests/baselines/reference/vueLikeDataAndPropsInference2.types
@@ -73,8 +73,8 @@ test({
 >                                                                                                                                                                                                                                     : ^^^^
 >test : { <Data, Props>(fn: ThisTypedOptions<Data, Props>): void; (fn: Options): void; }
 >     : ^^^    ^^     ^^  ^^                             ^^^    ^^^  ^^       ^^^    ^^^
->{    props: {        foo: ''    },    data(): { bar: boolean } {        return {            bar: true        }    },    watch: {        foo(newVal: string, oldVal: string): void {            this.bar = false        }    }} : { props: { foo: string; }; data(this: Readonly<{ foo: string; }> & Instance): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; }
->                                                                                                                                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^      ^^      ^^      ^^      ^^^    ^^^^^^
+>{    props: {        foo: ''    },    data(): { bar: boolean } {        return {            bar: true        }    },    watch: {        foo(newVal: string, oldVal: string): void {            this.bar = false        }    }} : { props: { foo: string; }; data(): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; }
+>                                                                                                                                                                                                                               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 ^^^^^^^^^^^^^^^      ^^      ^^      ^^      ^^^    ^^^^^^
 
     props: {
 >props : { foo: string; }
@@ -91,8 +91,8 @@ test({
     },
 
     data(): { bar: boolean } {
->data : (this: Readonly<{ foo: string; }> & Instance) => { bar: boolean; }
->     : ^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                 
+>data : () => { bar: boolean; }
+>     : ^^^^^^                 
 >bar : boolean
 >    : ^^^^^^^
 
diff --git a/tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts b/tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts
new file mode 100644
index 0000000000000..571ecce45f79e
--- /dev/null
+++ b/tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts
@@ -0,0 +1,49 @@
+// @strict: true
+// @target: esnext
+// @lib: esnext
+// @noEmit: true
+
+type ReadonlyRecord<in out K extends string | symbol, out A> = {
+  readonly [P in K]: A;
+};
+
+type Success<T> = T extends Micro<infer _A, infer _E, infer _R> ? _A : never;
+
+interface MicroIterator<T extends Micro<any, any, any>> {
+  next(...args: ReadonlyArray<any>): IteratorResult<T, Success<T>>;
+}
+
+interface Micro<out A, out E = never, out R = never> {
+  _A: A;
+  _E: E;
+  _R: R;
+  [Symbol.iterator](): MicroIterator<Micro<A, E, R>>;
+}
+
+declare function runPromise<A, E>(effect: Micro<A, E>): Promise<A>;
+
+declare function gen<Eff extends Micro<any, any, any>, AEff>(
+  body: () => Generator<Eff, AEff, never>,
+): Micro<AEff, any, never>;
+
+declare const traverse: {
+  <A, R, O, E, B>(
+    f: (a: A) => Micro<B, E, O>,
+  ): (
+    self: ReadonlyRecord<string, A>,
+  ) => Micro<ReadonlyRecord<string, B>, E, O>;
+  <A, O, E, B>(
+    self: ReadonlyRecord<string, A>,
+    f: (a: A) => Micro<B, E, O>,
+  ): Micro<ReadonlyRecord<string, B>, E, O>;
+};
+
+runPromise(
+  gen(function* () {
+    yield* traverse({ a: 1, b: 2 }, (n) =>
+      gen(function* () {
+        return n + 1;
+      }),
+    );
+  }),
+);
diff --git a/tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts b/tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts
new file mode 100644
index 0000000000000..35db556e9d221
--- /dev/null
+++ b/tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts
@@ -0,0 +1,59 @@
+// @strict: true
+// @target: esnext
+// @noEmit: true
+
+interface Effect<out A> {
+  readonly _A: A;
+}
+
+declare function gen<Eff extends Effect<any>, AEff>(
+  f: () => Generator<Eff, AEff>
+): Effect<AEff>;
+
+interface Rpc<
+  in out Tag extends string,
+  out Payload = unknown,
+  out Success = unknown
+> {
+  readonly _tag: Tag;
+  readonly payloadSchema: Payload;
+  readonly successSchema: Success;
+}
+
+interface RpcAny {
+  readonly _tag: string;
+}
+
+type Payload<R> = R extends Rpc<infer _Tag, infer _Payload, infer _Success>
+  ? _Payload
+  : never;
+
+type ResultFrom<R extends RpcAny> = R extends Rpc<
+  infer _Tag,
+  infer _Payload,
+  infer _Success
+>
+  ? _Success
+  : never;
+
+type ToHandlerFn<Current extends RpcAny> = (
+  payload: Payload<Current>
+) => ResultFrom<Current>;
+
+type HandlersFrom<Rpc extends RpcAny> = {
+  readonly [Current in Rpc as Current["_tag"]]: ToHandlerFn<Current>;
+};
+
+interface RpcGroup<in out R extends RpcAny> {
+  toLayer<Handlers extends HandlersFrom<R>>(build: Effect<Handlers>): unknown;
+}
+
+declare const Rpcs: RpcGroup<Rpc<"Register", number, string>>;
+
+export const layerServerHandlers = Rpcs.toLayer(
+  gen(function* () {
+    return {
+      Register: (id) => String(id),
+    };
+  })
+);
diff --git a/tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts b/tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts
new file mode 100644
index 0000000000000..e1c340544e72c
--- /dev/null
+++ b/tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts
@@ -0,0 +1,242 @@
+// @strict: true
+// @target: esnext
+// @noEmit: true
+
+// https://github.com/microsoft/TypeScript/issues/62204
+
+declare function TestConfig<const TConfig extends { a?: any; b?: any; c?: any }>(
+  config: TConfig,
+  test: keyof Omit<TConfig, "a" | "b"> extends never ? true : false,
+): void;
+
+TestConfig(
+  {
+    a: "hello",
+    b: function () {
+      return 123;
+    },
+  },
+  true,
+);
+
+TestConfig(
+  {
+    a: "hello",
+    b: function () {
+      return 123;
+    },
+  },
+  false, // error
+);
+
+// https://github.com/microsoft/TypeScript/issues/60986
+interface SubscribeFieldOptions<Event> {
+  subscribe: () => Event;
+  resolve: (event: Event) => number;
+}
+
+declare function defineOptions<Event>(
+  options: SubscribeFieldOptions<Event>,
+): void;
+
+defineOptions({
+  resolve: (event) => event, // number
+  subscribe() {
+    return 123;
+  },
+});
+
+defineOptions({
+  resolve: (event) => event, // number
+  subscribe: function () {
+    return 123;
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/58630
+
+export type StateFunction<State> = (s: State, ...args: any[]) => any;
+
+export type VuexStoreOptions<State, Modules> = {
+  state?: State | (() => State) | { (): State };
+  mutations?: Record<string, StateFunction<State>>;
+  modules?: {
+    [k in keyof Modules]: VuexStoreOptions<Modules[k], never>;
+  };
+};
+
+export function createStore<
+  State extends Record<string, unknown>,
+  Modules extends Record<string, Record<string, unknown>>,
+>(options: VuexStoreOptions<State, Modules>) {}
+
+const store = createStore({
+  state() {
+    return { bar2: 1 };
+  },
+  mutations: { inc: (state123) => state123.bar2++ },
+  modules: {
+    foo: {
+      state() {
+        return { bar2: 1 };
+      },
+      mutations: { inc: (state) => state.bar2++ },
+    },
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/57572
+
+type C = <Methods, Attached = (methods: Methods) => void>(options: {
+  methods: Methods;
+  attached: Attached;
+}) => any;
+
+var Component: C = () => {};
+
+Component({
+  attached(methods) {
+    methods.bbb(); // ok
+  },
+  methods: {
+    bbb() {},
+  },
+});
+
+Component({
+  attached(methods) {
+    methods.bbb(); // ok
+  },
+  methods: {
+    bbb: () => {},
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/56067
+
+declare function create56067<
+  State extends Record<string, any>,
+  Data extends Record<string, any>,
+  Actions extends (state: State, data: Data) => Record<string, any>,
+>(args: { getState: () => State; actions: Actions; getData: () => Data }): void;
+
+create56067({
+  getState() {
+    return { a: 1 };
+  },
+  getData: () => {
+    return { b: 2 };
+  },
+  actions(state, data) {
+    state // { a: number }
+    data; // { b: number }
+    return {
+      z: 1,
+    };
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/55489
+type NonStringIterable<T> = 
+  T extends string ? never : T extends Iterable<any> ? T : never;
+
+declare function doSomething<T>(value: NonStringIterable<T>): T;
+
+const o = { foo() {} };
+
+doSomething('value'); // error
+doSomething(['v']); // ok
+doSomething([o]); // ok
+doSomething([{ foo() {} }]); // ok
+
+// https://github.com/microsoft/TypeScript/issues/55124
+type Values<T> = T[keyof T];
+type ExtractFields<Options> = Values<{
+  [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never;
+}>;
+type SetType<Options> = {
+  [key: string]: any;
+  target?: ExtractFields<Options>;
+};
+
+declare function test55124<OptionsData extends SetType<OptionsData>>(
+  options: OptionsData,
+): void;
+
+test55124({
+  target: "$test4", // ok
+  data1: {
+    $test1: 111,
+    $test2: null,
+  },
+  data2: {
+    $test3: {},
+    $test4: () => {},
+    $test5() {},
+  },
+});
+
+test55124({
+  target: "$test6", // error
+  data1: {
+    $test1: 111,
+    $test2: null,
+  },
+  data2: {
+    $test3: {},
+    $test4: () => {},
+    $test5() {},
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/53924
+function test53924<T = unknown>(options: { a: (c: T) => void; b: () => T }) {}
+
+test53924({
+  a: (c) => {
+    c; // number;
+  },
+  b: () => 123,
+});
+
+test53924({
+  b: () => 123,
+  a: (c) => {
+    return c; // number
+  },
+});
+
+test53924({
+  b() {
+    return 123;
+  },
+  a(c) {
+    return c; // number
+  },
+});
+
+test53924({
+  a(c) {
+    return c; // number
+  },
+  b() {
+    return 123;
+  },
+});
+
+// https://github.com/microsoft/TypeScript/issues/50258
+declare function monitor<T extends (...args: any) => any>(
+  extractor: (...args: Parameters<T>) => Record<string, unknown>,
+  executor: T,
+): (...args: Parameters<T>) => ReturnType<T>;
+
+monitor(
+  (p) => ({ p }), // { p: number }
+  (p: number) => p,
+);
+monitor(
+  (p) => ({ p }), // { p: number }
+  function (p: number) {
+    return p;
+  },
+);
diff --git a/tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts b/tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts
new file mode 100644
index 0000000000000..946dfc69179a7
--- /dev/null
+++ b/tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts
@@ -0,0 +1,125 @@
+// @strict: true
+// @target: esnext
+// @noEmit: true
+
+interface Options<Context, Data> {
+  context: Context;
+  produce(this: Context): Data;
+  consume(this: Context, data: Data): void;
+}
+
+declare function defineOptions<Context, Data>(
+  options: Options<Context, Data>,
+): [Context, Data];
+
+const result1 = defineOptions({
+  context: { tag: "A", value: 1 },
+  consume(_data) {},
+  produce() {
+    return 42;
+  },
+});
+
+const result2 = defineOptions({
+  context: { tag: "B", value: 2 },
+  consume(_data) {},
+  produce() {
+    return this.value;
+  },
+});
+
+const result3 = defineOptions({
+  context: { tag: "C", value: 3 },
+  consume(_data) {},
+  produce: () => 123,
+});
+
+const result4 = defineOptions({
+  context: { tag: "D", value: 4 },
+  consume(_data) {},
+  produce() {
+    class Local {
+      value = 'foo';
+      get() {
+        return this.value;
+      }
+    }
+    return new Local().get();;
+  },
+});
+
+const result5 = defineOptions({
+  context: { tag: "E", value: 5 },
+  consume(_data) {},
+  produce() {
+    function inner() {
+      return this;
+    }
+    return inner();
+  },
+});
+
+const result6 = defineOptions({
+  context: { tag: "F", value: 6 },
+  consume(_data) {},
+  produce() {
+    const arrow = () => this.value;
+    return arrow();
+  },
+});
+
+const result7 = defineOptions({
+  context: { tag: "G", value: 7 },
+  consume(_data) {},
+  produce() {
+    const self = this;
+    function inner() {
+      return self.value;
+    }
+    return inner();
+  },
+});
+
+const result8 = defineOptions({
+  context: { tag: "H", value: 8 },
+  consume(_data) {},
+  produce: () => {
+    return this;
+  },
+});
+
+const result9 = defineOptions({
+  context: { tag: "I", value: 9 },
+  consume(_data) {},
+  produce() {
+    const obj = {
+      value: 'foo',
+      get() {
+        return this.value;
+      },
+    };
+    return obj.get();
+  },
+});
+
+const result10 = defineOptions({
+  context: { tag: "I", value: 9 },
+  consume(_data) {},
+  produce() {
+    interface Foo {
+        prop: this;
+    }
+    return {} as Foo;
+  },
+});
+
+const result11 = defineOptions({
+  context: { tag: "I", value: 9 },
+  consume(_data) {},
+  produce() {
+    function fn(this: { prop: string }) {
+      return this.prop;
+    }
+    return fn;
+  },
+});
diff --git a/tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts b/tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts
new file mode 100644
index 0000000000000..d730208cce63e
--- /dev/null
+++ b/tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts
@@ -0,0 +1,116 @@
+// @strict: true
+// @target: esnext
+// @noEmit: true
+
+declare class Editor {
+  private _editor;
+}
+
+declare class Plugin {
+  private _plugin;
+}
+
+type ParentConfig<T> = Partial<{
+  [P in keyof T]: Required<T>[P] extends (...args: any) => any
+    ? (...args: Parameters<Required<T>[P]>) => ReturnType<Required<T>[P]>
+    : T[P];
+}>;
+
+interface ExtendableConfig<
+  Options = any,
+  Config extends
+    | ExtensionConfig<Options>
+    | ExtendableConfig<Options> = ExtendableConfig<Options, any>,
+> {
+  name: string;
+  addOptions?: (this: {
+    name: string;
+    parent: ParentConfig<Config>["addOptions"];
+  }) => Options;
+  addProseMirrorPlugins?: (this: {
+    options: Options;
+    editor: Editor;
+  }) => Plugin[];
+}
+
+interface ExtensionConfig<Options = any>
+  extends ExtendableConfig<Options, ExtensionConfig<Options>> {}
+
+declare class Extension<Options = any> {
+  _options: Options;
+
+  static create<O = any>(config: Partial<ExtensionConfig<O>>): Extension<O>;
+
+  configure(options?: Partial<Options>): Extension<Options>;
+}
+
+interface SuggestionOptions {
+  editor: Editor;
+  char?: string;
+}
+
+declare function Suggestion(options: SuggestionOptions): Plugin;
+
+Extension.create({
+  name: "slash-command",
+  addOptions() {
+    return {
+      suggestion: {
+        char: "/",
+      } as SuggestionOptions,
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      Suggestion({
+        editor: this.editor, // error
+        ...this.options.suggestion,
+      }),
+    ];
+  },
+});
+
+Extension.create({
+  name: "slash-command",
+  addOptions: () => {
+    return {
+      suggestion: {
+        char: "/",
+      } as SuggestionOptions,
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      Suggestion({
+        editor: this.editor, // error
+        ...this.options.suggestion,
+      }),
+    ];
+  },
+});
+
+const parentExtension = Extension.create({
+  name: "parentExtension",
+  addOptions() {
+    return { parent: "exists", overwrite: "parent" };
+  },
+});
+
+const childExtension = parentExtension.configure({
+  child: "exists-too", // error
+  overwrite: "child",
+});
+
+const parentExtension2 = Extension.create({
+  name: "parentExtension2",
+  addOptions: () => {
+    return { parent: "exists", overwrite: "parent" };
+  },
+});
+
+const childExtension2 = parentExtension2.configure({
+  child: "exists-too", // error
+  overwrite: "child",
+});
+
+export {};