diff --git a/tests/baselines/reference/typeGuardFunction.js b/tests/baselines/reference/typeGuardFunction.js
new file mode 100644
index 00000000000..d6b64c09d4d
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunction.js
@@ -0,0 +1,105 @@
+//// [typeGuardFunction.ts]
+
+class A {
+    propA: number;
+}
+
+class B {
+    propB: number;
+}
+
+class C extends A {
+    propC: number;
+}
+
+declare function isA(p1: any): p1 is A;
+declare function isB(p1: any): p1 is B;
+declare function isC(p1: any): p1 is C;
+
+declare function retC(): C;
+
+var a: A;
+var b: B;
+
+// Basic.
+if (isC(a)) {
+    a.propC;
+}
+
+// Sub type.
+var subType: C;
+if(isA(subType)) {
+    subType.propC;
+}
+
+// Union type.
+var union: A | B;
+if(isA(union)) {
+    union.propA;
+}
+
+// The parameter index and argument index for the type guard target is matching.
+// The type predicate type is assignable to the parameter type.
+declare function isC_multipleParams(p1, p2): p1 is C;
+if (isC_multipleParams(a, 0)) {
+    a.propC;
+}
+
+// Evaluations are asssignable to boolean.
+declare function acceptingBoolean(a: boolean);
+acceptingBoolean(isA(a));
+
+// Type predicates with different parameter name.
+declare function acceptingTypeGuardFunction(p1: (item) => item is A);
+acceptingTypeGuardFunction(isA);
+
+let union2: C | B;
+let union3: boolean | B = isA(union2) || union2;
+
+//// [typeGuardFunction.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A() {
+    }
+    return A;
+})();
+var B = (function () {
+    function B() {
+    }
+    return B;
+})();
+var C = (function (_super) {
+    __extends(C, _super);
+    function C() {
+        _super.apply(this, arguments);
+    }
+    return C;
+})(A);
+var a;
+var b;
+// Basic.
+if (isC(a)) {
+    a.propC;
+}
+// Sub type.
+var subType;
+if (isA(subType)) {
+    subType.propC;
+}
+// Union type.
+var union;
+if (isA(union)) {
+    union.propA;
+}
+if (isC_multipleParams(a, 0)) {
+    a.propC;
+}
+acceptingBoolean(isA(a));
+acceptingTypeGuardFunction(isA);
+var union2;
+var union3 = isA(union2) || union2;
diff --git a/tests/baselines/reference/typeGuardFunction.symbols b/tests/baselines/reference/typeGuardFunction.symbols
new file mode 100644
index 00000000000..f9180d56b0b
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunction.symbols
@@ -0,0 +1,144 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts ===
+
+class A {
+>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
+
+    propA: number;
+>propA : Symbol(propA, Decl(typeGuardFunction.ts, 1, 9))
+}
+
+class B {
+>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
+
+    propB: number;
+>propB : Symbol(propB, Decl(typeGuardFunction.ts, 5, 9))
+}
+
+class C extends A {
+>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
+>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
+
+    propC: number;
+>propC : Symbol(propC, Decl(typeGuardFunction.ts, 9, 19))
+}
+
+declare function isA(p1: any): p1 is A;
+>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
+>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 13, 21))
+>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
+
+declare function isB(p1: any): p1 is B;
+>isB : Symbol(isB, Decl(typeGuardFunction.ts, 13, 39))
+>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 14, 21))
+>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
+
+declare function isC(p1: any): p1 is C;
+>isC : Symbol(isC, Decl(typeGuardFunction.ts, 14, 39))
+>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 15, 21))
+>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
+
+declare function retC(): C;
+>retC : Symbol(retC, Decl(typeGuardFunction.ts, 15, 39))
+>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
+
+var a: A;
+>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
+>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
+
+var b: B;
+>b : Symbol(b, Decl(typeGuardFunction.ts, 20, 3))
+>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
+
+// Basic.
+if (isC(a)) {
+>isC : Symbol(isC, Decl(typeGuardFunction.ts, 14, 39))
+>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
+
+    a.propC;
+>a.propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
+>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
+>propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
+}
+
+// Sub type.
+var subType: C;
+>subType : Symbol(subType, Decl(typeGuardFunction.ts, 28, 3))
+>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
+
+if(isA(subType)) {
+>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
+>subType : Symbol(subType, Decl(typeGuardFunction.ts, 28, 3))
+
+    subType.propC;
+>subType.propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
+>subType : Symbol(subType, Decl(typeGuardFunction.ts, 28, 3))
+>propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
+}
+
+// Union type.
+var union: A | B;
+>union : Symbol(union, Decl(typeGuardFunction.ts, 34, 3))
+>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
+>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
+
+if(isA(union)) {
+>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
+>union : Symbol(union, Decl(typeGuardFunction.ts, 34, 3))
+
+    union.propA;
+>union.propA : Symbol(A.propA, Decl(typeGuardFunction.ts, 1, 9))
+>union : Symbol(union, Decl(typeGuardFunction.ts, 34, 3))
+>propA : Symbol(A.propA, Decl(typeGuardFunction.ts, 1, 9))
+}
+
+// The parameter index and argument index for the type guard target is matching.
+// The type predicate type is assignable to the parameter type.
+declare function isC_multipleParams(p1, p2): p1 is C;
+>isC_multipleParams : Symbol(isC_multipleParams, Decl(typeGuardFunction.ts, 37, 1))
+>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 41, 36))
+>p2 : Symbol(p2, Decl(typeGuardFunction.ts, 41, 39))
+>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
+
+if (isC_multipleParams(a, 0)) {
+>isC_multipleParams : Symbol(isC_multipleParams, Decl(typeGuardFunction.ts, 37, 1))
+>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
+
+    a.propC;
+>a.propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
+>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
+>propC : Symbol(C.propC, Decl(typeGuardFunction.ts, 9, 19))
+}
+
+// Evaluations are asssignable to boolean.
+declare function acceptingBoolean(a: boolean);
+>acceptingBoolean : Symbol(acceptingBoolean, Decl(typeGuardFunction.ts, 44, 1))
+>a : Symbol(a, Decl(typeGuardFunction.ts, 47, 34))
+
+acceptingBoolean(isA(a));
+>acceptingBoolean : Symbol(acceptingBoolean, Decl(typeGuardFunction.ts, 44, 1))
+>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
+>a : Symbol(a, Decl(typeGuardFunction.ts, 19, 3))
+
+// Type predicates with different parameter name.
+declare function acceptingTypeGuardFunction(p1: (item) => item is A);
+>acceptingTypeGuardFunction : Symbol(acceptingTypeGuardFunction, Decl(typeGuardFunction.ts, 48, 25))
+>p1 : Symbol(p1, Decl(typeGuardFunction.ts, 51, 44))
+>item : Symbol(item, Decl(typeGuardFunction.ts, 51, 49))
+>A : Symbol(A, Decl(typeGuardFunction.ts, 0, 0))
+
+acceptingTypeGuardFunction(isA);
+>acceptingTypeGuardFunction : Symbol(acceptingTypeGuardFunction, Decl(typeGuardFunction.ts, 48, 25))
+>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
+
+let union2: C | B;
+>union2 : Symbol(union2, Decl(typeGuardFunction.ts, 54, 3))
+>C : Symbol(C, Decl(typeGuardFunction.ts, 7, 1))
+>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
+
+let union3: boolean | B = isA(union2) || union2;
+>union3 : Symbol(union3, Decl(typeGuardFunction.ts, 55, 3))
+>B : Symbol(B, Decl(typeGuardFunction.ts, 3, 1))
+>isA : Symbol(isA, Decl(typeGuardFunction.ts, 11, 1))
+>union2 : Symbol(union2, Decl(typeGuardFunction.ts, 54, 3))
+>union2 : Symbol(union2, Decl(typeGuardFunction.ts, 54, 3))
+
diff --git a/tests/baselines/reference/typeGuardFunction.types b/tests/baselines/reference/typeGuardFunction.types
new file mode 100644
index 00000000000..2b3d1c40c8e
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunction.types
@@ -0,0 +1,159 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts ===
+
+class A {
+>A : A
+
+    propA: number;
+>propA : number
+}
+
+class B {
+>B : B
+
+    propB: number;
+>propB : number
+}
+
+class C extends A {
+>C : C
+>A : A
+
+    propC: number;
+>propC : number
+}
+
+declare function isA(p1: any): p1 is A;
+>isA : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>A : A
+
+declare function isB(p1: any): p1 is B;
+>isB : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>B : B
+
+declare function isC(p1: any): p1 is C;
+>isC : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>C : C
+
+declare function retC(): C;
+>retC : () => C
+>C : C
+
+var a: A;
+>a : A
+>A : A
+
+var b: B;
+>b : B
+>B : B
+
+// Basic.
+if (isC(a)) {
+>isC(a) : boolean
+>isC : (p1: any) => boolean
+>a : A
+
+    a.propC;
+>a.propC : number
+>a : C
+>propC : number
+}
+
+// Sub type.
+var subType: C;
+>subType : C
+>C : C
+
+if(isA(subType)) {
+>isA(subType) : boolean
+>isA : (p1: any) => boolean
+>subType : C
+
+    subType.propC;
+>subType.propC : number
+>subType : C
+>propC : number
+}
+
+// Union type.
+var union: A | B;
+>union : A | B
+>A : A
+>B : B
+
+if(isA(union)) {
+>isA(union) : boolean
+>isA : (p1: any) => boolean
+>union : A | B
+
+    union.propA;
+>union.propA : number
+>union : A
+>propA : number
+}
+
+// The parameter index and argument index for the type guard target is matching.
+// The type predicate type is assignable to the parameter type.
+declare function isC_multipleParams(p1, p2): p1 is C;
+>isC_multipleParams : (p1: any, p2: any) => boolean
+>p1 : any
+>p2 : any
+>p1 : any
+>C : C
+
+if (isC_multipleParams(a, 0)) {
+>isC_multipleParams(a, 0) : boolean
+>isC_multipleParams : (p1: any, p2: any) => boolean
+>a : A
+>0 : number
+
+    a.propC;
+>a.propC : number
+>a : C
+>propC : number
+}
+
+// Evaluations are asssignable to boolean.
+declare function acceptingBoolean(a: boolean);
+>acceptingBoolean : (a: boolean) => any
+>a : boolean
+
+acceptingBoolean(isA(a));
+>acceptingBoolean(isA(a)) : any
+>acceptingBoolean : (a: boolean) => any
+>isA(a) : boolean
+>isA : (p1: any) => boolean
+>a : A
+
+// Type predicates with different parameter name.
+declare function acceptingTypeGuardFunction(p1: (item) => item is A);
+>acceptingTypeGuardFunction : (p1: (item: any) => boolean) => any
+>p1 : (item: any) => boolean
+>item : any
+>item : any
+>A : A
+
+acceptingTypeGuardFunction(isA);
+>acceptingTypeGuardFunction(isA) : any
+>acceptingTypeGuardFunction : (p1: (item: any) => boolean) => any
+>isA : (p1: any) => boolean
+
+let union2: C | B;
+>union2 : B | C
+>C : C
+>B : B
+
+let union3: boolean | B = isA(union2) || union2;
+>union3 : boolean | B
+>B : B
+>isA(union2) || union2 : boolean | B
+>isA(union2) : boolean
+>isA : (p1: any) => boolean
+>union2 : B | C
+>union2 : B
+
diff --git a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt
new file mode 100644
index 00000000000..8b5ed551dff
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt
@@ -0,0 +1,174 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(15,12): error TS1225: A type-guard function can only return a boolean.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,55): error TS2304: Cannot find name 'x'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,57): error TS1144: '{' or ';' expected.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,57): error TS2304: Cannot find name 'is'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,60): error TS1005: ';' expected.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(18,62): error TS1005: ';' expected.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(22,33): error TS2304: Cannot find name 'x'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(26,10): error TS2391: Function implementation is missing or not immediately following the declaration.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(27,5): error TS1131: Property or signature expected.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(28,1): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(30,38): error TS1226: Cannot find parameter 'x'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(34,51): error TS2322: Type 'B' is not assignable to type 'A'.
+  Property 'propA' is missing in type 'B'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(38,56): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(42,56): error TS2322: Type 'T[]' is not assignable to type 'string'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(56,7): error TS2339: Property 'propB' does not exist on type 'A'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(61,7): error TS2339: Property 'propB' does not exist on type 'A'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(66,7): error TS2339: Property 'propB' does not exist on type 'A'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(71,46): error TS2345: Argument of type '(p1: any) => boolean' is not assignable to parameter of type '(p1: any) => boolean'.
+  Type-guard annotation 'p1 is C' is not assignable to 'p1 is B'.
+    Type 'C' is not assignable to type 'B'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(75,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
+  A non-type guard function is not assignable to a type guard function.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(81,1): error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
+  Type-guard annotation 'p2 is A' is not assignable to 'p1 is A'.
+    Parameter index from 'p2' does not match the parameter index from 'p1'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(87,1): error TS2322: Type '(p1: any, p2: any, p3: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
+tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(92,56): error TS1226: Cannot find parameter 'p1'.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (22 errors) ====
+    
+    class A {
+        propA: number;
+    }
+    
+    class B {
+        propB: number;
+    }
+    
+    class C extends A {
+        propC: number;
+    }
+    
+    function hasANonBooleanReturnStatement(x): x is A {
+        return '';
+               ~~
+!!! error TS1225: A type-guard function can only return a boolean.
+    }
+    
+    function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
+                                                          ~
+!!! error TS2304: Cannot find name 'x'.
+                                                            ~~
+!!! error TS1144: '{' or ';' expected.
+                                                            ~~
+!!! error TS2304: Cannot find name 'is'.
+                                                               ~
+!!! error TS1005: ';' expected.
+                                                                 ~
+!!! error TS1005: ';' expected.
+        return true;
+    }
+    
+    function hasMissingIsKeyword(): x {
+                                    ~
+!!! error TS2304: Cannot find name 'x'.
+        return true;
+    }
+    
+    function hasMissingTypeInTypeGuardType(x): x is {
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2391: Function implementation is missing or not immediately following the declaration.
+        return true;
+        ~~~~~~
+!!! error TS1131: Property or signature expected.
+    }
+    ~
+!!! error TS1128: Declaration or statement expected.
+    
+    function hasNonMatchingParameter(y): x is A {
+                                         ~
+!!! error TS1226: Cannot find parameter 'x'.
+        return true;
+    }
+    
+    function hasNonMatchingParameterType1(x: A): x is B {
+                                                      ~
+!!! error TS2322: Type 'B' is not assignable to type 'A'.
+!!! error TS2322:   Property 'propA' is missing in type 'B'.
+        return true;
+    }
+    
+    function hasNonMatchingParameterType2(x: string): x is number {
+                                                           ~~~~~~
+!!! error TS2322: Type 'number' is not assignable to type 'string'.
+        return true;
+    }
+    
+    function hasNonMathcingGenericType<T>(a: string): a is T[] {
+                                                           ~~~
+!!! error TS2322: Type 'T[]' is not assignable to type 'string'.
+        return true;
+    }
+    
+    let a: A;
+    let b: B;
+    
+    declare function isB(p1): p1 is B;
+    declare function isC(p1): p1 is C;
+    declare function funA(p1: any, p2: any): p1 is B;
+    declare function hasNoTypeGuard(x);
+    
+    // Passed argument is not the same as the one being guarded.
+    if (isB(b)) {
+        a.propB;
+          ~~~~~
+!!! error TS2339: Property 'propB' does not exist on type 'A'.
+    }
+    
+    // Parameter index and argument index for the type guard target is not matching.
+    if (funA(0, a)) {
+        a.propB; // Error
+          ~~~~~
+!!! error TS2339: Property 'propB' does not exist on type 'A'.
+    }
+    
+    // No type guard in if statement
+    if (hasNoTypeGuard(a)) {
+        a.propB; 
+          ~~~~~
+!!! error TS2339: Property 'propB' does not exist on type 'A'.
+    }
+    
+    // Type predicate type is not assignable
+    declare function acceptingDifferentSignatureTypeGuardFunction(p1: (p1) => p1 is B);
+    acceptingDifferentSignatureTypeGuardFunction(isC);
+                                                 ~~~
+!!! error TS2345: Argument of type '(p1: any) => boolean' is not assignable to parameter of type '(p1: any) => boolean'.
+!!! error TS2345:   Type-guard annotation 'p1 is C' is not assignable to 'p1 is B'.
+!!! error TS2345:     Type 'C' is not assignable to type 'B'.
+    
+    // Boolean not assignable to type guard
+    var assign1: (p1, p2) => p1 is A;
+    assign1 = function(p1, p2): boolean {
+    ~~~~~~~
+!!! error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
+!!! error TS2322:   A non-type guard function is not assignable to a type guard function.
+        return true;
+    };
+    
+    // Must have matching parameter index
+    var assign2: (p1, p2) => p1 is A;
+    assign2 = function(p1, p2): p2 is A {
+    ~~~~~~~
+!!! error TS2322: Type '(p1: any, p2: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
+!!! error TS2322:   Type-guard annotation 'p2 is A' is not assignable to 'p1 is A'.
+!!! error TS2322:     Parameter index from 'p2' does not match the parameter index from 'p1'.
+        return true;
+    };
+    
+    // No matching signature 
+    var assign3: (p1, p2) => p1 is A;
+    assign3 = function(p1, p2, p3): p1 is A {
+    ~~~~~~~
+!!! error TS2322: Type '(p1: any, p2: any, p3: any) => boolean' is not assignable to type '(p1: any, p2: any) => boolean'.
+        return true;
+    };
+    
+    // Type guard paramater referring to a binding pattern
+    declare function destructureParameter({ p1, p2, p3 }): p1 is A;
+                                                           ~~
+!!! error TS1226: Cannot find parameter 'p1'.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/typeGuardFunctionErrors.js b/tests/baselines/reference/typeGuardFunctionErrors.js
new file mode 100644
index 00000000000..cc65fc00cba
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunctionErrors.js
@@ -0,0 +1,173 @@
+//// [typeGuardFunctionErrors.ts]
+
+class A {
+    propA: number;
+}
+
+class B {
+    propB: number;
+}
+
+class C extends A {
+    propC: number;
+}
+
+function hasANonBooleanReturnStatement(x): x is A {
+    return '';
+}
+
+function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
+    return true;
+}
+
+function hasMissingIsKeyword(): x {
+    return true;
+}
+
+function hasMissingTypeInTypeGuardType(x): x is {
+    return true;
+}
+
+function hasNonMatchingParameter(y): x is A {
+    return true;
+}
+
+function hasNonMatchingParameterType1(x: A): x is B {
+    return true;
+}
+
+function hasNonMatchingParameterType2(x: string): x is number {
+    return true;
+}
+
+function hasNonMathcingGenericType<T>(a: string): a is T[] {
+    return true;
+}
+
+let a: A;
+let b: B;
+
+declare function isB(p1): p1 is B;
+declare function isC(p1): p1 is C;
+declare function funA(p1: any, p2: any): p1 is B;
+declare function hasNoTypeGuard(x);
+
+// Passed argument is not the same as the one being guarded.
+if (isB(b)) {
+    a.propB;
+}
+
+// Parameter index and argument index for the type guard target is not matching.
+if (funA(0, a)) {
+    a.propB; // Error
+}
+
+// No type guard in if statement
+if (hasNoTypeGuard(a)) {
+    a.propB; 
+}
+
+// Type predicate type is not assignable
+declare function acceptingDifferentSignatureTypeGuardFunction(p1: (p1) => p1 is B);
+acceptingDifferentSignatureTypeGuardFunction(isC);
+
+// Boolean not assignable to type guard
+var assign1: (p1, p2) => p1 is A;
+assign1 = function(p1, p2): boolean {
+    return true;
+};
+
+// Must have matching parameter index
+var assign2: (p1, p2) => p1 is A;
+assign2 = function(p1, p2): p2 is A {
+    return true;
+};
+
+// No matching signature 
+var assign3: (p1, p2) => p1 is A;
+assign3 = function(p1, p2, p3): p1 is A {
+    return true;
+};
+
+// Type guard paramater referring to a binding pattern
+declare function destructureParameter({ p1, p2, p3 }): p1 is A;
+
+
+//// [typeGuardFunctionErrors.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A() {
+    }
+    return A;
+})();
+var B = (function () {
+    function B() {
+    }
+    return B;
+})();
+var C = (function (_super) {
+    __extends(C, _super);
+    function C() {
+        _super.apply(this, arguments);
+    }
+    return C;
+})(A);
+function hasANonBooleanReturnStatement(x) {
+    return '';
+}
+is;
+A;
+{
+    return true;
+}
+function hasMissingIsKeyword() {
+    return true;
+}
+return true;
+function hasNonMatchingParameter(y) {
+    return true;
+}
+function hasNonMatchingParameterType1(x) {
+    return true;
+}
+function hasNonMatchingParameterType2(x) {
+    return true;
+}
+function hasNonMathcingGenericType(a) {
+    return true;
+}
+var a;
+var b;
+// Passed argument is not the same as the one being guarded.
+if (isB(b)) {
+    a.propB;
+}
+// Parameter index and argument index for the type guard target is not matching.
+if (funA(0, a)) {
+    a.propB; // Error
+}
+// No type guard in if statement
+if (hasNoTypeGuard(a)) {
+    a.propB;
+}
+acceptingDifferentSignatureTypeGuardFunction(isC);
+// Boolean not assignable to type guard
+var assign1;
+assign1 = function (p1, p2) {
+    return true;
+};
+// Must have matching parameter index
+var assign2;
+assign2 = function (p1, p2) {
+    return true;
+};
+// No matching signature 
+var assign3;
+assign3 = function (p1, p2, p3) {
+    return true;
+};
diff --git a/tests/baselines/reference/typeGuardFunctionGenerics.js b/tests/baselines/reference/typeGuardFunctionGenerics.js
new file mode 100644
index 00000000000..6704225a0d0
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunctionGenerics.js
@@ -0,0 +1,69 @@
+//// [typeGuardFunctionGenerics.ts]
+
+class A {
+    propA: number;
+}
+
+class B {
+    propB: number;
+}
+
+class C extends A {
+    propC: number;
+}
+
+declare function isB(p1): p1 is B;
+declare function isC(p1): p1 is C;
+declare function retC(x): C; 
+
+declare function funA<T>(p1: (p1) => T): T;
+declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
+declare function funC<T>(p1: (p1) => p1 is T): T;
+declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
+declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
+
+let a: A;
+let test1: boolean = funA(isB);
+if (funB(retC, a)) {
+    a.propC;
+}
+let test2: B = funC(isB);
+if (funD(isC, a)) {
+    a.propC;
+}
+let test3: B = funE(isB, 1);
+
+//// [typeGuardFunctionGenerics.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var A = (function () {
+    function A() {
+    }
+    return A;
+})();
+var B = (function () {
+    function B() {
+    }
+    return B;
+})();
+var C = (function (_super) {
+    __extends(C, _super);
+    function C() {
+        _super.apply(this, arguments);
+    }
+    return C;
+})(A);
+var a;
+var test1 = funA(isB);
+if (funB(retC, a)) {
+    a.propC;
+}
+var test2 = funC(isB);
+if (funD(isC, a)) {
+    a.propC;
+}
+var test3 = funE(isB, 1);
diff --git a/tests/baselines/reference/typeGuardFunctionGenerics.symbols b/tests/baselines/reference/typeGuardFunctionGenerics.symbols
new file mode 100644
index 00000000000..0ad8fab2fdb
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunctionGenerics.symbols
@@ -0,0 +1,125 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts ===
+
+class A {
+>A : Symbol(A, Decl(typeGuardFunctionGenerics.ts, 0, 0))
+
+    propA: number;
+>propA : Symbol(propA, Decl(typeGuardFunctionGenerics.ts, 1, 9))
+}
+
+class B {
+>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
+
+    propB: number;
+>propB : Symbol(propB, Decl(typeGuardFunctionGenerics.ts, 5, 9))
+}
+
+class C extends A {
+>C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1))
+>A : Symbol(A, Decl(typeGuardFunctionGenerics.ts, 0, 0))
+
+    propC: number;
+>propC : Symbol(propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
+}
+
+declare function isB(p1): p1 is B;
+>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 13, 21))
+>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
+
+declare function isC(p1): p1 is C;
+>isC : Symbol(isC, Decl(typeGuardFunctionGenerics.ts, 13, 34))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 14, 21))
+>C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1))
+
+declare function retC(x): C; 
+>retC : Symbol(retC, Decl(typeGuardFunctionGenerics.ts, 14, 34))
+>x : Symbol(x, Decl(typeGuardFunctionGenerics.ts, 15, 22))
+>C : Symbol(C, Decl(typeGuardFunctionGenerics.ts, 7, 1))
+
+declare function funA<T>(p1: (p1) => T): T;
+>funA : Symbol(funA, Decl(typeGuardFunctionGenerics.ts, 15, 28))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 17, 22))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 17, 25))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 17, 30))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 17, 22))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 17, 22))
+
+declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
+>funB : Symbol(funB, Decl(typeGuardFunctionGenerics.ts, 17, 43))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 18, 25))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 18, 30))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22))
+>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 18, 39))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 18, 22))
+
+declare function funC<T>(p1: (p1) => p1 is T): T;
+>funC : Symbol(funC, Decl(typeGuardFunctionGenerics.ts, 18, 58))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 25))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 19, 30))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 19, 22))
+
+declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
+>funD : Symbol(funD, Decl(typeGuardFunctionGenerics.ts, 19, 49))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 25))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 20, 30))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22))
+>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 20, 45))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 20, 22))
+
+declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
+>funE : Symbol(funE, Decl(typeGuardFunctionGenerics.ts, 20, 64))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22))
+>U : Symbol(U, Decl(typeGuardFunctionGenerics.ts, 21, 24))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 28))
+>p1 : Symbol(p1, Decl(typeGuardFunctionGenerics.ts, 21, 33))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22))
+>p2 : Symbol(p2, Decl(typeGuardFunctionGenerics.ts, 21, 48))
+>U : Symbol(U, Decl(typeGuardFunctionGenerics.ts, 21, 24))
+>T : Symbol(T, Decl(typeGuardFunctionGenerics.ts, 21, 22))
+
+let a: A;
+>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
+>A : Symbol(A, Decl(typeGuardFunctionGenerics.ts, 0, 0))
+
+let test1: boolean = funA(isB);
+>test1 : Symbol(test1, Decl(typeGuardFunctionGenerics.ts, 24, 3))
+>funA : Symbol(funA, Decl(typeGuardFunctionGenerics.ts, 15, 28))
+>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
+
+if (funB(retC, a)) {
+>funB : Symbol(funB, Decl(typeGuardFunctionGenerics.ts, 17, 43))
+>retC : Symbol(retC, Decl(typeGuardFunctionGenerics.ts, 14, 34))
+>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
+
+    a.propC;
+>a.propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
+>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
+>propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
+}
+let test2: B = funC(isB);
+>test2 : Symbol(test2, Decl(typeGuardFunctionGenerics.ts, 28, 3))
+>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
+>funC : Symbol(funC, Decl(typeGuardFunctionGenerics.ts, 18, 58))
+>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
+
+if (funD(isC, a)) {
+>funD : Symbol(funD, Decl(typeGuardFunctionGenerics.ts, 19, 49))
+>isC : Symbol(isC, Decl(typeGuardFunctionGenerics.ts, 13, 34))
+>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
+
+    a.propC;
+>a.propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
+>a : Symbol(a, Decl(typeGuardFunctionGenerics.ts, 23, 3))
+>propC : Symbol(C.propC, Decl(typeGuardFunctionGenerics.ts, 9, 19))
+}
+let test3: B = funE(isB, 1);
+>test3 : Symbol(test3, Decl(typeGuardFunctionGenerics.ts, 32, 3))
+>B : Symbol(B, Decl(typeGuardFunctionGenerics.ts, 3, 1))
+>funE : Symbol(funE, Decl(typeGuardFunctionGenerics.ts, 20, 64))
+>isB : Symbol(isB, Decl(typeGuardFunctionGenerics.ts, 11, 1))
+
diff --git a/tests/baselines/reference/typeGuardFunctionGenerics.types b/tests/baselines/reference/typeGuardFunctionGenerics.types
new file mode 100644
index 00000000000..77162e55a40
--- /dev/null
+++ b/tests/baselines/reference/typeGuardFunctionGenerics.types
@@ -0,0 +1,138 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts ===
+
+class A {
+>A : A
+
+    propA: number;
+>propA : number
+}
+
+class B {
+>B : B
+
+    propB: number;
+>propB : number
+}
+
+class C extends A {
+>C : C
+>A : A
+
+    propC: number;
+>propC : number
+}
+
+declare function isB(p1): p1 is B;
+>isB : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>B : B
+
+declare function isC(p1): p1 is C;
+>isC : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>C : C
+
+declare function retC(x): C; 
+>retC : (x: any) => C
+>x : any
+>C : C
+
+declare function funA<T>(p1: (p1) => T): T;
+>funA : <T>(p1: (p1: any) => T) => T
+>T : T
+>p1 : (p1: any) => T
+>p1 : any
+>T : T
+>T : T
+
+declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
+>funB : <T>(p1: (p1: any) => T, p2: any) => boolean
+>T : T
+>p1 : (p1: any) => T
+>p1 : any
+>T : T
+>p2 : any
+>p2 : any
+>T : T
+
+declare function funC<T>(p1: (p1) => p1 is T): T;
+>funC : <T>(p1: (p1: any) => boolean) => T
+>T : T
+>p1 : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>T : T
+>T : T
+
+declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
+>funD : <T>(p1: (p1: any) => boolean, p2: any) => boolean
+>T : T
+>p1 : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>T : T
+>p2 : any
+>p2 : any
+>T : T
+
+declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
+>funE : <T, U>(p1: (p1: any) => boolean, p2: U) => T
+>T : T
+>U : U
+>p1 : (p1: any) => boolean
+>p1 : any
+>p1 : any
+>T : T
+>p2 : U
+>U : U
+>T : T
+
+let a: A;
+>a : A
+>A : A
+
+let test1: boolean = funA(isB);
+>test1 : boolean
+>funA(isB) : boolean
+>funA : <T>(p1: (p1: any) => T) => T
+>isB : (p1: any) => boolean
+
+if (funB(retC, a)) {
+>funB(retC, a) : boolean
+>funB : <T>(p1: (p1: any) => T, p2: any) => boolean
+>retC : (x: any) => C
+>a : A
+
+    a.propC;
+>a.propC : number
+>a : C
+>propC : number
+}
+let test2: B = funC(isB);
+>test2 : B
+>B : B
+>funC(isB) : B
+>funC : <T>(p1: (p1: any) => boolean) => T
+>isB : (p1: any) => boolean
+
+if (funD(isC, a)) {
+>funD(isC, a) : boolean
+>funD : <T>(p1: (p1: any) => boolean, p2: any) => boolean
+>isC : (p1: any) => boolean
+>a : A
+
+    a.propC;
+>a.propC : number
+>a : C
+>propC : number
+}
+let test3: B = funE(isB, 1);
+>test3 : B
+>B : B
+>funE(isB, 1) : B
+>funE : <T, U>(p1: (p1: any) => boolean, p2: U) => T
+>isB : (p1: any) => boolean
+>1 : number
+
diff --git a/tests/baselines/reference/typeGuardOfFormIsType.js b/tests/baselines/reference/typeGuardOfFormIsType.js
new file mode 100644
index 00000000000..65d99319d1e
--- /dev/null
+++ b/tests/baselines/reference/typeGuardOfFormIsType.js
@@ -0,0 +1,85 @@
+//// [typeGuardOfFormIsType.ts]
+
+class C1 {
+    p1: string;
+}
+class C2 {
+    p2: number;
+}
+class D1 extends C1 {
+    p3: number;
+}
+var str: string;
+var num: number;
+var strOrNum: string | number;
+
+function isC1(x: any): x is C1 {
+    return true;
+}
+
+function isC2(x: any): x is C2 {
+    return true;
+}
+
+function isD1(x: any): x is D1 {
+    return true;
+}
+
+var c1Orc2: C1 | C2;
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+
+var c2Ord1: C2 | D1;
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
+
+//// [typeGuardOfFormIsType.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    __.prototype = b.prototype;
+    d.prototype = new __();
+};
+var C1 = (function () {
+    function C1() {
+    }
+    return C1;
+})();
+var C2 = (function () {
+    function C2() {
+    }
+    return C2;
+})();
+var D1 = (function (_super) {
+    __extends(D1, _super);
+    function D1() {
+        _super.apply(this, arguments);
+    }
+    return D1;
+})(C1);
+var str;
+var num;
+var strOrNum;
+function isC1(x) {
+    return true;
+}
+function isC2(x) {
+    return true;
+}
+function isD1(x) {
+    return true;
+}
+var c1Orc2;
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+var c2Ord1;
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+var r2 = isC1(c2Ord1) && c2Ord1; // C2 | D1
diff --git a/tests/baselines/reference/typeGuardOfFormIsType.symbols b/tests/baselines/reference/typeGuardOfFormIsType.symbols
new file mode 100644
index 00000000000..a7bd0f4c165
--- /dev/null
+++ b/tests/baselines/reference/typeGuardOfFormIsType.symbols
@@ -0,0 +1,128 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts ===
+
+class C1 {
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
+
+    p1: string;
+>p1 : Symbol(p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+}
+class C2 {
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
+
+    p2: number;
+>p2 : Symbol(p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
+}
+class D1 extends C1 {
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
+
+    p3: number;
+>p3 : Symbol(p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
+}
+var str: string;
+>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
+
+var num: number;
+>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
+
+var strOrNum: string | number;
+>strOrNum : Symbol(strOrNum, Decl(typeGuardOfFormIsType.ts, 12, 3))
+
+function isC1(x: any): x is C1 {
+>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30))
+>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 14, 14))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
+
+    return true;
+}
+
+function isC2(x: any): x is C2 {
+>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1))
+>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 18, 14))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
+
+    return true;
+}
+
+function isD1(x: any): x is D1 {
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
+>x : Symbol(x, Decl(typeGuardOfFormIsType.ts, 22, 14))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
+
+    return true;
+}
+
+var c1Orc2: C1 | C2;
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsType.ts, 0, 0))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
+
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
+>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
+>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>c1Orc2.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
+
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>c1Orc2.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsType.ts, 26, 3))
+>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
+
+var c2Ord1: C2 | D1;
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
+
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
+>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsType.ts, 16, 1))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>c2Ord1.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsType.ts, 4, 10))
+
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+>num : Symbol(num, Decl(typeGuardOfFormIsType.ts, 11, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>c2Ord1.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsType.ts, 7, 21))
+
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+>str : Symbol(str, Decl(typeGuardOfFormIsType.ts, 10, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsType.ts, 20, 1))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>c2Ord1.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsType.ts, 1, 10))
+
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
+>r2 : Symbol(r2, Decl(typeGuardOfFormIsType.ts, 36, 3))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsType.ts, 3, 1))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsType.ts, 6, 1))
+>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsType.ts, 12, 30))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsType.ts, 32, 3))
+
diff --git a/tests/baselines/reference/typeGuardOfFormIsType.types b/tests/baselines/reference/typeGuardOfFormIsType.types
new file mode 100644
index 00000000000..b14e5e22910
--- /dev/null
+++ b/tests/baselines/reference/typeGuardOfFormIsType.types
@@ -0,0 +1,157 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts ===
+
+class C1 {
+>C1 : C1
+
+    p1: string;
+>p1 : string
+}
+class C2 {
+>C2 : C2
+
+    p2: number;
+>p2 : number
+}
+class D1 extends C1 {
+>D1 : D1
+>C1 : C1
+
+    p3: number;
+>p3 : number
+}
+var str: string;
+>str : string
+
+var num: number;
+>num : number
+
+var strOrNum: string | number;
+>strOrNum : string | number
+
+function isC1(x: any): x is C1 {
+>isC1 : (x: any) => boolean
+>x : any
+>x : any
+>C1 : C1
+
+    return true;
+>true : boolean
+}
+
+function isC2(x: any): x is C2 {
+>isC2 : (x: any) => boolean
+>x : any
+>x : any
+>C2 : C2
+
+    return true;
+>true : boolean
+}
+
+function isD1(x: any): x is D1 {
+>isD1 : (x: any) => boolean
+>x : any
+>x : any
+>D1 : D1
+
+    return true;
+>true : boolean
+}
+
+var c1Orc2: C1 | C2;
+>c1Orc2 : C1 | C2
+>C1 : C1
+>C2 : C2
+
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+>str = isC1(c1Orc2) && c1Orc2.p1 : string
+>str : string
+>isC1(c1Orc2) && c1Orc2.p1 : string
+>isC1(c1Orc2) : boolean
+>isC1 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p1 : string
+>c1Orc2 : C1
+>p1 : string
+
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+>num = isC2(c1Orc2) && c1Orc2.p2 : number
+>num : number
+>isC2(c1Orc2) && c1Orc2.p2 : number
+>isC2(c1Orc2) : boolean
+>isC2 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p2 : number
+>c1Orc2 : C2
+>p2 : number
+
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+>str = isD1(c1Orc2) && c1Orc2.p1 : string
+>str : string
+>isD1(c1Orc2) && c1Orc2.p1 : string
+>isD1(c1Orc2) : boolean
+>isD1 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p1 : string
+>c1Orc2 : D1
+>p1 : string
+
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+>num = isD1(c1Orc2) && c1Orc2.p3 : number
+>num : number
+>isD1(c1Orc2) && c1Orc2.p3 : number
+>isD1(c1Orc2) : boolean
+>isD1 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p3 : number
+>c1Orc2 : D1
+>p3 : number
+
+var c2Ord1: C2 | D1;
+>c2Ord1 : C2 | D1
+>C2 : C2
+>D1 : D1
+
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+>num = isC2(c2Ord1) && c2Ord1.p2 : number
+>num : number
+>isC2(c2Ord1) && c2Ord1.p2 : number
+>isC2(c2Ord1) : boolean
+>isC2 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1.p2 : number
+>c2Ord1 : C2
+>p2 : number
+
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+>num = isD1(c2Ord1) && c2Ord1.p3 : number
+>num : number
+>isD1(c2Ord1) && c2Ord1.p3 : number
+>isD1(c2Ord1) : boolean
+>isD1 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1.p3 : number
+>c2Ord1 : D1
+>p3 : number
+
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+>str = isD1(c2Ord1) && c2Ord1.p1 : string
+>str : string
+>isD1(c2Ord1) && c2Ord1.p1 : string
+>isD1(c2Ord1) : boolean
+>isD1 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1.p1 : string
+>c2Ord1 : D1
+>p1 : string
+
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
+>r2 : C2 | D1
+>C2 : C2
+>D1 : D1
+>isC1(c2Ord1) && c2Ord1 : D1
+>isC1(c2Ord1) : boolean
+>isC1 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1 : D1
+
diff --git a/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.js b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.js
new file mode 100644
index 00000000000..d5faee96e8b
--- /dev/null
+++ b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.js
@@ -0,0 +1,74 @@
+//// [typeGuardOfFormIsTypeOnInterfaces.ts]
+
+interface C1 {
+    (): C1;
+    prototype: C1;
+    p1: string;
+}
+interface C2 {
+    (): C2;
+    prototype: C2;
+    p2: number;
+}
+interface D1 extends C1 {
+    prototype: D1;
+    p3: number;
+}
+var str: string;
+var num: number;
+var strOrNum: string | number;
+
+
+function isC1(x: any): x is C1 {
+    return true;
+}
+
+function isC2(x: any): x is C2 {
+    return true;
+}
+
+function isD1(x: any): x is D1 {
+    return true;
+}
+
+var c1: C1;
+var c2: C2;
+var d1: D1;
+var c1Orc2: C1 | C2;
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+
+var c2Ord1: C2 | D1;
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
+
+//// [typeGuardOfFormIsTypeOnInterfaces.js]
+var str;
+var num;
+var strOrNum;
+function isC1(x) {
+    return true;
+}
+function isC2(x) {
+    return true;
+}
+function isD1(x) {
+    return true;
+}
+var c1;
+var c2;
+var d1;
+var c1Orc2;
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+var c2Ord1;
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+var r2 = isC1(c2Ord1) && c2Ord1; // C2 | D1
diff --git a/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols
new file mode 100644
index 00000000000..37249ef7659
--- /dev/null
+++ b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.symbols
@@ -0,0 +1,159 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts ===
+
+interface C1 {
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+
+    (): C1;
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+
+    prototype: C1;
+>prototype : Symbol(prototype, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 2, 11))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+
+    p1: string;
+>p1 : Symbol(p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+}
+interface C2 {
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+
+    (): C2;
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+
+    prototype: C2;
+>prototype : Symbol(prototype, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 7, 11))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+
+    p2: number;
+>p2 : Symbol(p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
+}
+interface D1 extends C1 {
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+
+    prototype: D1;
+>prototype : Symbol(prototype, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 11, 25))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
+
+    p3: number;
+>p3 : Symbol(p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
+}
+var str: string;
+>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
+
+var num: number;
+>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
+
+var strOrNum: string | number;
+>strOrNum : Symbol(strOrNum, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 3))
+
+
+function isC1(x: any): x is C1 {
+>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30))
+>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 20, 14))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+
+    return true;
+}
+
+function isC2(x: any): x is C2 {
+>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1))
+>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 24, 14))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+
+    return true;
+}
+
+function isD1(x: any): x is D1 {
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
+>x : Symbol(x, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 28, 14))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
+
+    return true;
+}
+
+var c1: C1;
+>c1 : Symbol(c1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 32, 3))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+
+var c2: C2;
+>c2 : Symbol(c2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 33, 3))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+
+var d1: D1;
+>d1 : Symbol(d1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 34, 3))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
+
+var c1Orc2: C1 | C2;
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>C1 : Symbol(C1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 0, 0))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
+>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
+>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>c1Orc2.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
+
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>c1Orc2.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>c1Orc2.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
+>c1Orc2 : Symbol(c1Orc2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 35, 3))
+>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
+
+var c2Ord1: C2 | D1;
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
+
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
+>isC2 : Symbol(isC2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 22, 1))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>c2Ord1.p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>p2 : Symbol(C2.p2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 8, 18))
+
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+>num : Symbol(num, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 16, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>c2Ord1.p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>p3 : Symbol(D1.p3, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 12, 18))
+
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+>str : Symbol(str, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 15, 3))
+>isD1 : Symbol(isD1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 26, 1))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>c2Ord1.p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>p1 : Symbol(C1.p1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 3, 18))
+
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
+>r2 : Symbol(r2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 45, 3))
+>C2 : Symbol(C2, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 5, 1))
+>D1 : Symbol(D1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 10, 1))
+>isC1 : Symbol(isC1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 17, 30))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+>c2Ord1 : Symbol(c2Ord1, Decl(typeGuardOfFormIsTypeOnInterfaces.ts, 41, 3))
+
diff --git a/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.types b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.types
new file mode 100644
index 00000000000..3a659d71163
--- /dev/null
+++ b/tests/baselines/reference/typeGuardOfFormIsTypeOnInterfaces.types
@@ -0,0 +1,188 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts ===
+
+interface C1 {
+>C1 : C1
+
+    (): C1;
+>C1 : C1
+
+    prototype: C1;
+>prototype : C1
+>C1 : C1
+
+    p1: string;
+>p1 : string
+}
+interface C2 {
+>C2 : C2
+
+    (): C2;
+>C2 : C2
+
+    prototype: C2;
+>prototype : C2
+>C2 : C2
+
+    p2: number;
+>p2 : number
+}
+interface D1 extends C1 {
+>D1 : D1
+>C1 : C1
+
+    prototype: D1;
+>prototype : D1
+>D1 : D1
+
+    p3: number;
+>p3 : number
+}
+var str: string;
+>str : string
+
+var num: number;
+>num : number
+
+var strOrNum: string | number;
+>strOrNum : string | number
+
+
+function isC1(x: any): x is C1 {
+>isC1 : (x: any) => boolean
+>x : any
+>x : any
+>C1 : C1
+
+    return true;
+>true : boolean
+}
+
+function isC2(x: any): x is C2 {
+>isC2 : (x: any) => boolean
+>x : any
+>x : any
+>C2 : C2
+
+    return true;
+>true : boolean
+}
+
+function isD1(x: any): x is D1 {
+>isD1 : (x: any) => boolean
+>x : any
+>x : any
+>D1 : D1
+
+    return true;
+>true : boolean
+}
+
+var c1: C1;
+>c1 : C1
+>C1 : C1
+
+var c2: C2;
+>c2 : C2
+>C2 : C2
+
+var d1: D1;
+>d1 : D1
+>D1 : D1
+
+var c1Orc2: C1 | C2;
+>c1Orc2 : C1 | C2
+>C1 : C1
+>C2 : C2
+
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+>str = isC1(c1Orc2) && c1Orc2.p1 : string
+>str : string
+>isC1(c1Orc2) && c1Orc2.p1 : string
+>isC1(c1Orc2) : boolean
+>isC1 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p1 : string
+>c1Orc2 : C1
+>p1 : string
+
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+>num = isC2(c1Orc2) && c1Orc2.p2 : number
+>num : number
+>isC2(c1Orc2) && c1Orc2.p2 : number
+>isC2(c1Orc2) : boolean
+>isC2 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p2 : number
+>c1Orc2 : C2
+>p2 : number
+
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+>str = isD1(c1Orc2) && c1Orc2.p1 : string
+>str : string
+>isD1(c1Orc2) && c1Orc2.p1 : string
+>isD1(c1Orc2) : boolean
+>isD1 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p1 : string
+>c1Orc2 : D1
+>p1 : string
+
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+>num = isD1(c1Orc2) && c1Orc2.p3 : number
+>num : number
+>isD1(c1Orc2) && c1Orc2.p3 : number
+>isD1(c1Orc2) : boolean
+>isD1 : (x: any) => boolean
+>c1Orc2 : C1 | C2
+>c1Orc2.p3 : number
+>c1Orc2 : D1
+>p3 : number
+
+var c2Ord1: C2 | D1;
+>c2Ord1 : C2 | D1
+>C2 : C2
+>D1 : D1
+
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+>num = isC2(c2Ord1) && c2Ord1.p2 : number
+>num : number
+>isC2(c2Ord1) && c2Ord1.p2 : number
+>isC2(c2Ord1) : boolean
+>isC2 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1.p2 : number
+>c2Ord1 : C2
+>p2 : number
+
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+>num = isD1(c2Ord1) && c2Ord1.p3 : number
+>num : number
+>isD1(c2Ord1) && c2Ord1.p3 : number
+>isD1(c2Ord1) : boolean
+>isD1 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1.p3 : number
+>c2Ord1 : D1
+>p3 : number
+
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+>str = isD1(c2Ord1) && c2Ord1.p1 : string
+>str : string
+>isD1(c2Ord1) && c2Ord1.p1 : string
+>isD1(c2Ord1) : boolean
+>isD1 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1.p1 : string
+>c2Ord1 : D1
+>p1 : string
+
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
+>r2 : C2 | D1
+>C2 : C2
+>D1 : D1
+>isC1(c2Ord1) && c2Ord1 : D1
+>isC1(c2Ord1) : boolean
+>isC1 : (x: any) => boolean
+>c2Ord1 : C2 | D1
+>c2Ord1 : D1
+
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts
new file mode 100644
index 00000000000..93cfd90ceb5
--- /dev/null
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardFunction.ts
@@ -0,0 +1,56 @@
+
+class A {
+    propA: number;
+}
+
+class B {
+    propB: number;
+}
+
+class C extends A {
+    propC: number;
+}
+
+declare function isA(p1: any): p1 is A;
+declare function isB(p1: any): p1 is B;
+declare function isC(p1: any): p1 is C;
+
+declare function retC(): C;
+
+var a: A;
+var b: B;
+
+// Basic.
+if (isC(a)) {
+    a.propC;
+}
+
+// Sub type.
+var subType: C;
+if(isA(subType)) {
+    subType.propC;
+}
+
+// Union type.
+var union: A | B;
+if(isA(union)) {
+    union.propA;
+}
+
+// The parameter index and argument index for the type guard target is matching.
+// The type predicate type is assignable to the parameter type.
+declare function isC_multipleParams(p1, p2): p1 is C;
+if (isC_multipleParams(a, 0)) {
+    a.propC;
+}
+
+// Evaluations are asssignable to boolean.
+declare function acceptingBoolean(a: boolean);
+acceptingBoolean(isA(a));
+
+// Type predicates with different parameter name.
+declare function acceptingTypeGuardFunction(p1: (item) => item is A);
+acceptingTypeGuardFunction(isA);
+
+let union2: C | B;
+let union3: boolean | B = isA(union2) || union2;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts
new file mode 100644
index 00000000000..28a512aca6d
--- /dev/null
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts
@@ -0,0 +1,92 @@
+
+class A {
+    propA: number;
+}
+
+class B {
+    propB: number;
+}
+
+class C extends A {
+    propC: number;
+}
+
+function hasANonBooleanReturnStatement(x): x is A {
+    return '';
+}
+
+function hasTypeGuardTypeInsideTypeGuardType(x): x is x is A {
+    return true;
+}
+
+function hasMissingIsKeyword(): x {
+    return true;
+}
+
+function hasMissingTypeInTypeGuardType(x): x is {
+    return true;
+}
+
+function hasNonMatchingParameter(y): x is A {
+    return true;
+}
+
+function hasNonMatchingParameterType1(x: A): x is B {
+    return true;
+}
+
+function hasNonMatchingParameterType2(x: string): x is number {
+    return true;
+}
+
+function hasNonMathcingGenericType<T>(a: string): a is T[] {
+    return true;
+}
+
+let a: A;
+let b: B;
+
+declare function isB(p1): p1 is B;
+declare function isC(p1): p1 is C;
+declare function funA(p1: any, p2: any): p1 is B;
+declare function hasNoTypeGuard(x);
+
+// Passed argument is not the same as the one being guarded.
+if (isB(b)) {
+    a.propB;
+}
+
+// Parameter index and argument index for the type guard target is not matching.
+if (funA(0, a)) {
+    a.propB; // Error
+}
+
+// No type guard in if statement
+if (hasNoTypeGuard(a)) {
+    a.propB; 
+}
+
+// Type predicate type is not assignable
+declare function acceptingDifferentSignatureTypeGuardFunction(p1: (p1) => p1 is B);
+acceptingDifferentSignatureTypeGuardFunction(isC);
+
+// Boolean not assignable to type guard
+var assign1: (p1, p2) => p1 is A;
+assign1 = function(p1, p2): boolean {
+    return true;
+};
+
+// Must have matching parameter index
+var assign2: (p1, p2) => p1 is A;
+assign2 = function(p1, p2): p2 is A {
+    return true;
+};
+
+// No matching signature 
+var assign3: (p1, p2) => p1 is A;
+assign3 = function(p1, p2, p3): p1 is A {
+    return true;
+};
+
+// Type guard paramater referring to a binding pattern
+declare function destructureParameter({ p1, p2, p3 }): p1 is A;
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts
new file mode 100644
index 00000000000..d0e108b5735
--- /dev/null
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardFunctionGenerics.ts
@@ -0,0 +1,33 @@
+
+class A {
+    propA: number;
+}
+
+class B {
+    propB: number;
+}
+
+class C extends A {
+    propC: number;
+}
+
+declare function isB(p1): p1 is B;
+declare function isC(p1): p1 is C;
+declare function retC(x): C; 
+
+declare function funA<T>(p1: (p1) => T): T;
+declare function funB<T>(p1: (p1) => T, p2: any): p2 is T;
+declare function funC<T>(p1: (p1) => p1 is T): T;
+declare function funD<T>(p1: (p1) => p1 is T, p2: any): p2 is T;
+declare function funE<T, U>(p1: (p1) => p1 is T, p2: U): T;
+
+let a: A;
+let test1: boolean = funA(isB);
+if (funB(retC, a)) {
+    a.propC;
+}
+let test2: B = funC(isB);
+if (funD(isC, a)) {
+    a.propC;
+}
+let test3: B = funE(isB, 1);
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts
new file mode 100644
index 00000000000..9f5ca611ee9
--- /dev/null
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsType.ts
@@ -0,0 +1,37 @@
+
+class C1 {
+    p1: string;
+}
+class C2 {
+    p2: number;
+}
+class D1 extends C1 {
+    p3: number;
+}
+var str: string;
+var num: number;
+var strOrNum: string | number;
+
+function isC1(x: any): x is C1 {
+    return true;
+}
+
+function isC2(x: any): x is C2 {
+    return true;
+}
+
+function isD1(x: any): x is D1 {
+    return true;
+}
+
+var c1Orc2: C1 | C2;
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+
+var c2Ord1: C2 | D1;
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts
new file mode 100644
index 00000000000..a199aeb1e68
--- /dev/null
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardOfFormIsTypeOnInterfaces.ts
@@ -0,0 +1,46 @@
+
+interface C1 {
+    (): C1;
+    prototype: C1;
+    p1: string;
+}
+interface C2 {
+    (): C2;
+    prototype: C2;
+    p2: number;
+}
+interface D1 extends C1 {
+    prototype: D1;
+    p3: number;
+}
+var str: string;
+var num: number;
+var strOrNum: string | number;
+
+
+function isC1(x: any): x is C1 {
+    return true;
+}
+
+function isC2(x: any): x is C2 {
+    return true;
+}
+
+function isD1(x: any): x is D1 {
+    return true;
+}
+
+var c1: C1;
+var c2: C2;
+var d1: D1;
+var c1Orc2: C1 | C2;
+str = isC1(c1Orc2) && c1Orc2.p1; // C1
+num = isC2(c1Orc2) && c1Orc2.p2; // C2
+str = isD1(c1Orc2) && c1Orc2.p1; // D1
+num = isD1(c1Orc2) && c1Orc2.p3; // D1
+
+var c2Ord1: C2 | D1;
+num = isC2(c2Ord1) && c2Ord1.p2; // C2
+num = isD1(c2Ord1) && c2Ord1.p3; // D1
+str = isD1(c2Ord1) && c2Ord1.p1; // D1
+var r2: C2 | D1 = isC1(c2Ord1) && c2Ord1; // C2 | D1
\ No newline at end of file