microsoft
diff --git a/‎src/compiler/binder.ts
Copy file name to clipboard
+13-1Lines changed: 13 additions & 1 deletion b/‎src/compiler/binder.ts
Copy file name to clipboard
+13-1Lines changed: 13 additions & 1 deletion
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+240-120Lines changed: 240 additions & 120 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+240-120Lines changed: 240 additions & 120 deletions
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions
diff --git a/‎src/compiler/parser.ts
Copy file name to clipboard
+20-9Lines changed: 20 additions & 9 deletions b/‎src/compiler/parser.ts
Copy file name to clipboard
+20-9Lines changed: 20 additions & 9 deletions
diff --git a/‎src/compiler/types.ts
Copy file name to clipboard
+29-5Lines changed: 29 additions & 5 deletions b/‎src/compiler/types.ts
Copy file name to clipboard
+29-5Lines changed: 29 additions & 5 deletions
diff --git a/‎src/compiler/utilities.ts
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions b/‎src/compiler/utilities.ts
Copy file name to clipboard
+4Lines changed: 4 additions & 0 deletions
diff --git a/‎tests/baselines/reference/arrayBufferIsViewNarrowsType.types
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎tests/baselines/reference/arrayBufferIsViewNarrowsType.types
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎tests/baselines/reference/isArray.types
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎tests/baselines/reference/isArray.types
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎tests/baselines/reference/stringLiteralCheckedInIf02.types
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎tests/baselines/reference/stringLiteralCheckedInIf02.types
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎tests/baselines/reference/stringLiteralTypesAsTags01.errors.txt
Copy file name to clipboard
+1-7Lines changed: 1 addition & 7 deletions b/‎tests/baselines/reference/stringLiteralTypesAsTags01.errors.txt
Copy file name to clipboard
+1-7Lines changed: 1 addition & 7 deletions
@@ -1189,7 +1189,8 @@ namespace ts {
                 case SyntaxKind.ThisType:
                     seenThisKeyword = true;
                     return;
-
+                case SyntaxKind.TypePredicate:
+                    return checkTypePredicate(node as TypePredicateNode);
                 case SyntaxKind.TypeParameter:
                     return declareSymbolAndAddToSymbolTable(<Declaration>node, SymbolFlags.TypeParameter, SymbolFlags.TypeParameterExcludes);
                 case SyntaxKind.Parameter:
@@ -1275,6 +1276,17 @@ namespace ts {
             }
         }
 
+        function checkTypePredicate(node: TypePredicateNode) {
+            const { parameterName, type } = node;
+            if (parameterName && parameterName.kind === SyntaxKind.Identifier) {
+                checkStrictModeIdentifier(parameterName as Identifier);
+            }
+            if (parameterName && parameterName.kind === SyntaxKind.ThisType) {
+                seenThisKeyword = true;
+            }
+            bind(type);
+        }
+
         function bindSourceFileIfExternalModule() {
             setExportContextFlag(file);
             if (isExternalModule(file)) {
 
@@ -1647,6 +1647,14 @@
         "category": "Error",
         "code": 2517
     },
+    "A 'this'-based type guard is not compatible with a parameter-based type guard.": {
+        "category": "Error",
+        "code": 2518
+    },
+    "A 'this'-based type predicate is only allowed within a class or interface's members, get accessors, or return type positions for functions and methods.": {
+        "category": "Error",
+        "code": 2519
+    },
     "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions.": {
         "category": "Error",
         "code": 2520
 
@@ -1963,11 +1963,7 @@ namespace ts {
         function parseTypeReferenceOrTypePredicate(): TypeReferenceNode | TypePredicateNode {
             const typeName = parseEntityName(/*allowReservedWords*/ false, Diagnostics.Type_expected);
             if (typeName.kind === SyntaxKind.Identifier && token === SyntaxKind.IsKeyword && !scanner.hasPrecedingLineBreak()) {
-                nextToken();
-                const node = <TypePredicateNode>createNode(SyntaxKind.TypePredicate, typeName.pos);
-                node.parameterName = <Identifier>typeName;
-                node.type = parseType();
-                return finishNode(node);
+                return parseTypePredicate(typeName as Identifier);
             }
             const node = <TypeReferenceNode>createNode(SyntaxKind.TypeReference, typeName.pos);
             node.typeName = typeName;
@@ -1977,8 +1973,16 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parseThisTypeNode(): TypeNode {
-            const node = <TypeNode>createNode(SyntaxKind.ThisType);
+        function parseTypePredicate(lhs: Identifier | ThisTypeNode): TypePredicateNode {
+            nextToken();
+            const node = createNode(SyntaxKind.TypePredicate, lhs.pos) as TypePredicateNode;
+            node.parameterName = lhs;
+            node.type = parseType();
+            return finishNode(node);
+        }
+
+        function parseThisTypeNode(): ThisTypeNode {
+            const node = createNode(SyntaxKind.ThisType) as ThisTypeNode;
             nextToken();
             return finishNode(node);
         }
@@ -2424,8 +2428,15 @@ namespace ts {
                     return parseStringLiteralTypeNode();
                 case SyntaxKind.VoidKeyword:
                     return parseTokenNode<TypeNode>();
-                case SyntaxKind.ThisKeyword:
-                    return parseThisTypeNode();
+                case SyntaxKind.ThisKeyword: {
+                    const thisKeyword = parseThisTypeNode();
+                    if (token === SyntaxKind.IsKeyword && !scanner.hasPrecedingLineBreak()) {
+                        return parseTypePredicate(thisKeyword);
+                    }
+                    else {
+                        return thisKeyword;
+                    }
+                }
                 case SyntaxKind.TypeOfKeyword:
                     return parseTypeQuery();
                 case SyntaxKind.OpenBraceToken:
 
@@ -733,11 +733,15 @@ namespace ts {
     // @kind(SyntaxKind.StringKeyword)
     // @kind(SyntaxKind.SymbolKeyword)
     // @kind(SyntaxKind.VoidKeyword)
-    // @kind(SyntaxKind.ThisType)
     export interface TypeNode extends Node {
         _typeNodeBrand: any;
     }
 
+    // @kind(SyntaxKind.ThisType)
+    export interface ThisTypeNode extends TypeNode {
+        _thisTypeNodeBrand: any;
+    }
+
     export interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {
         _functionOrConstructorTypeNodeBrand: any;
     }
@@ -756,7 +760,7 @@ namespace ts {
 
     // @kind(SyntaxKind.TypePredicate)
     export interface TypePredicateNode extends TypeNode {
-        parameterName: Identifier;
+        parameterName: Identifier | ThisTypeNode;
         type: TypeNode;
     }
 
@@ -1820,10 +1824,25 @@ namespace ts {
         CannotBeNamed
     }
 
+    export const enum TypePredicateKind {
+        This,
+        Identifier
+    }
+
     export interface TypePredicate {
+        kind: TypePredicateKind;
+        type: Type;
+    }
+
+    // @kind (TypePredicateKind.This)
+    export interface ThisTypePredicate extends TypePredicate {
+        _thisTypePredicateBrand: any;
+    }
+
+    // @kind (TypePredicateKind.Identifier)
+    export interface IdentifierTypePredicate extends TypePredicate {
         parameterName: string;
         parameterIndex: number;
-        type: Type;
     }
 
     /* @internal */
@@ -2091,6 +2110,7 @@ namespace ts {
         ESSymbol                = 0x01000000,  // Type of symbol primitive introduced in ES6
         ThisType                = 0x02000000,  // This type
         ObjectLiteralPatternWithComputedProperties = 0x04000000,  // Object literal type implied by binding pattern has computed properties
+        PredicateType           = 0x08000000,  // Predicate types are also Boolean types, but should not be considered Intrinsics - there's no way to capture this with flags
 
         /* @internal */
         Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null,
@@ -2102,7 +2122,7 @@ namespace ts {
         UnionOrIntersection = Union | Intersection,
         StructuredType = ObjectType | Union | Intersection,
         /* @internal */
-        RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral,
+        RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral | PredicateType,
         /* @internal */
         PropagatingFlags = ContainsUndefinedOrNull | ContainsObjectLiteral | ContainsAnyFunctionType
     }
@@ -2123,6 +2143,11 @@ namespace ts {
         intrinsicName: string;  // Name of intrinsic type
     }
 
+    // Predicate types (TypeFlags.Predicate)
+    export interface PredicateType extends Type {
+        predicate: ThisTypePredicate | IdentifierTypePredicate;
+    }
+
     // String literal types (TypeFlags.StringLiteral)
     export interface StringLiteralType extends Type {
         text: string;  // Text of string literal
@@ -2239,7 +2264,6 @@ namespace ts {
         declaration: SignatureDeclaration;  // Originating declaration
         typeParameters: TypeParameter[];    // Type parameters (undefined if non-generic)
         parameters: Symbol[];               // Parameters
-        typePredicate?: TypePredicate;      // Type predicate
         /* @internal */
         resolvedReturnType: Type;           // Resolved return type
         /* @internal */
 
@@ -693,6 +693,10 @@ namespace ts {
         return node && node.kind === SyntaxKind.MethodDeclaration && node.parent.kind === SyntaxKind.ObjectLiteralExpression;
     }
 
+    export function isIdentifierTypePredicate(predicate: TypePredicate): predicate is IdentifierTypePredicate {
+        return predicate && predicate.kind === TypePredicateKind.Identifier;
+    }
+
     export function getContainingFunction(node: Node): FunctionLikeDeclaration {
         while (true) {
             node = node.parent;
 
@@ -4,7 +4,7 @@ var obj: Object;
 >Object : Object
 
 if (ArrayBuffer.isView(obj)) {
->ArrayBuffer.isView(obj) : boolean
+>ArrayBuffer.isView(obj) : arg is ArrayBufferView
 >ArrayBuffer.isView : (arg: any) => arg is ArrayBufferView
 >ArrayBuffer : ArrayBufferConstructor
 >isView : (arg: any) => arg is ArrayBufferView
 
@@ -4,7 +4,7 @@ var maybeArray: number | number[];
 
 
 if (Array.isArray(maybeArray)) {
->Array.isArray(maybeArray) : boolean
+>Array.isArray(maybeArray) : arg is any[]
 >Array.isArray : (arg: any) => arg is any[]
 >Array : ArrayConstructor
 >isArray : (arg: any) => arg is any[]
 
@@ -31,7 +31,7 @@ function f(foo: T) {
 >T : ("a" | "b")[] | "a" | "b"
 
     if (isS(foo)) {
->isS(foo) : boolean
+>isS(foo) : t is "a" | "b"
 >isS : (t: ("a" | "b")[] | "a" | "b") => t is "a" | "b"
 >foo : ("a" | "b")[] | "a" | "b"
 
 
@@ -1,10 +1,8 @@
-tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(18,10): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
-tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(19,10): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
 tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(20,10): error TS2394: Overload signature is not compatible with function implementation.
 tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(22,21): error TS2304: Cannot find name 'is'.
 
 
-==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts (4 errors) ====
+==== tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts (2 errors) ====
 
     type Kind = "A" | "B"
 
@@ -23,11 +21,7 @@ tests/cases/conformance/types/stringLiteral/stringLiteralTypesAsTags01.ts(22,21)
     }
 
     function hasKind(entity: Entity, kind: "A"): entity is A;
-             ~~~~~~~
-!!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
     function hasKind(entity: Entity, kind: "B"): entity is B;
-             ~~~~~~~
-!!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
     function hasKind(entity: Entity, kind: Kind): entity is Entity;
              ~~~~~~~
 !!! error TS2394: Overload signature is not compatible with function implementation.