diff --git a/tests/baselines/reference/typeofOperatorWithNumberType.errors.txt b/tests/baselines/reference/typeofOperatorWithNumberType.errors.txt
deleted file mode 100644
index b84d3798ab0..00000000000
--- a/tests/baselines/reference/typeofOperatorWithNumberType.errors.txt
+++ /dev/null
@@ -1,69 +0,0 @@
-tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts(50,1): error TS7028: Unused label.
-tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts(51,1): error TS7028: Unused label.
-tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts(52,1): error TS7028: Unused label.
-
-
-==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts (3 errors) ====
-    // typeof  operator on number type
-    var NUMBER: number;
-    var NUMBER1: number[] = [1, 2];
-    
-    function foo(): number { return 1; }
-    
-    class A {
-        public a: number;
-        static foo() { return 1; }
-    }
-    module M {
-        export var n: number;
-    }
-    
-    var objA = new A();
-    
-    // number type var
-    var ResultIsString1 = typeof NUMBER;
-    var ResultIsString2 = typeof NUMBER1;
-    
-    // number type literal
-    var ResultIsString3 = typeof 1;
-    var ResultIsString4 = typeof { x: 1, y: 2};
-    var ResultIsString5 = typeof { x: 1, y: (n: number) => { return n; } };
-    
-    // number type expressions
-    var ResultIsString6 = typeof objA.a;
-    var ResultIsString7 = typeof M.n;
-    var ResultIsString8 = typeof NUMBER1[0];
-    var ResultIsString9 = typeof foo();
-    var ResultIsString10 = typeof A.foo();
-    var ResultIsString11 = typeof (NUMBER + NUMBER);
-    
-    // multiple typeof  operators
-    var ResultIsString12 = typeof typeof NUMBER;
-    var ResultIsString13 = typeof typeof typeof (NUMBER + NUMBER);
-    
-    // miss assignment operators
-    typeof 1;
-    typeof NUMBER;
-    typeof NUMBER1;
-    typeof foo();
-    typeof objA.a;
-    typeof M.n;
-    typeof objA.a, M.n;
-    
-    // use typeof in type query
-    var z: number;
-    var x: number[];
-    z: typeof NUMBER;
-    ~
-!!! error TS7028: Unused label.
-    x: typeof NUMBER1;
-    ~
-!!! error TS7028: Unused label.
-    r: typeof foo;
-    ~
-!!! error TS7028: Unused label.
-    var y = { a: 1, b: 2 };
-    z: typeof y.a;
-    z: typeof objA.a;
-    z: typeof A.foo;
-    z: typeof M.n;
\ No newline at end of file
diff --git a/tests/baselines/reference/typeofOperatorWithNumberType.symbols b/tests/baselines/reference/typeofOperatorWithNumberType.symbols
new file mode 100644
index 00000000000..df49b7dccb6
--- /dev/null
+++ b/tests/baselines/reference/typeofOperatorWithNumberType.symbols
@@ -0,0 +1,168 @@
+=== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts ===
+// typeof  operator on number type
+var NUMBER: number;
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+var NUMBER1: number[] = [1, 2];
+>NUMBER1 : Symbol(NUMBER1, Decl(typeofOperatorWithNumberType.ts, 2, 3))
+
+function foo(): number { return 1; }
+>foo : Symbol(foo, Decl(typeofOperatorWithNumberType.ts, 2, 31))
+
+class A {
+>A : Symbol(A, Decl(typeofOperatorWithNumberType.ts, 4, 36))
+
+    public a: number;
+>a : Symbol(a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+
+    static foo() { return 1; }
+>foo : Symbol(A.foo, Decl(typeofOperatorWithNumberType.ts, 7, 21))
+}
+module M {
+>M : Symbol(M, Decl(typeofOperatorWithNumberType.ts, 9, 1))
+
+    export var n: number;
+>n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+}
+
+var objA = new A();
+>objA : Symbol(objA, Decl(typeofOperatorWithNumberType.ts, 14, 3))
+>A : Symbol(A, Decl(typeofOperatorWithNumberType.ts, 4, 36))
+
+// number type var
+var ResultIsString1 = typeof NUMBER;
+>ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithNumberType.ts, 17, 3))
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+var ResultIsString2 = typeof NUMBER1;
+>ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithNumberType.ts, 18, 3))
+>NUMBER1 : Symbol(NUMBER1, Decl(typeofOperatorWithNumberType.ts, 2, 3))
+
+// number type literal
+var ResultIsString3 = typeof 1;
+>ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithNumberType.ts, 21, 3))
+
+var ResultIsString4 = typeof { x: 1, y: 2};
+>ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithNumberType.ts, 22, 3))
+>x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 22, 30))
+>y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 22, 36))
+
+var ResultIsString5 = typeof { x: 1, y: (n: number) => { return n; } };
+>ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithNumberType.ts, 23, 3))
+>x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 23, 30))
+>y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 23, 36))
+>n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 23, 41))
+>n : Symbol(n, Decl(typeofOperatorWithNumberType.ts, 23, 41))
+
+// number type expressions
+var ResultIsString6 = typeof objA.a;
+>ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithNumberType.ts, 26, 3))
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithNumberType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+
+var ResultIsString7 = typeof M.n;
+>ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithNumberType.ts, 27, 3))
+>M.n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithNumberType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+
+var ResultIsString8 = typeof NUMBER1[0];
+>ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithNumberType.ts, 28, 3))
+>NUMBER1 : Symbol(NUMBER1, Decl(typeofOperatorWithNumberType.ts, 2, 3))
+
+var ResultIsString9 = typeof foo();
+>ResultIsString9 : Symbol(ResultIsString9, Decl(typeofOperatorWithNumberType.ts, 29, 3))
+>foo : Symbol(foo, Decl(typeofOperatorWithNumberType.ts, 2, 31))
+
+var ResultIsString10 = typeof A.foo();
+>ResultIsString10 : Symbol(ResultIsString10, Decl(typeofOperatorWithNumberType.ts, 30, 3))
+>A.foo : Symbol(A.foo, Decl(typeofOperatorWithNumberType.ts, 7, 21))
+>A : Symbol(A, Decl(typeofOperatorWithNumberType.ts, 4, 36))
+>foo : Symbol(A.foo, Decl(typeofOperatorWithNumberType.ts, 7, 21))
+
+var ResultIsString11 = typeof (NUMBER + NUMBER);
+>ResultIsString11 : Symbol(ResultIsString11, Decl(typeofOperatorWithNumberType.ts, 31, 3))
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+// multiple typeof  operators
+var ResultIsString12 = typeof typeof NUMBER;
+>ResultIsString12 : Symbol(ResultIsString12, Decl(typeofOperatorWithNumberType.ts, 34, 3))
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+var ResultIsString13 = typeof typeof typeof (NUMBER + NUMBER);
+>ResultIsString13 : Symbol(ResultIsString13, Decl(typeofOperatorWithNumberType.ts, 35, 3))
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+// miss assignment operators
+typeof 1;
+typeof NUMBER;
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+typeof NUMBER1;
+>NUMBER1 : Symbol(NUMBER1, Decl(typeofOperatorWithNumberType.ts, 2, 3))
+
+typeof foo();
+>foo : Symbol(foo, Decl(typeofOperatorWithNumberType.ts, 2, 31))
+
+typeof objA.a;
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithNumberType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+
+typeof M.n;
+>M.n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithNumberType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+
+typeof objA.a, M.n;
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithNumberType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+>M.n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithNumberType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+
+// use typeof in type query
+var z: number;
+>z : Symbol(z, Decl(typeofOperatorWithNumberType.ts, 47, 3))
+
+var x: number[];
+>x : Symbol(x, Decl(typeofOperatorWithNumberType.ts, 48, 3))
+
+z: typeof NUMBER;
+>NUMBER : Symbol(NUMBER, Decl(typeofOperatorWithNumberType.ts, 1, 3))
+
+x: typeof NUMBER1;
+>NUMBER1 : Symbol(NUMBER1, Decl(typeofOperatorWithNumberType.ts, 2, 3))
+
+r: typeof foo;
+>foo : Symbol(foo, Decl(typeofOperatorWithNumberType.ts, 2, 31))
+
+var y = { a: 1, b: 2 };
+>y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 52, 3))
+>a : Symbol(a, Decl(typeofOperatorWithNumberType.ts, 52, 9))
+>b : Symbol(b, Decl(typeofOperatorWithNumberType.ts, 52, 15))
+
+z: typeof y.a;
+>y.a : Symbol(a, Decl(typeofOperatorWithNumberType.ts, 52, 9))
+>y : Symbol(y, Decl(typeofOperatorWithNumberType.ts, 52, 3))
+>a : Symbol(a, Decl(typeofOperatorWithNumberType.ts, 52, 9))
+
+z: typeof objA.a;
+>objA.a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+>objA : Symbol(objA, Decl(typeofOperatorWithNumberType.ts, 14, 3))
+>a : Symbol(A.a, Decl(typeofOperatorWithNumberType.ts, 6, 9))
+
+z: typeof A.foo;
+>A.foo : Symbol(A.foo, Decl(typeofOperatorWithNumberType.ts, 7, 21))
+>A : Symbol(A, Decl(typeofOperatorWithNumberType.ts, 4, 36))
+>foo : Symbol(A.foo, Decl(typeofOperatorWithNumberType.ts, 7, 21))
+
+z: typeof M.n;
+>M.n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+>M : Symbol(M, Decl(typeofOperatorWithNumberType.ts, 9, 1))
+>n : Symbol(M.n, Decl(typeofOperatorWithNumberType.ts, 11, 14))
+
diff --git a/tests/baselines/reference/typeofOperatorWithNumberType.types b/tests/baselines/reference/typeofOperatorWithNumberType.types
new file mode 100644
index 00000000000..b80e6b1d4a8
--- /dev/null
+++ b/tests/baselines/reference/typeofOperatorWithNumberType.types
@@ -0,0 +1,233 @@
+=== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts ===
+// typeof  operator on number type
+var NUMBER: number;
+>NUMBER : number
+
+var NUMBER1: number[] = [1, 2];
+>NUMBER1 : number[]
+>[1, 2] : number[]
+>1 : number
+>2 : number
+
+function foo(): number { return 1; }
+>foo : () => number
+>1 : number
+
+class A {
+>A : A
+
+    public a: number;
+>a : number
+
+    static foo() { return 1; }
+>foo : () => number
+>1 : number
+}
+module M {
+>M : typeof M
+
+    export var n: number;
+>n : number
+}
+
+var objA = new A();
+>objA : A
+>new A() : A
+>A : typeof A
+
+// number type var
+var ResultIsString1 = typeof NUMBER;
+>ResultIsString1 : string
+>typeof NUMBER : string
+>NUMBER : number
+
+var ResultIsString2 = typeof NUMBER1;
+>ResultIsString2 : string
+>typeof NUMBER1 : string
+>NUMBER1 : number[]
+
+// number type literal
+var ResultIsString3 = typeof 1;
+>ResultIsString3 : string
+>typeof 1 : string
+>1 : number
+
+var ResultIsString4 = typeof { x: 1, y: 2};
+>ResultIsString4 : string
+>typeof { x: 1, y: 2} : string
+>{ x: 1, y: 2} : { x: number; y: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+
+var ResultIsString5 = typeof { x: 1, y: (n: number) => { return n; } };
+>ResultIsString5 : string
+>typeof { x: 1, y: (n: number) => { return n; } } : string
+>{ x: 1, y: (n: number) => { return n; } } : { x: number; y: (n: number) => number; }
+>x : number
+>1 : number
+>y : (n: number) => number
+>(n: number) => { return n; } : (n: number) => number
+>n : number
+>n : number
+
+// number type expressions
+var ResultIsString6 = typeof objA.a;
+>ResultIsString6 : string
+>typeof objA.a : string
+>objA.a : number
+>objA : A
+>a : number
+
+var ResultIsString7 = typeof M.n;
+>ResultIsString7 : string
+>typeof M.n : string
+>M.n : number
+>M : typeof M
+>n : number
+
+var ResultIsString8 = typeof NUMBER1[0];
+>ResultIsString8 : string
+>typeof NUMBER1[0] : string
+>NUMBER1[0] : number
+>NUMBER1 : number[]
+>0 : number
+
+var ResultIsString9 = typeof foo();
+>ResultIsString9 : string
+>typeof foo() : string
+>foo() : number
+>foo : () => number
+
+var ResultIsString10 = typeof A.foo();
+>ResultIsString10 : string
+>typeof A.foo() : string
+>A.foo() : number
+>A.foo : () => number
+>A : typeof A
+>foo : () => number
+
+var ResultIsString11 = typeof (NUMBER + NUMBER);
+>ResultIsString11 : string
+>typeof (NUMBER + NUMBER) : string
+>(NUMBER + NUMBER) : number
+>NUMBER + NUMBER : number
+>NUMBER : number
+>NUMBER : number
+
+// multiple typeof  operators
+var ResultIsString12 = typeof typeof NUMBER;
+>ResultIsString12 : string
+>typeof typeof NUMBER : string
+>typeof NUMBER : string
+>NUMBER : number
+
+var ResultIsString13 = typeof typeof typeof (NUMBER + NUMBER);
+>ResultIsString13 : string
+>typeof typeof typeof (NUMBER + NUMBER) : string
+>typeof typeof (NUMBER + NUMBER) : string
+>typeof (NUMBER + NUMBER) : string
+>(NUMBER + NUMBER) : number
+>NUMBER + NUMBER : number
+>NUMBER : number
+>NUMBER : number
+
+// miss assignment operators
+typeof 1;
+>typeof 1 : string
+>1 : number
+
+typeof NUMBER;
+>typeof NUMBER : string
+>NUMBER : number
+
+typeof NUMBER1;
+>typeof NUMBER1 : string
+>NUMBER1 : number[]
+
+typeof foo();
+>typeof foo() : string
+>foo() : number
+>foo : () => number
+
+typeof objA.a;
+>typeof objA.a : string
+>objA.a : number
+>objA : A
+>a : number
+
+typeof M.n;
+>typeof M.n : string
+>M.n : number
+>M : typeof M
+>n : number
+
+typeof objA.a, M.n;
+>typeof objA.a, M.n : number
+>typeof objA.a : string
+>objA.a : number
+>objA : A
+>a : number
+>M.n : number
+>M : typeof M
+>n : number
+
+// use typeof in type query
+var z: number;
+>z : number
+
+var x: number[];
+>x : number[]
+
+z: typeof NUMBER;
+>z : any
+>typeof NUMBER : string
+>NUMBER : number
+
+x: typeof NUMBER1;
+>x : any
+>typeof NUMBER1 : string
+>NUMBER1 : number[]
+
+r: typeof foo;
+>r : any
+>typeof foo : string
+>foo : () => number
+
+var y = { a: 1, b: 2 };
+>y : { a: number; b: number; }
+>{ a: 1, b: 2 } : { a: number; b: number; }
+>a : number
+>1 : number
+>b : number
+>2 : number
+
+z: typeof y.a;
+>z : any
+>typeof y.a : string
+>y.a : number
+>y : { a: number; b: number; }
+>a : number
+
+z: typeof objA.a;
+>z : any
+>typeof objA.a : string
+>objA.a : number
+>objA : A
+>a : number
+
+z: typeof A.foo;
+>z : any
+>typeof A.foo : string
+>A.foo : () => number
+>A : typeof A
+>foo : () => number
+
+z: typeof M.n;
+>z : any
+>typeof M.n : string
+>M.n : number
+>M : typeof M
+>n : number
+
diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts
index 06ac3e29784..81687e4f860 100644
--- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts
@@ -1,3 +1,4 @@
+// @allowUnusedLabels: true
 // typeof  operator on number type
 var NUMBER: number;
 var NUMBER1: number[] = [1, 2];