Merge pull request #23039 from Microsoft/fixConditionalConstraints

Improve conditional type constraints

Author: ahejlsberg

src/compiler/checker.ts

@@ -6245,7 +6245,12 @@ namespace ts {
         }
 
         function getDefaultConstraintOfConditionalType(type: ConditionalType) {
-            return getUnionType([getInferredTrueTypeFromConditionalType(type), getFalseTypeFromConditionalType(type)]);
+            if (!type.resolvedDefaultConstraint) {
+                const rootTrueType = type.root.trueType;
+                const rootTrueConstraint = rootTrueType.flags & TypeFlags.Substitution ? (<SubstitutionType>rootTrueType).substitute : rootTrueType;
+                type.resolvedDefaultConstraint = getUnionType([instantiateType(rootTrueConstraint, type.combinedMapper || type.mapper), getFalseTypeFromConditionalType(type)]);
+            }
+            return type.resolvedDefaultConstraint;
         }
 
         function getConstraintOfDistributiveConditionalType(type: ConditionalType): Type {
@@ -6258,7 +6263,10 @@ namespace ts {
                 const constraint = getConstraintOfType(type.checkType);
                 if (constraint) {
                     const mapper = createTypeMapper([<TypeParameter>type.root.checkType], [constraint]);
-                    return getConditionalTypeInstantiation(type, combineTypeMappers(mapper, type.mapper));
+                    const instantiated = getConditionalTypeInstantiation(type, combineTypeMappers(mapper, type.mapper));
+                    if (!(instantiated.flags & TypeFlags.Never)) {
+                        return instantiated;
+                    }
                 }
             }
             return undefined;
@@ -8410,12 +8418,6 @@ namespace ts {
             return type.resolvedFalseType || (type.resolvedFalseType = instantiateType(type.root.falseType, type.mapper));
         }
 
-        function getInferredTrueTypeFromConditionalType(type: ConditionalType) {
-            return type.combinedMapper ?
-                type.resolvedInferredTrueType || (type.resolvedInferredTrueType = instantiateType(type.root.trueType, type.combinedMapper)) :
-                getTrueTypeFromConditionalType(type);
-        }
-
         function getInferTypeParameters(node: ConditionalTypeNode): TypeParameter[] {
             let result: TypeParameter[];
             if (node.locals) {
@@ -8428,13 +8430,25 @@ namespace ts {
             return result;
         }
 
+        function getTopConditionalType(node: Node): ConditionalTypeNode {
+            let result: ConditionalTypeNode;
+            while (node) {
+                if (node.kind === SyntaxKind.ConditionalType) {
+                    result = <ConditionalTypeNode>node;
+                }
+                node = node.parent;
+            }
+            return result;
+        }
+
         function getTypeFromConditionalTypeNode(node: ConditionalTypeNode): Type {
             const links = getNodeLinks(node);
             if (!links.resolvedType) {
                 const checkType = getTypeFromTypeNode(node.checkType);
                 const aliasTypeArguments = getAliasTypeArgumentsForTypeNode(node);
                 const allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true);
-                const outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : filter(allOuterTypeParameters, tp => isTypeParameterPossiblyReferenced(tp, node));
+                const topNode = getTopConditionalType(node);
+                const outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : filter(allOuterTypeParameters, tp => isTypeParameterPossiblyReferenced(tp, topNode));
                 const root: ConditionalRoot = {
                     node,
                     checkType,

src/compiler/types.ts

@@ -3882,7 +3882,7 @@ namespace ts {
         resolvedTrueType?: Type;
         resolvedFalseType?: Type;
         /* @internal */
-        resolvedInferredTrueType?: Type;
+        resolvedDefaultConstraint?: Type;
         /* @internal */
         mapper?: TypeMapper;
         /* @internal */

tests/baselines/reference/conditionalTypes2.errors.txt

@@ -10,9 +10,21 @@ tests/cases/conformance/types/conditional/conditionalTypes2.ts(25,5): error TS23
   Types of property 'foo' are incompatible.
     Type 'A extends string ? keyof A : A' is not assignable to type 'B extends string ? keyof B : B'.
       Type 'A' is not assignable to type 'B'.
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(73,12): error TS2345: Argument of type 'Extract<Extract<T, Foo>, Bar>' is not assignable to parameter of type '{ foo: string; bat: string; }'.
+  Type 'Bar & Extract<T, Foo>' is not assignable to type '{ foo: string; bat: string; }'.
+    Property 'bat' is missing in type 'Bar & Foo'.
+      Type 'Extract<Foo & T, Bar>' is not assignable to type '{ foo: string; bat: string; }'.
+        Type 'Bar & Foo & T' is not assignable to type '{ foo: string; bat: string; }'.
+          Property 'bat' is missing in type 'Bar & Foo'.
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(74,12): error TS2345: Argument of type 'Extract<T, Foo & Bar>' is not assignable to parameter of type '{ foo: string; bat: string; }'.
+  Type 'Foo & Bar & T' is not assignable to type '{ foo: string; bat: string; }'.
+    Property 'bat' is missing in type 'Foo & Bar'.
+tests/cases/conformance/types/conditional/conditionalTypes2.ts(75,12): error TS2345: Argument of type 'Extract2<T, Foo, Bar>' is not assignable to parameter of type '{ foo: string; bat: string; }'.
+  Type 'T extends Bar ? T : never' is not assignable to type '{ foo: string; bat: string; }'.
+    Type 'Bar & Foo & T' is not assignable to type '{ foo: string; bat: string; }'.
 
 
-==== tests/cases/conformance/types/conditional/conditionalTypes2.ts (4 errors) ====
+==== tests/cases/conformance/types/conditional/conditionalTypes2.ts (7 errors) ====
     interface Covariant<T> {
         foo: T extends string ? T : number;
     }
@@ -56,6 +68,71 @@ tests/cases/conformance/types/conditional/conditionalTypes2.ts(25,5): error TS23
 !!! error TS2322:       Type 'A' is not assignable to type 'B'.
     }
 
+    // Extract<T, Function> is a T that is known to be a Function
+    function isFunction<T>(value: T): value is Extract<T, Function> {
+        return typeof value === "function";
+    }
+    
+    function getFunction<T>(item: T) {
+        if (isFunction(item)) {
+            return item;
+        }
+        throw new Error();
+    }
+    
+    function f10<T>(x: T) {
+        if (isFunction(x)) {
+            const f: Function = x;
+            const t: T = x;
+        }
+    }
+    
+    function f11(x: string | (() => string) | undefined) {
+        if (isFunction(x)) {
+            x();
+        }
+    }
+    
+    function f12(x: string | (() => string) | undefined) {
+        const f = getFunction(x);  // () => string
+        f();
+    }
+    
+    type Foo = { foo: string };
+    type Bar = { bar: string };
+    
+    declare function fooBar(x: { foo: string, bar: string }): void;
+    declare function fooBat(x: { foo: string, bat: string }): void;
+    
+    type Extract2<T, U, V> = T extends U ? T extends V ? T : never : never;
+    
+    function f20<T>(x: Extract<Extract<T, Foo>, Bar>, y: Extract<T, Foo & Bar>, z: Extract2<T, Foo, Bar>) {
+        fooBar(x);
+        fooBar(y);
+        fooBar(z);
+    }
+    
+    function f21<T>(x: Extract<Extract<T, Foo>, Bar>, y: Extract<T, Foo & Bar>, z: Extract2<T, Foo, Bar>) {
+        fooBat(x);  // Error
+               ~
+!!! error TS2345: Argument of type 'Extract<Extract<T, Foo>, Bar>' is not assignable to parameter of type '{ foo: string; bat: string; }'.
+!!! error TS2345:   Type 'Bar & Extract<T, Foo>' is not assignable to type '{ foo: string; bat: string; }'.
+!!! error TS2345:     Property 'bat' is missing in type 'Bar & Foo'.
+!!! error TS2345:       Type 'Extract<Foo & T, Bar>' is not assignable to type '{ foo: string; bat: string; }'.
+!!! error TS2345:         Type 'Bar & Foo & T' is not assignable to type '{ foo: string; bat: string; }'.
+!!! error TS2345:           Property 'bat' is missing in type 'Bar & Foo'.
+        fooBat(y);  // Error
+               ~
+!!! error TS2345: Argument of type 'Extract<T, Foo & Bar>' is not assignable to parameter of type '{ foo: string; bat: string; }'.
+!!! error TS2345:   Type 'Foo & Bar & T' is not assignable to type '{ foo: string; bat: string; }'.
+!!! error TS2345:     Property 'bat' is missing in type 'Foo & Bar'.
+        fooBat(z);  // Error
+               ~
+!!! error TS2345: Argument of type 'Extract2<T, Foo, Bar>' is not assignable to parameter of type '{ foo: string; bat: string; }'.
+!!! error TS2345:   Type 'T extends Bar ? T : never' is not assignable to type '{ foo: string; bat: string; }'.
+!!! error TS2345:     Type 'Bar & Foo & T' is not assignable to type '{ foo: string; bat: string; }'.
+    }
+    
     // Repros from #22860
 
     class Opt<T> {
@@ -87,4 +164,16 @@ tests/cases/conformance/types/conditional/conditionalTypes2.ts(25,5): error TS23
         bat: B1<B1<T>>;
         boom: T extends any ? true : true
     }
+    
+    // Repro from #22899
+    
+    declare function toString1(value: object | Function): string ;
+    declare function toString2(value: Function): string ;
+    
+    function foo<T>(value: T) {
+        if (isFunction(value)) {
+            toString1(value);
+            toString2(value);
+        }
+    }
 

tests/baselines/reference/conditionalTypes2.js

@@ -26,6 +26,56 @@ function f3<A, B extends A>(a: Invariant<A>, b: Invariant<B>) {
     b = a;  // Error
 }
 
+// Extract<T, Function> is a T that is known to be a Function
+function isFunction<T>(value: T): value is Extract<T, Function> {
+    return typeof value === "function";
+}
+
+function getFunction<T>(item: T) {
+    if (isFunction(item)) {
+        return item;
+    }
+    throw new Error();
+}
+
+function f10<T>(x: T) {
+    if (isFunction(x)) {
+        const f: Function = x;
+        const t: T = x;
+    }
+}
+
+function f11(x: string | (() => string) | undefined) {
+    if (isFunction(x)) {
+        x();
+    }
+}
+
+function f12(x: string | (() => string) | undefined) {
+    const f = getFunction(x);  // () => string
+    f();
+}
+
+type Foo = { foo: string };
+type Bar = { bar: string };
+
+declare function fooBar(x: { foo: string, bar: string }): void;
+declare function fooBat(x: { foo: string, bat: string }): void;
+
+type Extract2<T, U, V> = T extends U ? T extends V ? T : never : never;
+
+function f20<T>(x: Extract<Extract<T, Foo>, Bar>, y: Extract<T, Foo & Bar>, z: Extract2<T, Foo, Bar>) {
+    fooBar(x);
+    fooBar(y);
+    fooBar(z);
+}
+
+function f21<T>(x: Extract<Extract<T, Foo>, Bar>, y: Extract<T, Foo & Bar>, z: Extract2<T, Foo, Bar>) {
+    fooBat(x);  // Error
+    fooBat(y);  // Error
+    fooBat(z);  // Error
+}
+
 // Repros from #22860
 
 class Opt<T> {
@@ -57,6 +107,18 @@ interface B1<T> extends A1<T> {
     bat: B1<B1<T>>;
     boom: T extends any ? true : true
 }
+
+// Repro from #22899
+
+declare function toString1(value: object | Function): string ;
+declare function toString2(value: Function): string ;
+
+function foo<T>(value: T) {
+    if (isFunction(value)) {
+        toString1(value);
+        toString2(value);
+    }
+}
 
 
 //// [conditionalTypes2.js]
@@ -73,6 +135,41 @@ function f3(a, b) {
     a = b; // Error
     b = a; // Error
 }
+// Extract<T, Function> is a T that is known to be a Function
+function isFunction(value) {
+    return typeof value === "function";
+}
+function getFunction(item) {
+    if (isFunction(item)) {
+        return item;
+    }
+    throw new Error();
+}
+function f10(x) {
+    if (isFunction(x)) {
+        var f = x;
+        var t = x;
+    }
+}
+function f11(x) {
+    if (isFunction(x)) {
+        x();
+    }
+}
+function f12(x) {
+    var f = getFunction(x); // () => string
+    f();
+}
+function f20(x, y, z) {
+    fooBar(x);
+    fooBar(y);
+    fooBar(z);
+}
+function f21(x, y, z) {
+    fooBat(x); // Error
+    fooBat(y); // Error
+    fooBat(z); // Error
+}
 // Repros from #22860
 var Opt = /** @class */ (function () {
     function Opt() {
@@ -93,6 +190,12 @@ var Vector = /** @class */ (function () {
     };
     return Vector;
 }());
+function foo(value) {
+    if (isFunction(value)) {
+        toString1(value);
+        toString2(value);
+    }
+}
 
 
 //// [conditionalTypes2.d.ts]
@@ -108,6 +211,28 @@ interface Invariant<T> {
 declare function f1<A, B extends A>(a: Covariant<A>, b: Covariant<B>): void;
 declare function f2<A, B extends A>(a: Contravariant<A>, b: Contravariant<B>): void;
 declare function f3<A, B extends A>(a: Invariant<A>, b: Invariant<B>): void;
+declare function isFunction<T>(value: T): value is Extract<T, Function>;
+declare function getFunction<T>(item: T): Extract<T, Function>;
+declare function f10<T>(x: T): void;
+declare function f11(x: string | (() => string) | undefined): void;
+declare function f12(x: string | (() => string) | undefined): void;
+declare type Foo = {
+    foo: string;
+};
+declare type Bar = {
+    bar: string;
+};
+declare function fooBar(x: {
+    foo: string;
+    bar: string;
+}): void;
+declare function fooBat(x: {
+    foo: string;
+    bat: string;
+}): void;
+declare type Extract2<T, U, V> = T extends U ? T extends V ? T : never : never;
+declare function f20<T>(x: Extract<Extract<T, Foo>, Bar>, y: Extract<T, Foo & Bar>, z: Extract2<T, Foo, Bar>): void;
+declare function f21<T>(x: Extract<Extract<T, Foo>, Bar>, y: Extract<T, Foo & Bar>, z: Extract2<T, Foo, Bar>): void;
 declare class Opt<T> {
     toVector(): Vector<T>;
 }
@@ -126,3 +251,6 @@ interface B1<T> extends A1<T> {
     bat: B1<B1<T>>;
     boom: T extends any ? true : true;
 }
+declare function toString1(value: object | Function): string;
+declare function toString2(value: Function): string;
+declare function foo<T>(value: T): void;