Accepting new baselines

tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.symbols

@@ -1,57 +0,0 @@
-=== tests/cases/compiler/map1.ts ===
-
-import { Observable } from "./observable"
->Observable : Symbol(Observable, Decl(map1.ts, 1, 8))
-
-(<any>Observable.prototype).map = function() { }
->Observable.prototype : Symbol(Observable.prototype)
->Observable : Symbol(Observable, Decl(map1.ts, 1, 8))
->prototype : Symbol(Observable.prototype)
-
-declare module "./observable" {
-    interface I {x0}
->I : Symbol(I, Decl(map1.ts, 5, 31), Decl(map2.ts, 4, 31))
->x0 : Symbol(x0, Decl(map1.ts, 6, 17))
-}
-
-=== tests/cases/compiler/map2.ts ===
-import { Observable } from "./observable"
->Observable : Symbol(Observable, Decl(map2.ts, 0, 8))
-
-(<any>Observable.prototype).map = function() { }
->Observable.prototype : Symbol(Observable.prototype)
->Observable : Symbol(Observable, Decl(map2.ts, 0, 8))
->prototype : Symbol(Observable.prototype)
-
-declare module "./observable" {
-    interface I {x1}
->I : Symbol(I, Decl(map1.ts, 5, 31), Decl(map2.ts, 4, 31))
->x1 : Symbol(x1, Decl(map2.ts, 5, 17))
-}
-
-
-=== tests/cases/compiler/observable.ts ===
-export declare class Observable<T> {
->Observable : Symbol(Observable, Decl(observable.ts, 0, 0))
->T : Symbol(T, Decl(observable.ts, 0, 32))
-
-    filter(pred: (e:T) => boolean): Observable<T>;
->filter : Symbol(filter, Decl(observable.ts, 0, 36))
->pred : Symbol(pred, Decl(observable.ts, 1, 11))
->e : Symbol(e, Decl(observable.ts, 1, 18))
->T : Symbol(T, Decl(observable.ts, 0, 32))
->Observable : Symbol(Observable, Decl(observable.ts, 0, 0))
->T : Symbol(T, Decl(observable.ts, 0, 32))
-}
-
-=== tests/cases/compiler/main.ts ===
-import { Observable } from "./observable"
->Observable : Symbol(Observable, Decl(main.ts, 0, 8))
-
-import "./map1";
-import "./map2";
-
-let x: Observable<number>;
->x : Symbol(x, Decl(main.ts, 4, 3))
->Observable : Symbol(Observable, Decl(main.ts, 0, 8))
-

tests/baselines/reference/moduleAugmentationCollidingNamesInAugmentation1.types

@@ -1,69 +0,0 @@
-=== tests/cases/compiler/map1.ts ===
-
-import { Observable } from "./observable"
->Observable : typeof Observable
-
-(<any>Observable.prototype).map = function() { }
->(<any>Observable.prototype).map = function() { } : () => void
->(<any>Observable.prototype).map : any
->(<any>Observable.prototype) : any
-><any>Observable.prototype : any
->Observable.prototype : Observable<any>
->Observable : typeof Observable
->prototype : Observable<any>
->map : any
->function() { } : () => void
-
-declare module "./observable" {
-    interface I {x0}
->I : I
->x0 : any
-}
-
-=== tests/cases/compiler/map2.ts ===
-import { Observable } from "./observable"
->Observable : typeof Observable
-
-(<any>Observable.prototype).map = function() { }
->(<any>Observable.prototype).map = function() { } : () => void
->(<any>Observable.prototype).map : any
->(<any>Observable.prototype) : any
-><any>Observable.prototype : any
->Observable.prototype : Observable<any>
->Observable : typeof Observable
->prototype : Observable<any>
->map : any
->function() { } : () => void
-
-declare module "./observable" {
-    interface I {x1}
->I : I
->x1 : any
-}
-
-
-=== tests/cases/compiler/observable.ts ===
-export declare class Observable<T> {
->Observable : Observable<T>
->T : T
-
-    filter(pred: (e:T) => boolean): Observable<T>;
->filter : (pred: (e: T) => boolean) => Observable<T>
->pred : (e: T) => boolean
->e : T
->T : T
->Observable : Observable<T>
->T : T
-}
-
-=== tests/cases/compiler/main.ts ===
-import { Observable } from "./observable"
->Observable : typeof Observable
-
-import "./map1";
-import "./map2";
-
-let x: Observable<number>;
->x : Observable<number>
->Observable : Observable<T>
-

tests/baselines/reference/typeGuardInClass.errors.txt

@@ -0,0 +1,30 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardInClass.ts(6,17): error TS2322: Type 'string | number' is not assignable to type 'string'.
+  Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/expressions/typeGuards/typeGuardInClass.ts(13,17): error TS2322: Type 'string | number' is not assignable to type 'number'.
+  Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardInClass.ts (2 errors) ====
+    let x: string | number;
+    
+    if (typeof x === "string") {
+        let n = class {
+            constructor() {
+                let y: string = x;
+                    ~
+!!! error TS2322: Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
+            }
+        }
+    }
+    else {
+        let m = class {
+            constructor() {
+                let y: number = x;
+                    ~
+!!! error TS2322: Type 'string | number' is not assignable to type 'number'.
+!!! error TS2322:   Type 'string' is not assignable to type 'number'.
+            }
+        }
+    }
+    

tests/baselines/reference/typeGuardInClass.symbols

@@ -1,29 +0,0 @@
-=== tests/cases/conformance/expressions/typeGuards/typeGuardInClass.ts ===
-let x: string | number;
->x : Symbol(x, Decl(typeGuardInClass.ts, 0, 3))
-
-if (typeof x === "string") {
->x : Symbol(x, Decl(typeGuardInClass.ts, 0, 3))
-
-    let n = class {
->n : Symbol(n, Decl(typeGuardInClass.ts, 3, 7))
-
-        constructor() {
-            let y: string = x;
->y : Symbol(y, Decl(typeGuardInClass.ts, 5, 15))
->x : Symbol(x, Decl(typeGuardInClass.ts, 0, 3))
-        }
-    }
-}
-else {
-    let m = class {
->m : Symbol(m, Decl(typeGuardInClass.ts, 10, 7))
-
-        constructor() {
-            let y: number = x;
->y : Symbol(y, Decl(typeGuardInClass.ts, 12, 15))
->x : Symbol(x, Decl(typeGuardInClass.ts, 0, 3))
-        }
-    }
-}
-

tests/baselines/reference/typeGuardInClass.types

@@ -1,34 +0,0 @@
-=== tests/cases/conformance/expressions/typeGuards/typeGuardInClass.ts ===
-let x: string | number;
->x : string | number
-
-if (typeof x === "string") {
->typeof x === "string" : boolean
->typeof x : string
->x : string | number
->"string" : string
-
-    let n = class {
->n : typeof (Anonymous class)
->class {        constructor() {            let y: string = x;        }    } : typeof (Anonymous class)
-
-        constructor() {
-            let y: string = x;
->y : string
->x : string
-        }
-    }
-}
-else {
-    let m = class {
->m : typeof (Anonymous class)
->class {        constructor() {            let y: number = x;        }    } : typeof (Anonymous class)
-
-        constructor() {
-            let y: number = x;
->y : number
->x : number
-        }
-    }
-}
-

tests/baselines/reference/typeGuardsDefeat.errors.txt

@@ -0,0 +1,52 @@
+tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts(21,20): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts(21,24): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts(32,23): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts(32,27): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+
+
+==== tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts (4 errors) ====
+    // Also note that it is possible to defeat a type guard by calling a function that changes the 
+    // type of the guarded variable.
+    function foo(x: number | string) {
+        function f() {
+            x = 10;
+        }
+        if (typeof x === "string") {
+            f();
+            return x.length; // string
+        }
+        else {
+            return x++; // number
+        }
+    }
+    function foo2(x: number | string) {
+        if (typeof x === "string") {
+            return x.length; // string
+        }
+        else {
+            var f = function () {
+                return x * x;
+                       ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                           ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+            };
+        }
+        x = "hello";
+        f();
+    }
+    function foo3(x: number | string) {
+        if (typeof x === "string") {
+            return x.length; // string
+        }
+        else {
+            var f = () => x * x;
+                          ~
+!!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+                              ~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+        }
+        x = "hello";
+        f();
+    }
+    

tests/baselines/reference/typeGuardsDefeat.symbols

@@ -1,82 +0,0 @@
-=== tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts ===
-// Also note that it is possible to defeat a type guard by calling a function that changes the 
-// type of the guarded variable.
-function foo(x: number | string) {
->foo : Symbol(foo, Decl(typeGuardsDefeat.ts, 0, 0))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13))
-
-    function f() {
->f : Symbol(f, Decl(typeGuardsDefeat.ts, 2, 34))
-
-        x = 10;
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13))
-    }
-    if (typeof x === "string") {
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13))
-
-        f();
->f : Symbol(f, Decl(typeGuardsDefeat.ts, 2, 34))
-
-        return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
-    }
-    else {
-        return x++; // number
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13))
-    }
-}
-function foo2(x: number | string) {
->foo2 : Symbol(foo2, Decl(typeGuardsDefeat.ts, 13, 1))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
-
-    if (typeof x === "string") {
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
-
-        return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
-    }
-    else {
-        var f = function () {
->f : Symbol(f, Decl(typeGuardsDefeat.ts, 19, 11))
-
-            return x * x;
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
-
-        };
-    }
-    x = "hello";
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14))
-
-    f();
->f : Symbol(f, Decl(typeGuardsDefeat.ts, 19, 11))
-}
-function foo3(x: number | string) {
->foo3 : Symbol(foo3, Decl(typeGuardsDefeat.ts, 25, 1))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
-
-    if (typeof x === "string") {
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
-
-        return x.length; // string
->x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
->length : Symbol(String.length, Decl(lib.d.ts, --, --))
-    }
-    else {
-        var f = () => x * x;
->f : Symbol(f, Decl(typeGuardsDefeat.ts, 31, 11))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
-    }
-    x = "hello";
->x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14))
-
-    f();
->f : Symbol(f, Decl(typeGuardsDefeat.ts, 31, 11))
-}
-

tests/baselines/reference/typeGuardsDefeat.types

@@ -1,105 +0,0 @@
-=== tests/cases/conformance/expressions/typeGuards/typeGuardsDefeat.ts ===
-// Also note that it is possible to defeat a type guard by calling a function that changes the 
-// type of the guarded variable.
-function foo(x: number | string) {
->foo : (x: number | string) => number
->x : number | string
-
-    function f() {
->f : () => void
-
-        x = 10;
->x = 10 : number
->x : number | string
->10 : number
-    }
-    if (typeof x === "string") {
->typeof x === "string" : boolean
->typeof x : string
->x : number | string
->"string" : string
-
-        f();
->f() : void
->f : () => void
-
-        return x.length; // string
->x.length : number
->x : string
->length : number
-    }
-    else {
-        return x++; // number
->x++ : number
->x : number
-    }
-}
-function foo2(x: number | string) {
->foo2 : (x: number | string) => number
->x : number | string
-
-    if (typeof x === "string") {
->typeof x === "string" : boolean
->typeof x : string
->x : number | string
->"string" : string
-
-        return x.length; // string
->x.length : number
->x : string
->length : number
-    }
-    else {
-        var f = function () {
->f : () => number
->function () {            return x * x;        } : () => number
-
-            return x * x;
->x * x : number
->x : number
->x : number
-
-        };
-    }
-    x = "hello";
->x = "hello" : string
->x : number | string
->"hello" : string
-
-    f();
->f() : number
->f : () => number
-}
-function foo3(x: number | string) {
->foo3 : (x: number | string) => number
->x : number | string
-
-    if (typeof x === "string") {
->typeof x === "string" : boolean
->typeof x : string
->x : number | string
->"string" : string
-
-        return x.length; // string
->x.length : number
->x : string
->length : number
-    }
-    else {
-        var f = () => x * x;
->f : () => number
->() => x * x : () => number
->x * x : number
->x : number
->x : number
-    }
-    x = "hello";
->x = "hello" : string
->x : number | string
->"hello" : string
-
-    f();
->f() : number
->f : () => number
-}
-

tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols

@@ -27,9 +27,9 @@ function foo(x: number | string | boolean) {
 >toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         } ();
 }
@@ -60,9 +60,9 @@ function foo2(x: number | string | boolean) {
 >toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         } (x); // x here is narrowed to number | boolean
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14))
@@ -91,9 +91,9 @@ function foo3(x: number | string | boolean) {
 >toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         })();
 }
@@ -123,9 +123,9 @@ function foo4(x: number | string | boolean) {
 >toString : Symbol(Object.toString, Decl(lib.d.ts, --, --))
 
                 : x.toString(); // number
->x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 
         })(x); // x here is narrowed to number | boolean
 >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14))

tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.types

@@ -21,14 +21,14 @@ function foo(x: number | string | boolean) {
 >f : () => string
 
             var b = x; // number | boolean
->b : number | boolean
->x : number | boolean
+>b : number | string | boolean
+>x : number | string | boolean
 
             return typeof x === "boolean"
 >typeof x === "boolean"                ? x.toString() // boolean                : x.toString() : string
 >typeof x === "boolean" : boolean
 >typeof x : string
->x : number | boolean
+>x : number | string | boolean
 >"boolean" : string
 
                 ? x.toString() // boolean
@@ -40,7 +40,7 @@ function foo(x: number | string | boolean) {
                 : x.toString(); // number
 >x.toString() : string
 >x.toString : (radix?: number) => string
->x : number
+>x : number | string
 >toString : (radix?: number) => string
 
         } ();
@@ -66,14 +66,14 @@ function foo2(x: number | string | boolean) {
 >a : number | boolean
 
             var b = x; // new scope - number | boolean
->b : number | boolean
->x : number | boolean
+>b : number | string | boolean
+>x : number | string | boolean
 
             return typeof x === "boolean"
 >typeof x === "boolean"                ? x.toString() // boolean                : x.toString() : string
 >typeof x === "boolean" : boolean
 >typeof x : string
->x : number | boolean
+>x : number | string | boolean
 >"boolean" : string
 
                 ? x.toString() // boolean
@@ -85,7 +85,7 @@ function foo2(x: number | string | boolean) {
                 : x.toString(); // number
 >x.toString() : string
 >x.toString : (radix?: number) => string
->x : number
+>x : number | string
 >toString : (radix?: number) => string
 
         } (x); // x here is narrowed to number | boolean
@@ -111,14 +111,14 @@ function foo3(x: number | string | boolean) {
 >() => {            var b = x; // new scope - number | boolean            return typeof x === "boolean"                ? x.toString() // boolean                : x.toString(); // number        } : () => string
 
             var b = x; // new scope - number | boolean
->b : number | boolean
->x : number | boolean
+>b : number | string | boolean
+>x : number | string | boolean
 
             return typeof x === "boolean"
 >typeof x === "boolean"                ? x.toString() // boolean                : x.toString() : string
 >typeof x === "boolean" : boolean
 >typeof x : string
->x : number | boolean
+>x : number | string | boolean
 >"boolean" : string
 
                 ? x.toString() // boolean
@@ -130,7 +130,7 @@ function foo3(x: number | string | boolean) {
                 : x.toString(); // number
 >x.toString() : string
 >x.toString : (radix?: number) => string
->x : number
+>x : number | string
 >toString : (radix?: number) => string
 
         })();
@@ -156,14 +156,14 @@ function foo4(x: number | string | boolean) {
 >a : number | boolean
 
             var b = x; // new scope - number | boolean
->b : number | boolean
->x : number | boolean
+>b : number | string | boolean
+>x : number | string | boolean
 
             return typeof x === "boolean"
 >typeof x === "boolean"                ? x.toString() // boolean                : x.toString() : string
 >typeof x === "boolean" : boolean
 >typeof x : string
->x : number | boolean
+>x : number | string | boolean
 >"boolean" : string
 
                 ? x.toString() // boolean
@@ -175,7 +175,7 @@ function foo4(x: number | string | boolean) {
                 : x.toString(); // number
 >x.toString() : string
 >x.toString : (radix?: number) => string
->x : number
+>x : number | string
 >toString : (radix?: number) => string
 
         })(x); // x here is narrowed to number | boolean
@@ -200,8 +200,8 @@ function foo5(x: number | string | boolean) {
 >foo : () => void
 
             var z = x; // string
->z : string
->x : string
+>z : number | string | boolean
+>x : number | string | boolean
         }
     }
 }

tests/baselines/reference/typeGuardsInProperties.types

@@ -29,32 +29,32 @@ class C1 {
 >method : () => void
 
         strOrNum = typeof this.pp1 === "string" && this.pp1; // string | number
->strOrNum = typeof this.pp1 === "string" && this.pp1 : string | number
+>strOrNum = typeof this.pp1 === "string" && this.pp1 : string
 >strOrNum : string | number
->typeof this.pp1 === "string" && this.pp1 : string | number
+>typeof this.pp1 === "string" && this.pp1 : string
 >typeof this.pp1 === "string" : boolean
 >typeof this.pp1 : string
 >this.pp1 : string | number
 >this : this
 >pp1 : string | number
 >"string" : string
->this.pp1 : string | number
+>this.pp1 : string
 >this : this
->pp1 : string | number
+>pp1 : string
 
         strOrNum = typeof this.pp2 === "string" && this.pp2; // string | number
->strOrNum = typeof this.pp2 === "string" && this.pp2 : string | number
+>strOrNum = typeof this.pp2 === "string" && this.pp2 : string
 >strOrNum : string | number
->typeof this.pp2 === "string" && this.pp2 : string | number
+>typeof this.pp2 === "string" && this.pp2 : string
 >typeof this.pp2 === "string" : boolean
 >typeof this.pp2 : string
 >this.pp2 : string | number
 >this : this
 >pp2 : string | number
 >"string" : string
->this.pp2 : string | number
+>this.pp2 : string
 >this : this
->pp2 : string | number
+>pp2 : string
 
         strOrNum = typeof this.pp3 === "string" && this.pp3; // string | number
 >strOrNum = typeof this.pp3 === "string" && this.pp3 : string | number

tests/baselines/reference/typeGuardsOnClassProperty.errors.txt

@@ -1,34 +0,0 @@
-tests/cases/conformance/expressions/typeGuards/typeGuardsOnClassProperty.ts(14,70): error TS2339: Property 'join' does not exist on type 'string | string[]'.
-
-
-==== tests/cases/conformance/expressions/typeGuards/typeGuardsOnClassProperty.ts (1 errors) ====
-    // Note that type guards affect types of variables and parameters only and 
-    // have no effect on members of objects such as properties. 
-    
-    // Note that the class's property must be copied to a local variable for
-    // the type guard to have an effect
-    class D {
-        data: string | string[];
-        getData() {
-            var data = this.data;
-            return typeof data === "string" ? data : data.join(" ");
-        }
-    
-        getData1() {
-            return typeof this.data === "string" ? this.data : this.data.join(" ");
-                                                                         ~~~~
-!!! error TS2339: Property 'join' does not exist on type 'string | string[]'.
-        }
-    }
-    
-    var o: {
-        prop1: number|string;
-        prop2: boolean|string;
-    } = {
-            prop1: "string" ,
-            prop2: true
-        }
-    
-    if (typeof o.prop1 === "string" && o.prop1.toLowerCase()) {}
-    var prop1 = o.prop1;
-    if (typeof prop1 === "string" && prop1.toLocaleLowerCase()) { }

tests/baselines/reference/typeGuardsOnClassProperty.symbols

@@ -0,0 +1,86 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardsOnClassProperty.ts ===
+// Note that type guards affect types of variables and parameters only and 
+// have no effect on members of objects such as properties. 
+
+// Note that the class's property must be copied to a local variable for
+// the type guard to have an effect
+class D {
+>D : Symbol(D, Decl(typeGuardsOnClassProperty.ts, 0, 0))
+
+    data: string | string[];
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+
+    getData() {
+>getData : Symbol(getData, Decl(typeGuardsOnClassProperty.ts, 6, 28))
+
+        var data = this.data;
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 8, 11))
+>this.data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>this : Symbol(D, Decl(typeGuardsOnClassProperty.ts, 0, 0))
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+
+        return typeof data === "string" ? data : data.join(" ");
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 8, 11))
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 8, 11))
+>data.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 8, 11))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+    }
+
+    getData1() {
+>getData1 : Symbol(getData1, Decl(typeGuardsOnClassProperty.ts, 10, 5))
+
+        return typeof this.data === "string" ? this.data : this.data.join(" ");
+>this.data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>this : Symbol(D, Decl(typeGuardsOnClassProperty.ts, 0, 0))
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>this.data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>this : Symbol(D, Decl(typeGuardsOnClassProperty.ts, 0, 0))
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>this.data.join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+>this.data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>this : Symbol(D, Decl(typeGuardsOnClassProperty.ts, 0, 0))
+>data : Symbol(data, Decl(typeGuardsOnClassProperty.ts, 5, 9))
+>join : Symbol(Array.join, Decl(lib.d.ts, --, --))
+    }
+}
+
+var o: {
+>o : Symbol(o, Decl(typeGuardsOnClassProperty.ts, 17, 3))
+
+    prop1: number|string;
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+
+    prop2: boolean|string;
+>prop2 : Symbol(prop2, Decl(typeGuardsOnClassProperty.ts, 18, 25))
+
+} = {
+        prop1: "string" ,
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 20, 5))
+
+        prop2: true
+>prop2 : Symbol(prop2, Decl(typeGuardsOnClassProperty.ts, 21, 25))
+    }
+
+if (typeof o.prop1 === "string" && o.prop1.toLowerCase()) {}
+>o.prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+>o : Symbol(o, Decl(typeGuardsOnClassProperty.ts, 17, 3))
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+>o.prop1.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
+>o.prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+>o : Symbol(o, Decl(typeGuardsOnClassProperty.ts, 17, 3))
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --))
+
+var prop1 = o.prop1;
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 26, 3))
+>o.prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+>o : Symbol(o, Decl(typeGuardsOnClassProperty.ts, 17, 3))
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 17, 8))
+
+if (typeof prop1 === "string" && prop1.toLocaleLowerCase()) { }
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 26, 3))
+>prop1.toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, --, --))
+>prop1 : Symbol(prop1, Decl(typeGuardsOnClassProperty.ts, 26, 3))
+>toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, --, --))
+

tests/baselines/reference/typeGuardsOnClassProperty.types

@@ -0,0 +1,112 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardsOnClassProperty.ts ===
+// Note that type guards affect types of variables and parameters only and 
+// have no effect on members of objects such as properties. 
+
+// Note that the class's property must be copied to a local variable for
+// the type guard to have an effect
+class D {
+>D : D
+
+    data: string | string[];
+>data : string | string[]
+
+    getData() {
+>getData : () => string
+
+        var data = this.data;
+>data : string | string[]
+>this.data : string | string[]
+>this : this
+>data : string | string[]
+
+        return typeof data === "string" ? data : data.join(" ");
+>typeof data === "string" ? data : data.join(" ") : string
+>typeof data === "string" : boolean
+>typeof data : string
+>data : string | string[]
+>"string" : string
+>data : string
+>data.join(" ") : string
+>data.join : (separator?: string) => string
+>data : string[]
+>join : (separator?: string) => string
+>" " : string
+    }
+
+    getData1() {
+>getData1 : () => string
+
+        return typeof this.data === "string" ? this.data : this.data.join(" ");
+>typeof this.data === "string" ? this.data : this.data.join(" ") : string
+>typeof this.data === "string" : boolean
+>typeof this.data : string
+>this.data : string | string[]
+>this : this
+>data : string | string[]
+>"string" : string
+>this.data : string
+>this : this
+>data : string
+>this.data.join(" ") : string
+>this.data.join : (separator?: string) => string
+>this.data : string[]
+>this : this
+>data : string[]
+>join : (separator?: string) => string
+>" " : string
+    }
+}
+
+var o: {
+>o : { prop1: number | string; prop2: boolean | string; }
+
+    prop1: number|string;
+>prop1 : number | string
+
+    prop2: boolean|string;
+>prop2 : boolean | string
+
+} = {
+>{        prop1: "string" ,        prop2: true    } : { prop1: string; prop2: boolean; }
+
+        prop1: "string" ,
+>prop1 : string
+>"string" : string
+
+        prop2: true
+>prop2 : boolean
+>true : boolean
+    }
+
+if (typeof o.prop1 === "string" && o.prop1.toLowerCase()) {}
+>typeof o.prop1 === "string" && o.prop1.toLowerCase() : string
+>typeof o.prop1 === "string" : boolean
+>typeof o.prop1 : string
+>o.prop1 : number | string
+>o : { prop1: number | string; prop2: boolean | string; }
+>prop1 : number | string
+>"string" : string
+>o.prop1.toLowerCase() : string
+>o.prop1.toLowerCase : () => string
+>o.prop1 : string
+>o : { prop1: number | string; prop2: boolean | string; }
+>prop1 : string
+>toLowerCase : () => string
+
+var prop1 = o.prop1;
+>prop1 : number | string
+>o.prop1 : number | string
+>o : { prop1: number | string; prop2: boolean | string; }
+>prop1 : number | string
+
+if (typeof prop1 === "string" && prop1.toLocaleLowerCase()) { }
+>typeof prop1 === "string" && prop1.toLocaleLowerCase() : string
+>typeof prop1 === "string" : boolean
+>typeof prop1 : string
+>prop1 : number | string
+>"string" : string
+>prop1.toLocaleLowerCase() : string
+>prop1.toLocaleLowerCase : () => string
+>prop1 : string
+>toLocaleLowerCase : () => string
+