Revert type predicates to not have instanceof special casing

ahejlsberg · ahejlsberg · commit d2c0952801dc · 2016-11-14T17:13:49.000-08:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -9721,20 +9721,20 @@ namespace ts {
                 }
 
                 if (targetType) {
-                    return getNarrowedType(type, targetType, assumeTrue);
+                    return getNarrowedType(type, targetType, assumeTrue, isTypeInstanceOf);
                 }
 
                 return type;
             }
 
-            function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean) {
+            function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean, isRelated: (source: Type, target: Type) => boolean) {
                 if (!assumeTrue) {
-                    return filterType(type, t => !isTypeInstanceOf(t, candidate));
+                    return filterType(type, t => !isRelated(t, candidate));
                 }
                 // If the current type is a union type, remove all constituents that couldn't be instances of
                 // the candidate type. If one or more constituents remain, return a union of those.
                 if (type.flags & TypeFlags.Union) {
-                    const assignableType = filterType(type, t => isTypeInstanceOf(t, candidate));
+                    const assignableType = filterType(type, t => isRelated(t, candidate));
                     if (!(assignableType.flags & TypeFlags.Never)) {
                         return assignableType;
                     }
@@ -9770,7 +9770,7 @@ namespace ts {
                     const predicateArgument = callExpression.arguments[predicate.parameterIndex];
                     if (predicateArgument) {
                         if (isMatchingReference(reference, predicateArgument)) {
-                            return getNarrowedType(type, predicate.type, assumeTrue);
+                            return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
                         }
                         if (containsMatchingReference(reference, predicateArgument)) {
                             return declaredType;
@@ -9783,7 +9783,7 @@ namespace ts {
                         const accessExpression = invokedExpression as ElementAccessExpression | PropertyAccessExpression;
                         const possibleReference = skipParentheses(accessExpression.expression);
                         if (isMatchingReference(reference, possibleReference)) {
-                            return getNarrowedType(type, predicate.type, assumeTrue);
+                            return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);
                         }
                         if (containsMatchingReference(reference, possibleReference)) {
                             return declaredType;

Original file line number	Diff line number	Diff line change
`@@ -9721,20 +9721,20 @@ namespace ts {`
`9721`	`9721`	`}`
`9722`	`9722`
`9723`	`9723`	`if (targetType) {`
`9724`		`- return getNarrowedType(type, targetType, assumeTrue);`
	`9724`	`+ return getNarrowedType(type, targetType, assumeTrue, isTypeInstanceOf);`
`9725`	`9725`	`}`
`9726`	`9726`
`9727`	`9727`	`return type;`
`9728`	`9728`	`}`
`9729`	`9729`
`9730`		`- function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean) {`
	`9730`	`+ function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean, isRelated: (source: Type, target: Type) => boolean) {`
`9731`	`9731`	`if (!assumeTrue) {`
`9732`		`- return filterType(type, t => !isTypeInstanceOf(t, candidate));`
	`9732`	`+ return filterType(type, t => !isRelated(t, candidate));`
`9733`	`9733`	`}`
`9734`	`9734`	`// If the current type is a union type, remove all constituents that couldn't be instances of`
`9735`	`9735`	`// the candidate type. If one or more constituents remain, return a union of those.`
`9736`	`9736`	`if (type.flags & TypeFlags.Union) {`
`9737`		`- const assignableType = filterType(type, t => isTypeInstanceOf(t, candidate));`
	`9737`	`+ const assignableType = filterType(type, t => isRelated(t, candidate));`
`9738`	`9738`	`if (!(assignableType.flags & TypeFlags.Never)) {`
`9739`	`9739`	`return assignableType;`
`9740`	`9740`	`}`
`@@ -9770,7 +9770,7 @@ namespace ts {`
`9770`	`9770`	`const predicateArgument = callExpression.arguments[predicate.parameterIndex];`
`9771`	`9771`	`if (predicateArgument) {`
`9772`	`9772`	`if (isMatchingReference(reference, predicateArgument)) {`
`9773`		`- return getNarrowedType(type, predicate.type, assumeTrue);`
	`9773`	`+ return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);`
`9774`	`9774`	`}`
`9775`	`9775`	`if (containsMatchingReference(reference, predicateArgument)) {`
`9776`	`9776`	`return declaredType;`
`@@ -9783,7 +9783,7 @@ namespace ts {`
`9783`	`9783`	`const accessExpression = invokedExpression as ElementAccessExpression \| PropertyAccessExpression;`
`9784`	`9784`	`const possibleReference = skipParentheses(accessExpression.expression);`
`9785`	`9785`	`if (isMatchingReference(reference, possibleReference)) {`
`9786`		`- return getNarrowedType(type, predicate.type, assumeTrue);`
	`9786`	`+ return getNarrowedType(type, predicate.type, assumeTrue, isTypeSubtypeOf);`
`9787`	`9787`	`}`
`9788`	`9788`	`if (containsMatchingReference(reference, possibleReference)) {`
`9789`	`9789`	`return declaredType;`