From e7cbfc41e5afbaa68bdc30e2865acd3a7b0b44e8 Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Sat, 17 Aug 2019 07:05:49 -0700
Subject: [PATCH] Update API to be backwards compatible

---
 src/compiler/checker.ts |  4 ++--
 src/compiler/factory.ts | 17 +++++++++++++----
 src/compiler/visitor.ts |  2 +-
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index c919bb986e4..0af56d7f172 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4235,7 +4235,7 @@ namespace ts {
                         setEmitFlags(createIdentifier(typePredicate.parameterName), EmitFlags.NoAsciiEscaping) :
                         createThisTypeNode();
                     const typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
-                    returnTypeNode = createTypePredicateNode(assertsModifier, parameterName, typeNode);
+                    returnTypeNode = createTypePredicateNodeWithModifier(assertsModifier, parameterName, typeNode);
                 }
                 else {
                     const returnType = getReturnTypeOfSignature(signature);
@@ -4703,7 +4703,7 @@ namespace ts {
             return writer ? typePredicateToStringWorker(writer).getText() : usingSingleLineStringWriter(typePredicateToStringWorker);
 
             function typePredicateToStringWorker(writer: EmitTextWriter) {
-                const predicate = createTypePredicateNode(
+                const predicate = createTypePredicateNodeWithModifier(
                     typePredicate.kind === TypePredicateKind.AssertsThis || typePredicate.kind === TypePredicateKind.AssertsIdentifier ? createToken(SyntaxKind.AssertsKeyword) : undefined,
                     typePredicate.kind === TypePredicateKind.Identifier || typePredicate.kind === TypePredicateKind.AssertsIdentifier ? createIdentifier(typePredicate.parameterName) : createThisTypeNode(),
                     typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | NodeBuilderFlags.IgnoreErrors | NodeBuilderFlags.WriteTypeParametersInQualifiedName)! // TODO: GH#18217
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 9a484681acf..3118b9a2efe 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -667,7 +667,11 @@ namespace ts {
         return <KeywordTypeNode>createSynthesizedNode(kind);
     }
 
-    export function createTypePredicateNode(assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined) {
+    export function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined) {
+        return createTypePredicateNodeWithModifier(/*assertsModifier*/ undefined, parameterName, type);
+    }
+
+    export function createTypePredicateNodeWithModifier(assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined) {
         const node = createSynthesizedNode(SyntaxKind.TypePredicate) as TypePredicateNode;
         node.assertsModifier = assertsModifier;
         node.parameterName = asName(parameterName);
@@ -675,10 +679,15 @@ namespace ts {
         return node;
     }
 
-    export function updateTypePredicateNode(node: TypePredicateNode, assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) {
-        return node.parameterName !== parameterName
+    export function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) {
+        return updateTypePredicateNodeWithModifier(node, node.assertsModifier, parameterName, type);
+    }
+
+    export function updateTypePredicateNodeWithModifier(node: TypePredicateNode, assertsModifier: AssertsToken | undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined) {
+        return node.assertsModifier !== assertsModifier
+            || node.parameterName !== parameterName
             || node.type !== type
-            ? updateNode(createTypePredicateNode(assertsModifier, parameterName, type), node)
+            ? updateNode(createTypePredicateNodeWithModifier(assertsModifier, parameterName, type), node)
             : node;
     }
 
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index aa497511f78..266b794438b 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -339,7 +339,7 @@ namespace ts {
             // Types
 
             case SyntaxKind.TypePredicate:
-                return updateTypePredicateNode(<TypePredicateNode>node,
+                return updateTypePredicateNodeWithModifier(<TypePredicateNode>node,
                     visitNode((<TypePredicateNode>node).assertsModifier, visitor),
                     visitNode((<TypePredicateNode>node).parameterName, visitor),
                     visitNode((<TypePredicateNode>node).type, visitor, isTypeNode));