When calculating inferred infer type constraints, replace conditionals…

src/compiler/checker.ts

@@ -13373,10 +13373,34 @@ namespace ts {
                             (grandParent.parent as ConditionalTypeNode).extendsType === grandParent && (grandParent.parent as ConditionalTypeNode).checkType.kind === SyntaxKind.MappedType &&
                             ((grandParent.parent as ConditionalTypeNode).checkType as MappedTypeNode).type) {
                             const checkMappedType = (grandParent.parent as ConditionalTypeNode).checkType as MappedTypeNode;
-                            const nodeType = getTypeFromTypeNode(checkMappedType.type!);
+                            let nodeType = getTypeFromTypeNode(checkMappedType.type!);
+                            // Unwrap any top-level conditionals in the template type to their constraints
+                            while (someType(nodeType, isOrHasGenericConditional)) {
+                                const original = nodeType;
+                                nodeType = mapType(nodeType, t => t.flags & TypeFlags.Conditional && getConstraintFromConditionalType(t as ConditionalType) || t);
+                                if (nodeType === original) {
+                                    break;
+                                }
+                            }
+                            // Instantiate away the mapped type parameter into the parameter's constraint
                             inferences = append(inferences, instantiateType(nodeType,
                                 makeUnaryTypeMapper(getDeclaredTypeOfTypeParameter(getSymbolOfNode(checkMappedType.typeParameter)), checkMappedType.typeParameter.constraint ? getTypeFromTypeNode(checkMappedType.typeParameter.constraint) : keyofConstraintType)
                             ));
+                            // This isn't the highest precision constraint we could make, but the alternatives are very invasive and very ugly
+                            // Specifically, it'd be more correct to do something like manufacture
+                            // {[K in U]: WhateverTemplate<K>}[U]
+                            // or equivalently
+                            // U extends infer K extends U ? WhateverTemplate<K> : never
+                            // but both are _very_ complicated types which encounter issues elsewhere in the checker, even in the common case.
+                            // Specifically
+                            // - the first incorrectly simplifies to `WhateverTemplate<U>` in `getSimplifiedType`, removing the notion of
+                            // distribution over keys from the type and making the template resolve incorrectly if it contains conditionals
+                            // - the second has relationship issues; namely conditional types are usually only related by === equality, but
+                            // are over-instantiated today because `isTypeParamaterPossibleReferenced` doesn't filter outer type parameters
+                            // well enough (or at all, from what I've seen - it only filters out parameters which are unreferenced _everywhere_,
+                            // rather than those which are unused within the given node).
+                            //
+                            // Each of those relationship issues, in turn, then cause inference of the `infer` type parameter in question to fail.
                         }
                     }
                 }

tests/baselines/reference/inferConditionalConstraintMappedMember.types

@@ -9,7 +9,7 @@ type KeysWithoutStringIndex<T> =
 
 // Only "foo" | "bar" as expected, [string] index signature removed
 type test = KeysWithoutStringIndex<{ [index: string]: string; foo: string; bar: 'baz' }>
->test : never
+>test : "foo" | "bar"
 >index : string
 >foo : string
 >bar : "baz"

tests/baselines/reference/inferImpliedConstraintNotExecuted.js

@@ -0,0 +1,19 @@
+//// [inferImpliedConstraintNotExecuted.ts]
+type KnownKeys<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K
+} extends { [_ in keyof T]: infer U } ? U : never;
+
+
+interface HasStringKeys {
+    [s: string]: any;
+}
+
+interface ThingWithKeys extends HasStringKeys {
+    foo: unknown;
+    bar: unknown;
+}
+
+const demo: KnownKeys<ThingWithKeys> = 'foo';
+
+//// [inferImpliedConstraintNotExecuted.js]
+var demo = 'foo';

tests/baselines/reference/inferImpliedConstraintNotExecuted.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/compiler/inferImpliedConstraintNotExecuted.ts ===
+type KnownKeys<T> = {
+>KnownKeys : Symbol(KnownKeys, Decl(inferImpliedConstraintNotExecuted.ts, 0, 0))
+>T : Symbol(T, Decl(inferImpliedConstraintNotExecuted.ts, 0, 15))
+
+    [K in keyof T]: string extends K ? never : number extends K ? never : K
+>K : Symbol(K, Decl(inferImpliedConstraintNotExecuted.ts, 1, 5))
+>T : Symbol(T, Decl(inferImpliedConstraintNotExecuted.ts, 0, 15))
+>K : Symbol(K, Decl(inferImpliedConstraintNotExecuted.ts, 1, 5))
+>K : Symbol(K, Decl(inferImpliedConstraintNotExecuted.ts, 1, 5))
+>K : Symbol(K, Decl(inferImpliedConstraintNotExecuted.ts, 1, 5))
+
+} extends { [_ in keyof T]: infer U } ? U : never;
+>_ : Symbol(_, Decl(inferImpliedConstraintNotExecuted.ts, 2, 13))
+>T : Symbol(T, Decl(inferImpliedConstraintNotExecuted.ts, 0, 15))
+>U : Symbol(U, Decl(inferImpliedConstraintNotExecuted.ts, 2, 33))
+>U : Symbol(U, Decl(inferImpliedConstraintNotExecuted.ts, 2, 33))
+
+
+interface HasStringKeys {
+>HasStringKeys : Symbol(HasStringKeys, Decl(inferImpliedConstraintNotExecuted.ts, 2, 50))
+
+    [s: string]: any;
+>s : Symbol(s, Decl(inferImpliedConstraintNotExecuted.ts, 6, 5))
+}
+
+interface ThingWithKeys extends HasStringKeys {
+>ThingWithKeys : Symbol(ThingWithKeys, Decl(inferImpliedConstraintNotExecuted.ts, 7, 1))
+>HasStringKeys : Symbol(HasStringKeys, Decl(inferImpliedConstraintNotExecuted.ts, 2, 50))
+
+    foo: unknown;
+>foo : Symbol(ThingWithKeys.foo, Decl(inferImpliedConstraintNotExecuted.ts, 9, 47))
+
+    bar: unknown;
+>bar : Symbol(ThingWithKeys.bar, Decl(inferImpliedConstraintNotExecuted.ts, 10, 17))
+}
+
+const demo: KnownKeys<ThingWithKeys> = 'foo';
+>demo : Symbol(demo, Decl(inferImpliedConstraintNotExecuted.ts, 14, 5))
+>KnownKeys : Symbol(KnownKeys, Decl(inferImpliedConstraintNotExecuted.ts, 0, 0))
+>ThingWithKeys : Symbol(ThingWithKeys, Decl(inferImpliedConstraintNotExecuted.ts, 7, 1))
+

tests/baselines/reference/inferImpliedConstraintNotExecuted.types

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/inferImpliedConstraintNotExecuted.ts ===
+type KnownKeys<T> = {
+>KnownKeys : KnownKeys<T>
+
+    [K in keyof T]: string extends K ? never : number extends K ? never : K
+} extends { [_ in keyof T]: infer U } ? U : never;
+
+
+interface HasStringKeys {
+    [s: string]: any;
+>s : string
+}
+
+interface ThingWithKeys extends HasStringKeys {
+    foo: unknown;
+>foo : unknown
+
+    bar: unknown;
+>bar : unknown
+}
+
+const demo: KnownKeys<ThingWithKeys> = 'foo';
+>demo : "foo" | "bar"
+>'foo' : "foo"
+

tests/cases/compiler/inferImpliedConstraintNotExecuted.ts

@@ -0,0 +1,15 @@
+type KnownKeys<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K
+} extends { [_ in keyof T]: infer U } ? U : never;
+
+
+interface HasStringKeys {
+    [s: string]: any;
+}
+
+interface ThingWithKeys extends HasStringKeys {
+    foo: unknown;
+    bar: unknown;
+}
+
+const demo: KnownKeys<ThingWithKeys> = 'foo';