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

@@ -2710,7 +2710,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;
@@ -3520,7 +3530,14 @@ 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.
+        // (See https://github.com/Microsoft/TypeScript/pull/17600#discussion_r132059173)
+        resolvedTypePredicate: TypePredicate | undefined;
         /* @internal */
         minArgumentCount: number;           // Number of non-optional parameters
         /* @internal */
@@ -3540,8 +3557,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

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

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/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/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;
+    }
+}

tests/baselines/reference/typePredicatesInUnion_noMatch.symbols

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

tests/baselines/reference/typePredicatesInUnion_noMatch.types

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

tests/cases/compiler/typeInferenceTypePredicate.ts

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

tests/cases/compiler/typePredicatesInUnion.ts

@@ -0,0 +1,14 @@
+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;
+    }
+}

tests/cases/compiler/typePredicatesInUnion_noMatch.ts

@@ -0,0 +1,15 @@
+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;
+    }
+}