Still get aparent type

Author: weswigham

src/compiler/checker.ts

@@ -13128,9 +13128,10 @@ namespace ts {
          */
         function getInstantiatedContextualType(node: Expression, checkMode?: CheckMode): Type {
             if (checkMode === CheckMode.Inferential && node.contextualType && node.contextualMapper) {
-                return instantiateType(node.contextualType, node.contextualMapper);
+                const type = instantiateType(node.contextualType, node.contextualMapper);
+                return type && getApparentType(type);
             }
-            return getContextualType(node, checkMode);
+            return getApparentTypeOfContextualType(node, checkMode);
         }
 
         /**

tests/baselines/reference/inferentialTypingUsingApparentType2.types

@@ -13,7 +13,7 @@ function foo<T extends { m(p: string): number }>(x: T): T {
 }
 
 foo({ m(x) { return x.length } });
->foo({ m(x) { return x.length } }) : { m(p: string): number; }
+>foo({ m(x) { return x.length } }) : { m(x: string): number; }
 >foo : <T extends { m(p: string): number; }>(x: T) => T
 >{ m(x) { return x.length } } : { m(x: string): number; }
 >m : (x: string) => number

tests/baselines/reference/inferringAnyFunctionType5.types

@@ -13,8 +13,8 @@ function f<T extends { q: (p1: number) => number }>(p: T): T {
 }
 
 var v = f({ q: x => x });
->v : { q: (p1: number) => number; }
->f({ q: x => x }) : { q: (p1: number) => number; }
+>v : { q: (x: number) => number; }
+>f({ q: x => x }) : { q: (x: number) => number; }
 >f : <T extends { q: (p1: number) => number; }>(p: T) => T
 >{ q: x => x } : { q: (x: number) => number; }
 >q : (x: number) => number