Lazily compute signature type predicates

src/compiler/symbolWalker.ts

@@ -2,6 +2,7 @@
 namespace ts {
     export function createGetSymbolWalker(
         getRestTypeOfSignature: (sig: Signature) => Type,
+        getTypePredicateOfSignature: (sig: Signature) => TypePredicate | undefined,
         getReturnTypeOfSignature: (sig: Signature) => Type,
         getBaseTypes: (type: Type) => Type[],
         resolveStructuredTypeMembers: (type: ObjectType) => ResolvedType,
@@ -117,8 +118,9 @@ namespace ts {
             }
 
             function visitSignature(signature: Signature): void {
-                if (signature.typePredicate) {
-                    visitType(signature.typePredicate.type);
+                const typePredicate = getTypePredicateOfSignature(signature);
+                if (typePredicate) {
+                    visitType(typePredicate.type);
                 }
                 forEach(signature.typeParameters, visitType);
 

src/compiler/types.ts

@@ -2787,7 +2787,17 @@ namespace ts {
         /* @internal */ createPromiseType(type: Type): Type;
 
         /* @internal */ createAnonymousType(symbol: Symbol, members: SymbolTable, callSignatures: Signature[], constructSignatures: Signature[], stringIndexInfo: IndexInfo, numberIndexInfo: IndexInfo): Type;
-        /* @internal */ createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[], thisParameter: Symbol | undefined, parameters: Symbol[], resolvedReturnType: Type, typePredicate: TypePredicate, minArgumentCount: number, hasRestParameter: boolean, hasLiteralTypes: boolean): Signature;
+        /* @internal */ createSignature(
+            declaration: SignatureDeclaration,
+            typeParameters: TypeParameter[],
+            thisParameter: Symbol | undefined,
+            parameters: Symbol[],
+            resolvedReturnType: Type,
+            typePredicate: TypePredicate | undefined,
+            minArgumentCount: number,
+            hasRestParameter: boolean,
+            hasLiteralTypes: boolean,
+        ): Signature;
         /* @internal */ createSymbol(flags: SymbolFlags, name: __String): TransientSymbol;
         /* @internal */ createIndexInfo(type: Type, isReadonly: boolean, declaration?: SignatureDeclaration): IndexInfo;
         /* @internal */ isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
@@ -3620,7 +3630,13 @@ namespace ts {
         /* @internal */
         thisParameter?: Symbol;             // symbol of this-type parameter
         /* @internal */
-        resolvedReturnType: Type;           // Resolved return type
+        // See comment in `instantiateSignature` for why these are set lazily.
+        resolvedReturnType: Type | undefined; // Lazily set by `getReturnTypeOfSignature`.
+        /* @internal */
+        // Lazily set by `getTypePredicateOfSignature`.
+        // `undefined` indicates a type predicate that has not yet been computed.
+        // Uses a special `noTypePredicate` sentinel value to indicate that there is no type predicate. This looks like a TypePredicate at runtime to avoid polymorphism.
+        resolvedTypePredicate: TypePredicate | undefined;
         /* @internal */
         minArgumentCount: number;           // Number of non-optional parameters
         /* @internal */
@@ -3640,8 +3656,6 @@ namespace ts {
         /* @internal */
         isolatedSignatureType?: ObjectType; // A manufactured type that just contains the signature for purposes of signature comparison
         /* @internal */
-        typePredicate?: TypePredicate;
-        /* @internal */
         instantiations?: Map<Signature>;    // Generic signature instantiation cache
     }
 

src/services/services.ts

@@ -481,6 +481,7 @@ namespace ts {
         parameters: Symbol[];
         thisParameter: Symbol;
         resolvedReturnType: Type;
+        resolvedTypePredicate: TypePredicate | undefined;
         minTypeArgumentCount: number;
         minArgumentCount: number;
         hasRestParameter: boolean;

tests/baselines/reference/fixSignatureCaching.types

@@ -866,9 +866,9 @@ define(function () {
 >'UnknownMobile' : "UnknownMobile"
 
     isArray = ('isArray' in Array) ?
->isArray = ('isArray' in Array) ?        Array.isArray : function (value) { return Object.prototype.toString.call(value) === '[object Array]'; } : (arg: any) => arg is any[]
+>isArray = ('isArray' in Array) ?        Array.isArray : function (value) { return Object.prototype.toString.call(value) === '[object Array]'; } : (value: any) => boolean
 >isArray : any
->('isArray' in Array) ?        Array.isArray : function (value) { return Object.prototype.toString.call(value) === '[object Array]'; } : (arg: any) => arg is any[]
+>('isArray' in Array) ?        Array.isArray : function (value) { return Object.prototype.toString.call(value) === '[object Array]'; } : (value: any) => boolean
 >('isArray' in Array) : boolean
 >'isArray' in Array : boolean
 >'isArray' : "isArray"

tests/baselines/reference/typeInferenceTypePredicate.js

@@ -0,0 +1,9 @@
+//// [typeInferenceTypePredicate.ts]
+declare function f<T>(predicate: (x: {}) => x is T): T;
+// 'res' should be of type 'number'.
+const res = f((n): n is number => true);
+
+
+//// [typeInferenceTypePredicate.js]
+// 'res' should be of type 'number'.
+var res = f(function (n) { return true; });

tests/baselines/reference/typeInferenceTypePredicate.symbols

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/typeInferenceTypePredicate.ts ===
+declare function f<T>(predicate: (x: {}) => x is T): T;
+>f : Symbol(f, Decl(typeInferenceTypePredicate.ts, 0, 0))
+>T : Symbol(T, Decl(typeInferenceTypePredicate.ts, 0, 19))
+>predicate : Symbol(predicate, Decl(typeInferenceTypePredicate.ts, 0, 22))
+>x : Symbol(x, Decl(typeInferenceTypePredicate.ts, 0, 34))
+>x : Symbol(x, Decl(typeInferenceTypePredicate.ts, 0, 34))
+>T : Symbol(T, Decl(typeInferenceTypePredicate.ts, 0, 19))
+>T : Symbol(T, Decl(typeInferenceTypePredicate.ts, 0, 19))
+
+// 'res' should be of type 'number'.
+const res = f((n): n is number => true);
+>res : Symbol(res, Decl(typeInferenceTypePredicate.ts, 2, 5))
+>f : Symbol(f, Decl(typeInferenceTypePredicate.ts, 0, 0))
+>n : Symbol(n, Decl(typeInferenceTypePredicate.ts, 2, 15))
+>n : Symbol(n, Decl(typeInferenceTypePredicate.ts, 2, 15))
+

tests/baselines/reference/typeInferenceTypePredicate.types

@@ -0,0 +1,20 @@
+=== tests/cases/compiler/typeInferenceTypePredicate.ts ===
+declare function f<T>(predicate: (x: {}) => x is T): T;
+>f : <T>(predicate: (x: {}) => x is T) => T
+>T : T
+>predicate : (x: {}) => x is T
+>x : {}
+>x : any
+>T : T
+>T : T
+
+// 'res' should be of type 'number'.
+const res = f((n): n is number => true);
+>res : number
+>f((n): n is number => true) : number
+>f : <T>(predicate: (x: {}) => x is T) => T
+>(n): n is number => true : (n: {}) => n is number
+>n : {}
+>n : any
+>true : true
+

tests/baselines/reference/typeInferenceTypePredicate2.js

@@ -0,0 +1,10 @@
+//// [typeInferenceTypePredicate2.ts]
+[true, true, false, null]
+    .filter((thing): thing is boolean => thing !== null)
+    .map(thing => thing.toString());
+
+
+//// [typeInferenceTypePredicate2.js]
+[true, true, false, null]
+    .filter(function (thing) { return thing !== null; })
+    .map(function (thing) { return thing.toString(); });

tests/baselines/reference/typeInferenceTypePredicate2.symbols

@@ -0,0 +1,18 @@
+=== tests/cases/compiler/typeInferenceTypePredicate2.ts ===
+[true, true, false, null]
+>[true, true, false, null]    .filter((thing): thing is boolean => thing !== null)    .map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>[true, true, false, null]    .filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    .filter((thing): thing is boolean => thing !== null)
+>filter : Symbol(Array.filter, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>thing : Symbol(thing, Decl(typeInferenceTypePredicate2.ts, 1, 13))
+>thing : Symbol(thing, Decl(typeInferenceTypePredicate2.ts, 1, 13))
+>thing : Symbol(thing, Decl(typeInferenceTypePredicate2.ts, 1, 13))
+
+    .map(thing => thing.toString());
+>map : Symbol(Array.map, Decl(lib.d.ts, --, --))
+>thing : Symbol(thing, Decl(typeInferenceTypePredicate2.ts, 2, 9))
+>thing.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
+>thing : Symbol(thing, Decl(typeInferenceTypePredicate2.ts, 2, 9))
+>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
+

tests/baselines/reference/typeInferenceTypePredicate2.types

@@ -0,0 +1,30 @@
+=== tests/cases/compiler/typeInferenceTypePredicate2.ts ===
+[true, true, false, null]
+>[true, true, false, null]    .filter((thing): thing is boolean => thing !== null)    .map(thing => thing.toString()) : string[]
+>[true, true, false, null]    .filter((thing): thing is boolean => thing !== null)    .map : <U>(callbackfn: (value: boolean, index: number, array: boolean[]) => U, thisArg?: any) => U[]
+>[true, true, false, null]    .filter((thing): thing is boolean => thing !== null) : boolean[]
+>[true, true, false, null]    .filter : { <S extends boolean>(callbackfn: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: boolean, index: number, array: boolean[]) => any, thisArg?: any): boolean[]; }
+>[true, true, false, null] : boolean[]
+>true : true
+>true : true
+>false : false
+>null : null
+
+    .filter((thing): thing is boolean => thing !== null)
+>filter : { <S extends boolean>(callbackfn: (value: boolean, index: number, array: boolean[]) => value is S, thisArg?: any): S[]; (callbackfn: (value: boolean, index: number, array: boolean[]) => any, thisArg?: any): boolean[]; }
+>(thing): thing is boolean => thing !== null : (thing: boolean) => thing is boolean
+>thing : boolean
+>thing : any
+>thing !== null : boolean
+>thing : boolean
+>null : null
+
+    .map(thing => thing.toString());
+>map : <U>(callbackfn: (value: boolean, index: number, array: boolean[]) => U, thisArg?: any) => U[]
+>thing => thing.toString() : (thing: boolean) => string
+>thing : boolean
+>thing.toString() : string
+>thing.toString : () => string
+>thing : boolean
+>toString : () => string
+

tests/baselines/reference/typePredicatesInUnion.js

@@ -0,0 +1,23 @@
+//// [typePredicatesInUnion.ts]
+interface A {
+    pred(x: {}): x is boolean;
+}
+interface B {
+    pred(x: {}): x is string;
+}
+
+type Or = A | B;
+
+function f(o: Or, x: {}) {
+    if (o.pred(x)) {
+        x;
+    }
+}
+
+
+//// [typePredicatesInUnion.js]
+function f(o, x) {
+    if (o.pred(x)) {
+        x;
+    }
+}

tests/baselines/reference/typePredicatesInUnion.symbols

@@ -0,0 +1,40 @@
+=== tests/cases/compiler/typePredicatesInUnion.ts ===
+interface A {
+>A : Symbol(A, Decl(typePredicatesInUnion.ts, 0, 0))
+
+    pred(x: {}): x is boolean;
+>pred : Symbol(A.pred, Decl(typePredicatesInUnion.ts, 0, 13))
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 1, 9))
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 1, 9))
+}
+interface B {
+>B : Symbol(B, Decl(typePredicatesInUnion.ts, 2, 1))
+
+    pred(x: {}): x is string;
+>pred : Symbol(B.pred, Decl(typePredicatesInUnion.ts, 3, 13))
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 4, 9))
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 4, 9))
+}
+
+type Or = A | B;
+>Or : Symbol(Or, Decl(typePredicatesInUnion.ts, 5, 1))
+>A : Symbol(A, Decl(typePredicatesInUnion.ts, 0, 0))
+>B : Symbol(B, Decl(typePredicatesInUnion.ts, 2, 1))
+
+function f(o: Or, x: {}) {
+>f : Symbol(f, Decl(typePredicatesInUnion.ts, 7, 16))
+>o : Symbol(o, Decl(typePredicatesInUnion.ts, 9, 11))
+>Or : Symbol(Or, Decl(typePredicatesInUnion.ts, 5, 1))
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 9, 17))
+
+    if (o.pred(x)) {
+>o.pred : Symbol(pred, Decl(typePredicatesInUnion.ts, 0, 13), Decl(typePredicatesInUnion.ts, 3, 13))
+>o : Symbol(o, Decl(typePredicatesInUnion.ts, 9, 11))
+>pred : Symbol(pred, Decl(typePredicatesInUnion.ts, 0, 13), Decl(typePredicatesInUnion.ts, 3, 13))
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 9, 17))
+
+        x;
+>x : Symbol(x, Decl(typePredicatesInUnion.ts, 9, 17))
+    }
+}
+

tests/baselines/reference/typePredicatesInUnion.types

@@ -0,0 +1,41 @@
+=== tests/cases/compiler/typePredicatesInUnion.ts ===
+interface A {
+>A : A
+
+    pred(x: {}): x is boolean;
+>pred : (x: {}) => x is boolean
+>x : {}
+>x : any
+}
+interface B {
+>B : B
+
+    pred(x: {}): x is string;
+>pred : (x: {}) => x is string
+>x : {}
+>x : any
+}
+
+type Or = A | B;
+>Or : Or
+>A : A
+>B : B
+
+function f(o: Or, x: {}) {
+>f : (o: Or, x: {}) => void
+>o : Or
+>Or : Or
+>x : {}
+
+    if (o.pred(x)) {
+>o.pred(x) : boolean
+>o.pred : ((x: {}) => x is boolean) | ((x: {}) => x is string)
+>o : Or
+>pred : ((x: {}) => x is boolean) | ((x: {}) => x is string)
+>x : {}
+
+        x;
+>x : string | boolean
+    }
+}
+

tests/baselines/reference/typePredicatesInUnion2.js

@@ -0,0 +1,11 @@
+//// [typePredicatesInUnion2.ts]
+declare function isString(x: any): x is string;
+declare function isNumber(x: any): x is number;
+declare function f(p: typeof isString | typeof isNumber): void;
+f(isString);
+f(isNumber);
+
+
+//// [typePredicatesInUnion2.js]
+f(isString);
+f(isNumber);

tests/baselines/reference/typePredicatesInUnion2.symbols

@@ -0,0 +1,25 @@
+=== tests/cases/compiler/typePredicatesInUnion2.ts ===
+declare function isString(x: any): x is string;
+>isString : Symbol(isString, Decl(typePredicatesInUnion2.ts, 0, 0))
+>x : Symbol(x, Decl(typePredicatesInUnion2.ts, 0, 26))
+>x : Symbol(x, Decl(typePredicatesInUnion2.ts, 0, 26))
+
+declare function isNumber(x: any): x is number;
+>isNumber : Symbol(isNumber, Decl(typePredicatesInUnion2.ts, 0, 47))
+>x : Symbol(x, Decl(typePredicatesInUnion2.ts, 1, 26))
+>x : Symbol(x, Decl(typePredicatesInUnion2.ts, 1, 26))
+
+declare function f(p: typeof isString | typeof isNumber): void;
+>f : Symbol(f, Decl(typePredicatesInUnion2.ts, 1, 47))
+>p : Symbol(p, Decl(typePredicatesInUnion2.ts, 2, 19))
+>isString : Symbol(isString, Decl(typePredicatesInUnion2.ts, 0, 0))
+>isNumber : Symbol(isNumber, Decl(typePredicatesInUnion2.ts, 0, 47))
+
+f(isString);
+>f : Symbol(f, Decl(typePredicatesInUnion2.ts, 1, 47))
+>isString : Symbol(isString, Decl(typePredicatesInUnion2.ts, 0, 0))
+
+f(isNumber);
+>f : Symbol(f, Decl(typePredicatesInUnion2.ts, 1, 47))
+>isNumber : Symbol(isNumber, Decl(typePredicatesInUnion2.ts, 0, 47))
+

tests/baselines/reference/typePredicatesInUnion2.types

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/typePredicatesInUnion2.ts ===
+declare function isString(x: any): x is string;
+>isString : (x: any) => x is string
+>x : any
+>x : any
+
+declare function isNumber(x: any): x is number;
+>isNumber : (x: any) => x is number
+>x : any
+>x : any
+
+declare function f(p: typeof isString | typeof isNumber): void;
+>f : (p: ((x: any) => x is string) | ((x: any) => x is number)) => void
+>p : ((x: any) => x is string) | ((x: any) => x is number)
+>isString : (x: any) => x is string
+>isNumber : (x: any) => x is number
+
+f(isString);
+>f(isString) : void
+>f : (p: ((x: any) => x is string) | ((x: any) => x is number)) => void
+>isString : (x: any) => x is string
+
+f(isNumber);
+>f(isNumber) : void
+>f : (p: ((x: any) => x is string) | ((x: any) => x is number)) => void
+>isNumber : (x: any) => x is number
+

tests/baselines/reference/typePredicatesInUnion_noMatch.js

@@ -0,0 +1,25 @@
+//// [typePredicatesInUnion_noMatch.ts]
+interface A {
+    pred(x: {}, y: {}): x is boolean;
+}
+interface B {
+    pred(x: {}, y: {}): y is string;
+}
+
+type Or = A | B;
+
+function f(o: Or, x: {}, y: {}) {
+    if (o.pred(x, y)) {
+        x;
+        y;
+    }
+}
+
+
+//// [typePredicatesInUnion_noMatch.js]
+function f(o, x, y) {
+    if (o.pred(x, y)) {
+        x;
+        y;
+    }
+}