Slightly improve test, add comment explaining situation

Author: weswigham

src/compiler/checker.ts

@@ -11963,11 +11963,20 @@ namespace ts {
                         const mapper = (target as ConditionalType).mapper;
                         const context = createInferenceContext(root.inferTypeParameters, /*signature*/ undefined, InferenceFlags.None);
                         const instantiatedExtends = instantiateType(root.extendsType, mapper);
-                        const checkConstraint = getSimplifiedType(instantiateType(root.checkType, combineTypeMappers(mapper, getBaseConstraintOrType)));
-                        inferTypes(context.inferences, checkConstraint, instantiatedExtends, InferencePriority.NoConstraints | InferencePriority.AlwaysStrict);
+                        const checkConstraint = getSimplifiedType(instantiateType(root.checkType, mapper));
+                        // TODO: Use InferencePriority.NoConstraints for type parameters which are being used contravariantly/in a write-only context
+                        // (Or, ideally, some future InferencePriority.SuperConstraints should we start tracking them!)
+                        // As-is, this is unsound - it can be made stricter by replacing `instantiateType(root.trueType, combinedMapper)` with
+                        // `getintersectionType([instantiateType(root.trueType, combinedMapper), instantiateType(root.trueType, mapper)])` which
+                        // would preserve the type-parametery-ness of the check; but such a limitation makes this branch almost useless, as only
+                        // conditional types with effectively "independent" inference parameters will end up being assignable via this branch, eg
+                        // `type InferBecauseWhyNot<T> = T extends (p: infer P1) => any ? T | P1 : never;`
+                        // contains a union in the `true` branch, and so while we can't confirm assignability to `P1`, we _could_ confirm assignability
+                        // to `T`.
+                        inferTypes(context.inferences, checkConstraint, instantiatedExtends, InferencePriority.AlwaysStrict);
                         const combinedMapper = combineTypeMappers(mapper, context);
                         if (isRelatedTo(checkConstraint, instantiateType(root.extendsType, combinedMapper))) {
-                            if (result = isRelatedTo(source, instantiateType(root.trueType, combinedMapper))) {
+                            if (result = isRelatedTo(source, instantiateType(root.trueType, combinedMapper), reportErrors)) {
                                 errorInfo = saveErrorInfo;
                                 return result;
                             }

tests/baselines/reference/genericRestTypes.types

@@ -22,7 +22,7 @@ type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parame
 >Bind1 : Bind1<T>
 >head : any
 >tail : any[]
->args : any[]
+>args : Tail<Parameters<T>>
 
 type Generic = Bind1<MyFunctionType>; // (bar: string) => boolean
 >Generic : Bind1<MyFunctionType>

tests/baselines/reference/thisConditionalInferenceInClassBody.js

@@ -12,7 +12,14 @@ class Foo {
     }
 }
 
-set(new Foo(), 'prop', 'hi'); // <-- typechecks
+set(new Foo(), 'prop', 'hi'); // <-- typechecks
+
+type InferBecauseWhyNot<T> = T extends (p: infer P1) => any ? P1 | T : never;
+
+function f<Q extends (arg: any) => any>(x: Q): InferBecauseWhyNot<Q> {
+    return x;
+}
+
 
 //// [thisConditionalInferenceInClassBody.js]
 var Foo = /** @class */ (function () {
@@ -24,3 +31,6 @@ var Foo = /** @class */ (function () {
     return Foo;
 }());
 set(new Foo(), 'prop', 'hi'); // <-- typechecks
+function f(x) {
+    return x;
+}

tests/baselines/reference/thisConditionalInferenceInClassBody.symbols

@@ -51,3 +51,25 @@ set(new Foo(), 'prop', 'hi'); // <-- typechecks
 >set : Symbol(set, Decl(thisConditionalInferenceInClassBody.ts, 1, 52))
 >Foo : Symbol(Foo, Decl(thisConditionalInferenceInClassBody.ts, 3, 94))
 
+type InferBecauseWhyNot<T> = T extends (p: infer P1) => any ? P1 | T : never;
+>InferBecauseWhyNot : Symbol(InferBecauseWhyNot, Decl(thisConditionalInferenceInClassBody.ts, 13, 29))
+>T : Symbol(T, Decl(thisConditionalInferenceInClassBody.ts, 15, 24))
+>T : Symbol(T, Decl(thisConditionalInferenceInClassBody.ts, 15, 24))
+>p : Symbol(p, Decl(thisConditionalInferenceInClassBody.ts, 15, 40))
+>P1 : Symbol(P1, Decl(thisConditionalInferenceInClassBody.ts, 15, 48))
+>P1 : Symbol(P1, Decl(thisConditionalInferenceInClassBody.ts, 15, 48))
+>T : Symbol(T, Decl(thisConditionalInferenceInClassBody.ts, 15, 24))
+
+function f<Q extends (arg: any) => any>(x: Q): InferBecauseWhyNot<Q> {
+>f : Symbol(f, Decl(thisConditionalInferenceInClassBody.ts, 15, 77))
+>Q : Symbol(Q, Decl(thisConditionalInferenceInClassBody.ts, 17, 11))
+>arg : Symbol(arg, Decl(thisConditionalInferenceInClassBody.ts, 17, 22))
+>x : Symbol(x, Decl(thisConditionalInferenceInClassBody.ts, 17, 40))
+>Q : Symbol(Q, Decl(thisConditionalInferenceInClassBody.ts, 17, 11))
+>InferBecauseWhyNot : Symbol(InferBecauseWhyNot, Decl(thisConditionalInferenceInClassBody.ts, 13, 29))
+>Q : Symbol(Q, Decl(thisConditionalInferenceInClassBody.ts, 17, 11))
+
+    return x;
+>x : Symbol(x, Decl(thisConditionalInferenceInClassBody.ts, 17, 40))
+}
+

tests/baselines/reference/thisConditionalInferenceInClassBody.types

@@ -38,3 +38,16 @@ set(new Foo(), 'prop', 'hi'); // <-- typechecks
 >'prop' : "prop"
 >'hi' : "hi"
 
+type InferBecauseWhyNot<T> = T extends (p: infer P1) => any ? P1 | T : never;
+>InferBecauseWhyNot : InferBecauseWhyNot<T>
+>p : P1
+
+function f<Q extends (arg: any) => any>(x: Q): InferBecauseWhyNot<Q> {
+>f : <Q extends (arg: any) => any>(x: Q) => InferBecauseWhyNot<Q>
+>arg : any
+>x : Q
+
+    return x;
+>x : Q
+}
+

tests/cases/compiler/thisConditionalInferenceInClassBody.ts

@@ -11,4 +11,10 @@ class Foo {
     }
 }
 
-set(new Foo(), 'prop', 'hi'); // <-- typechecks
+set(new Foo(), 'prop', 'hi'); // <-- typechecks
+
+type InferBecauseWhyNot<T> = T extends (p: infer P1) => any ? P1 | T : never;
+
+function f<Q extends (arg: any) => any>(x: Q): InferBecauseWhyNot<Q> {
+    return x;
+}