Lazily compute signature type predicates

src/compiler/checker.ts

@@ -280,6 +280,11 @@ namespace ts {
         const resolvingSignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
         const silentNeverSignature = createSignature(undefined, undefined, undefined, emptyArray, silentNeverType, /*typePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);
 
+        const unresolvedTypePredicate: void & { __unresolvedTypePredicate: void } = (() => {
+            const tp: IdentifierTypePredicate = { kind: TypePredicateKind.Identifier, parameterName: "<<unresolved>>", parameterIndex: 0, type: anyType };
+            return tp as any;
+        })();
+
         const enumNumberIndexInfo = createIndexInfo(stringType, /*isReadonly*/ true);
         const jsObjectLiteralIndexInfo = createIndexInfo(anyType, /*isReadonly*/ false);
 
@@ -2826,8 +2831,8 @@ namespace ts {
                     parameters.unshift(thisParameter);
                 }
                 let returnTypeNode: TypeNode;
-                if (signature.typePredicate) {
-                    const typePredicate = signature.typePredicate;
+                const typePredicate = getTypePredicateOfSignature(signature);
+                if (typePredicate) {
                     const parameterName = typePredicate.kind === TypePredicateKind.Identifier ?
                         setEmitFlags(createIdentifier((<IdentifierTypePredicate>typePredicate).parameterName), EmitFlags.NoAsciiEscaping) :
                         createThisTypeNode();
@@ -3773,8 +3778,9 @@ namespace ts {
                 }
                 writeSpace(writer);
 
-                if (signature.typePredicate) {
-                    buildTypePredicateDisplay(signature.typePredicate, writer, enclosingDeclaration, flags, symbolStack);
+                const typePredicate = getTypePredicateOfSignature(signature);
+                if (typePredicate) {
+                    buildTypePredicateDisplay(typePredicate, writer, enclosingDeclaration, flags, symbolStack);
                 }
                 else {
                     buildTypeDisplay(returnType, writer, enclosingDeclaration, flags, symbolStack);
@@ -5431,14 +5437,14 @@ namespace ts {
         }
 
         function createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[], thisParameter: Symbol | undefined, parameters: Symbol[],
-            resolvedReturnType: Type, typePredicate: TypePredicate, minArgumentCount: number, hasRestParameter: boolean, hasLiteralTypes: boolean): Signature {
+            resolvedReturnType: Type | undefined, resolvedTypePredicate: TypePredicate | void & { __unresolvedTypePredicate: void } | undefined, minArgumentCount: number, hasRestParameter: boolean, hasLiteralTypes: boolean): Signature {
             const sig = new Signature(checker);
             sig.declaration = declaration;
             sig.typeParameters = typeParameters;
             sig.parameters = parameters;
             sig.thisParameter = thisParameter;
             sig.resolvedReturnType = resolvedReturnType;
-            sig.typePredicate = typePredicate;
+            sig.resolvedTypePredicate = resolvedTypePredicate;
             sig.minArgumentCount = minArgumentCount;
             sig.hasRestParameter = hasRestParameter;
             sig.hasLiteralTypes = hasLiteralTypes;
@@ -5447,7 +5453,7 @@ namespace ts {
 
         function cloneSignature(sig: Signature): Signature {
             return createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, sig.resolvedReturnType,
-                sig.typePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasLiteralTypes);
+                sig.resolvedTypePredicate, sig.minArgumentCount, sig.hasRestParameter, sig.hasLiteralTypes);
         }
 
         function getDefaultConstructSignatures(classType: InterfaceType): Signature[] {
@@ -6543,6 +6549,17 @@ namespace ts {
             }
         }
 
+        function signatureHasTypePredicate(signature: Signature): boolean {
+            return signature.resolvedTypePredicate !== undefined;
+        }
+
+        function getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined {
+            if (signature.resolvedTypePredicate === unresolvedTypePredicate) {
+                signature.resolvedTypePredicate = instantiateTypePredicate(getTypePredicateOfSignature(signature.target), signature.mapper);
+            }
+            return signature.resolvedTypePredicate as TypePredicate | undefined;
+        }
+
         function getReturnTypeOfSignature(signature: Signature): Type {
             if (!signature.resolvedReturnType) {
                 if (!pushTypeResolution(signature, TypeSystemPropertyName.ResolvedReturnType)) {
@@ -8102,7 +8119,7 @@ namespace ts {
             return result;
         }
 
-        function cloneTypePredicate(predicate: TypePredicate, mapper: TypeMapper): ThisTypePredicate | IdentifierTypePredicate {
+        function instantiateTypePredicate(predicate: TypePredicate, mapper: TypeMapper): ThisTypePredicate | IdentifierTypePredicate {
             if (isIdentifierTypePredicate(predicate)) {
                 return {
                     kind: TypePredicateKind.Identifier,
@@ -8121,7 +8138,6 @@ namespace ts {
 
         function instantiateSignature(signature: Signature, mapper: TypeMapper, eraseTypeParameters?: boolean): Signature {
             let freshTypeParameters: TypeParameter[];
-            let freshTypePredicate: TypePredicate;
             if (signature.typeParameters && !eraseTypeParameters) {
                 // First create a fresh set of type parameters, then include a mapping from the old to the
                 // new type parameters in the mapper function. Finally store this mapper in the new type
@@ -8132,14 +8148,14 @@ namespace ts {
                     tp.mapper = mapper;
                 }
             }
-            if (signature.typePredicate) {
-                freshTypePredicate = cloneTypePredicate(signature.typePredicate, mapper);
-            }
+            // Don't compute resolvedReturnType and resolvedTypePredicate now,
+            // because using `mapper` now could trigger inferences to become fixed. (See `createInferenceContext`.)
+            // See GH#17600.
             const result = createSignature(signature.declaration, freshTypeParameters,
                 signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper),
                 instantiateList(signature.parameters, mapper, instantiateSymbol),
                 /*resolvedReturnType*/ undefined,
-                freshTypePredicate,
+                /*resolvedTypePredicate*/ signatureHasTypePredicate(signature) ? unresolvedTypePredicate : undefined,
                 signature.minArgumentCount, signature.hasRestParameter, signature.hasLiteralTypes);
             result.target = signature;
             result.mapper = mapper;
@@ -8566,7 +8582,7 @@ namespace ts {
                 // similar to return values, callback parameters are output positions. This means that a Promise<T>,
                 // where T is used only in callback parameter positions, will be co-variant (as opposed to bi-variant)
                 // with respect to T.
-                const callbacks = sourceSig && targetSig && !sourceSig.typePredicate && !targetSig.typePredicate &&
+                const callbacks = sourceSig && targetSig && !signatureHasTypePredicate(sourceSig) && !signatureHasTypePredicate(targetSig) &&
                     (getFalsyFlags(sourceType) & TypeFlags.Nullable) === (getFalsyFlags(targetType) & TypeFlags.Nullable);
                 const related = callbacks ?
                     compareSignaturesRelated(targetSig, sourceSig, /*checkAsCallback*/ true, /*ignoreReturnTypes*/ false, reportErrors, errorReporter, compareTypes) :
@@ -8590,11 +8606,13 @@ namespace ts {
                 const sourceReturnType = getReturnTypeOfSignature(source);
 
                 // The following block preserves behavior forbidding boolean returning functions from being assignable to type guard returning functions
-                if (target.typePredicate) {
-                    if (source.typePredicate) {
-                        result &= compareTypePredicateRelatedTo(source.typePredicate, target.typePredicate, reportErrors, errorReporter, compareTypes);
+                const targetTypePredicate = getTypePredicateOfSignature(target);
+                if (targetTypePredicate) {
+                    const sourceTypePredicate = getTypePredicateOfSignature(source);
+                    if (sourceTypePredicate) {
+                        result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors, errorReporter, compareTypes);
                     }
-                    else if (isIdentifierTypePredicate(target.typePredicate)) {
+                    else if (isIdentifierTypePredicate(targetTypePredicate)) {
                         if (reportErrors) {
                             errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
                         }
@@ -10639,8 +10657,10 @@ namespace ts {
             function inferFromSignature(source: Signature, target: Signature) {
                 forEachMatchingParameterType(source, target, inferFromTypes);
 
-                if (source.typePredicate && target.typePredicate && source.typePredicate.kind === target.typePredicate.kind) {
-                    inferFromTypes(source.typePredicate.type, target.typePredicate.type);
+                const sourceTypePredicate = getTypePredicateOfSignature(source);
+                const targetTypePredicate = getTypePredicateOfSignature(target);
+                if (sourceTypePredicate && targetTypePredicate && sourceTypePredicate.kind === targetTypePredicate.kind) {
+                    inferFromTypes(sourceTypePredicate.type, targetTypePredicate.type);
                 }
                 else {
                     inferFromTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
@@ -11403,7 +11423,7 @@ namespace ts {
                     const apparentType = getApparentType(funcType);
                     if (apparentType !== unknownType) {
                         const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
-                        return !!forEach(callSignatures, sig => sig.typePredicate);
+                        return some(callSignatures, sig => signatureHasTypePredicate(sig));
                     }
                 }
             }
@@ -11957,7 +11977,7 @@ namespace ts {
                     return type;
                 }
                 const signature = getResolvedSignature(callExpression);
-                const predicate = signature.typePredicate;
+                const predicate = getTypePredicateOfSignature(signature);
                 if (!predicate) {
                     return type;
                 }
@@ -18122,7 +18142,7 @@ namespace ts {
                 return;
             }
 
-            const typePredicate = getSignatureFromDeclaration(parent).typePredicate;
+            const typePredicate = getTypePredicateOfSignature(getSignatureFromDeclaration(parent));
             if (!typePredicate) {
                 return;
             }

src/compiler/types.ts

@@ -3369,7 +3369,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`.
+        // Unlike `resolvedReturnType`, `undefined` is a valid value, so we use a special sentinel TypePredicate-like instead to indicate a type predicate that must still be computed.
+        // (See https://github.com/Microsoft/TypeScript/pull/17600#discussion_r132059173)
+        // Uses a funny type signature to help ensure that this value is not accidentally used as a valid TypePredicate.
+        resolvedTypePredicate: TypePredicate | void & { __unresolvedTypePredicate: void } | undefined;
         /* @internal */
         minArgumentCount: number;           // Number of non-optional parameters
         /* @internal */
@@ -3387,8 +3394,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

@@ -440,6 +440,7 @@ namespace ts {
         parameters: Symbol[];
         thisParameter: Symbol;
         resolvedReturnType: Type;
+        resolvedTypePredicate: TypePredicate | void & { __unresolvedTypePredicate: void } | 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/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);