Lazily compute signature type predicates (#17600)

* Lazily compute signature type predicates

* Use an instance of IdentifierTypePredicate to represent an unresolved type predicate

* Simplify `getMaybeTypePredicate`

* Invert representation of `resolvedTypePredicate`

* Remove `__unresolvedTypePredicate` type and remember to use `noTypePredicate` instead of `undefined` when in all `createSignature` calls

* Fix style of getTypePredicateOfSignature

* Use in createGetSymbolWalker

* Fix bugs for unions of type predicates

* Code review

* Make noTypePredicate purely an implementation detail of getTypePredictateOfSignature

* Add test

* Add test for #19642

* Add test with reversed order

Author: Andy

src/compiler/checker.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/symbolWalker.ts

@@ -2791,7 +2791,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;
@@ -3638,7 +3648,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 */
@@ -3658,8 +3674,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/compiler/types.ts

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

src/services/services.ts

@@ -297,6 +297,9 @@ define(function () {
 
     isArray = ('isArray' in Array) ?
         Array.isArray : function (value) { return Object.prototype.toString.call(value) === '[object Array]'; };
+    isArray = 'isArray' in Array
+        ? function (value) { return Object.prototype.toString.call(value) === '[object Array]'; }
+        : Array.isArray;
 
     function equalIC(a, b) {
         return a != null && b != null && a.toLowerCase() === b.toLowerCase();
@@ -967,7 +970,7 @@ define(function () {
 
     // should not be replaced by a completely new object - just overwrite existing methods
     MobileDetect._impl = impl;
-    
+
     MobileDetect.version = '1.3.3 2016-07-31';
 
     return MobileDetect;
@@ -1276,6 +1279,9 @@ define(function () {
         impl.FALLBACK_MOBILE = 'UnknownMobile';
         isArray = ('isArray' in Array) ?
             Array.isArray : function (value) { return Object.prototype.toString.call(value) === '[object Array]'; };
+        isArray = 'isArray' in Array
+            ? function (value) { return Object.prototype.toString.call(value) === '[object Array]'; }
+            : Array.isArray;
         function equalIC(a, b) {
             return a != null && b != null && a.toLowerCase() === b.toLowerCase();
         }