Merge branch 'master' into empty-set

tests/baselines/reference/APISample_compile.js

@@ -57,5 +57,5 @@ function compile(fileNames, options) {
 exports.compile = compile;
 compile(process.argv.slice(2), {
     noEmitOnError: true, noImplicitAny: true,
-    target: 1 /* ES5 */, module: 1 /* CommonJS */
+    target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS
 });

tests/baselines/reference/APISample_linter.js

@@ -75,28 +75,28 @@ function delint(sourceFile) {
     delintNode(sourceFile);
     function delintNode(node) {
         switch (node.kind) {
-            case 199 /* ForStatement */:
-            case 200 /* ForInStatement */:
-            case 198 /* WhileStatement */:
-            case 197 /* DoStatement */:
-                if (node.statement.kind !== 192 /* Block */) {
+            case ts.SyntaxKind.ForStatement:
+            case ts.SyntaxKind.ForInStatement:
+            case ts.SyntaxKind.WhileStatement:
+            case ts.SyntaxKind.DoStatement:
+                if (node.statement.kind !== ts.SyntaxKind.Block) {
                     report(node, "A looping statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 196 /* IfStatement */:
+            case ts.SyntaxKind.IfStatement:
                 var ifStatement = node;
-                if (ifStatement.thenStatement.kind !== 192 /* Block */) {
+                if (ifStatement.thenStatement.kind !== ts.SyntaxKind.Block) {
                     report(ifStatement.thenStatement, "An if statement's contents should be wrapped in a block body.");
                 }
                 if (ifStatement.elseStatement &&
-                    ifStatement.elseStatement.kind !== 192 /* Block */ &&
-                    ifStatement.elseStatement.kind !== 196 /* IfStatement */) {
+                    ifStatement.elseStatement.kind !== ts.SyntaxKind.Block &&
+                    ifStatement.elseStatement.kind !== ts.SyntaxKind.IfStatement) {
                     report(ifStatement.elseStatement, "An else statement's contents should be wrapped in a block body.");
                 }
                 break;
-            case 181 /* BinaryExpression */:
+            case ts.SyntaxKind.BinaryExpression:
                 var op = node.operatorToken.kind;
-                if (op === 30 /* EqualsEqualsToken */ || op == 31 /* ExclamationEqualsToken */) {
+                if (op === ts.SyntaxKind.EqualsEqualsToken || op == ts.SyntaxKind.ExclamationEqualsToken) {
                     report(node, "Use '===' and '!=='.");
                 }
                 break;
@@ -112,7 +112,7 @@ exports.delint = delint;
 var fileNames = process.argv.slice(2);
 fileNames.forEach(function (fileName) {
     // Parse a file
-    var sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), 2 /* ES6 */, /*setParentNodes */ true);
+    var sourceFile = ts.createSourceFile(fileName, readFileSync(fileName).toString(), ts.ScriptTarget.ES6, /*setParentNodes */ true);
     // delint it
     delint(sourceFile);
 });

tests/baselines/reference/APISample_transform.js

@@ -24,5 +24,5 @@ console.log(JSON.stringify(result));
  */
 var ts = require("typescript");
 var source = "let x: string  = 'string'";
-var result = ts.transpile(source, { module: 1 /* CommonJS */ });
+var result = ts.transpile(source, { module: ts.ModuleKind.CommonJS });
 console.log(JSON.stringify(result));

tests/baselines/reference/APISample_watcher.js

@@ -181,4 +181,4 @@ function watch(rootFileNames, options) {
 var currentDirectoryFiles = fs.readdirSync(process.cwd()).
     filter(function (fileName) { return fileName.length >= 3 && fileName.substr(fileName.length - 3, 3) === ".ts"; });
 // Start the watcher
-watch(currentDirectoryFiles, { module: 1 /* CommonJS */ });
+watch(currentDirectoryFiles, { module: ts.ModuleKind.CommonJS });

tests/baselines/reference/ES3For-ofTypeCheck4.js

@@ -4,6 +4,6 @@ for (const v of union) { }
 
 //// [ES3For-ofTypeCheck4.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES3For-ofTypeCheck6.js

@@ -4,6 +4,6 @@ for (var v of union) { }
 
 //// [ES3For-ofTypeCheck6.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES5For-of24.js

@@ -6,7 +6,7 @@ for (var v of a) {
 
 //// [ES5For-of24.js]
 var a = [1, 2, 3];
-for (var _i = 0; _i < a.length; _i++) {
-    var v = a[_i];
-    var a_1 = 0;
+for (var _i = 0, a_1 = a; _i < a_1.length; _i++) {
+    var v = a_1[_i];
+    var a_2 = 0;
 }

tests/baselines/reference/ES5For-of25.js

@@ -7,8 +7,8 @@ for (var v of a) {
 
 //// [ES5For-of25.js]
 var a = [1, 2, 3];
-for (var _i = 0; _i < a.length; _i++) {
-    var v = a[_i];
+for (var _i = 0, a_1 = a; _i < a_1.length; _i++) {
+    var v = a_1[_i];
     v;
     a;
 }

tests/baselines/reference/ES5For-of25.js.map

@@ -1,2 +1,2 @@
 //// [ES5For-of25.js.map]
-{"version":3,"file":"ES5For-of25.js","sourceRoot":"","sources":["ES5For-of25.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAClB,GAAG,CAAC,CAAU,UAAC,EAAV,aAAK,EAAL,IAAU,CAAC;IAAX,IAAI,CAAC,GAAI,CAAC,IAAL;IACN,CAAC,CAAC;IACF,CAAC,CAAC;CACL"}
+{"version":3,"file":"ES5For-of25.js","sourceRoot":"","sources":["ES5For-of25.ts"],"names":[],"mappings":"AAAA,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAClB,GAAG,CAAC,CAAU,UAAC,EAAD,OAAC,EAAV,eAAK,EAAL,IAAU,CAAC;IAAX,IAAI,CAAC,UAAA;IACN,CAAC,CAAC;IACF,CAAC,CAAC;CACL"}

tests/baselines/reference/ES5For-of25.sourcemap.txt

@@ -21,7 +21,7 @@ sourceFile:ES5For-of25.ts
 10>               ^
 11>                ^
 12>                 ^
-13>                  ^^^^^^^^^^^^^^^^^^^^^^->
+13>                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^->
 1 >
 2 >var 
 3 >    a
@@ -47,17 +47,19 @@ sourceFile:ES5For-of25.ts
 11>Emitted(1, 18) Source(1, 18) + SourceIndex(0)
 12>Emitted(1, 19) Source(1, 19) + SourceIndex(0)
 ---
->>>for (var _i = 0; _i < a.length; _i++) {
+>>>for (var _i = 0, a_1 = a; _i < a_1.length; _i++) {
 1->
 2 >^^^
 3 >   ^
 4 >    ^
 5 >     ^^^^^^^^^^
 6 >               ^^
-7 >                 ^^^^^^^^^^^^^
-8 >                              ^^
-9 >                                ^^^^
-10>                                    ^
+7 >                 ^^^^^^^
+8 >                        ^^
+9 >                          ^^^^^^^^^^^^^^^
+10>                                         ^^
+11>                                           ^^^^
+12>                                               ^
 1->
   >
 2 >for
@@ -65,40 +67,38 @@ sourceFile:ES5For-of25.ts
 4 >    (var v of 
 5 >     a
 6 >               
-7 >                 var v
-8 >                              
-9 >                                var v of a
-10>                                    )
+7 >                 a
+8 >                        
+9 >                          var v
+10>                                         
+11>                                           var v of a
+12>                                               )
 1->Emitted(2, 1) Source(2, 1) + SourceIndex(0)
 2 >Emitted(2, 4) Source(2, 4) + SourceIndex(0)
 3 >Emitted(2, 5) Source(2, 5) + SourceIndex(0)
 4 >Emitted(2, 6) Source(2, 15) + SourceIndex(0)
 5 >Emitted(2, 16) Source(2, 16) + SourceIndex(0)
-6 >Emitted(2, 18) Source(2, 6) + SourceIndex(0)
-7 >Emitted(2, 31) Source(2, 11) + SourceIndex(0)
-8 >Emitted(2, 33) Source(2, 6) + SourceIndex(0)
-9 >Emitted(2, 37) Source(2, 16) + SourceIndex(0)
-10>Emitted(2, 38) Source(2, 17) + SourceIndex(0)
+6 >Emitted(2, 18) Source(2, 15) + SourceIndex(0)
+7 >Emitted(2, 25) Source(2, 16) + SourceIndex(0)
+8 >Emitted(2, 27) Source(2, 6) + SourceIndex(0)
+9 >Emitted(2, 42) Source(2, 11) + SourceIndex(0)
+10>Emitted(2, 44) Source(2, 6) + SourceIndex(0)
+11>Emitted(2, 48) Source(2, 16) + SourceIndex(0)
+12>Emitted(2, 49) Source(2, 17) + SourceIndex(0)
 ---
->>>    var v = a[_i];
+>>>    var v = a_1[_i];
 1 >^^^^
 2 >    ^^^^
 3 >        ^
-4 >         ^^^
-5 >            ^
-6 >             ^^^^
+4 >         ^^^^^^^^^^
 1 >
 2 >    var 
 3 >        v
-4 >          of 
-5 >            a
-6 >             
+4 >         
 1 >Emitted(3, 5) Source(2, 6) + SourceIndex(0)
 2 >Emitted(3, 9) Source(2, 10) + SourceIndex(0)
 3 >Emitted(3, 10) Source(2, 11) + SourceIndex(0)
-4 >Emitted(3, 13) Source(2, 15) + SourceIndex(0)
-5 >Emitted(3, 14) Source(2, 16) + SourceIndex(0)
-6 >Emitted(3, 18) Source(2, 11) + SourceIndex(0)
+4 >Emitted(3, 20) Source(2, 11) + SourceIndex(0)
 ---
 >>>    v;
 1 >^^^^

tests/baselines/reference/ES5For-of30.js

@@ -9,8 +9,8 @@ for ([a = 1, b = ""] of tuple) {
 //// [ES5For-of30.js]
 var a, b;
 var tuple = [2, "3"];
-for (var _i = 0; _i < tuple.length; _i++) {
-    _a = tuple[_i], _b = _a[0], a = _b === void 0 ? 1 : _b, _c = _a[1], b = _c === void 0 ? "" : _c;
+for (var _i = 0, tuple_1 = tuple; _i < tuple_1.length; _i++) {
+    _a = tuple_1[_i], _b = _a[0], a = _b === void 0 ? 1 : _b, _c = _a[1], b = _c === void 0 ? "" : _c;
     a;
     b;
 }

tests/baselines/reference/ES5For-ofTypeCheck11.js

@@ -6,6 +6,6 @@ for (v of union) { }
 //// [ES5For-ofTypeCheck11.js]
 var union;
 var v;
-for (var _i = 0; _i < union.length; _i++) {
-    v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    v = union_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck3.js

@@ -4,6 +4,6 @@ for (var v of tuple) { }
 
 //// [ES5For-ofTypeCheck3.js]
 var tuple = ["", 0];
-for (var _i = 0; _i < tuple.length; _i++) {
-    var v = tuple[_i];
+for (var _i = 0, tuple_1 = tuple; _i < tuple_1.length; _i++) {
+    var v = tuple_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck4.js

@@ -4,6 +4,6 @@ for (const v of union) { }
 
 //// [ES5For-ofTypeCheck4.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck5.js

@@ -4,6 +4,6 @@ for (var v of union) { }
 
 //// [ES5For-ofTypeCheck5.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck6.js

@@ -4,6 +4,6 @@ for (var v of union) { }
 
 //// [ES5For-ofTypeCheck6.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck7.js

@@ -4,6 +4,6 @@ for (var v of union) { }
 
 //// [ES5For-ofTypeCheck7.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck8.js

@@ -6,6 +6,6 @@ for (v of union) { }
 //// [ES5For-ofTypeCheck8.js]
 var union;
 var v;
-for (var _i = 0; _i < union.length; _i++) {
-    v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    v = union_1[_i];
 }

tests/baselines/reference/ES5For-ofTypeCheck9.js

@@ -4,6 +4,6 @@ for (let v of union) { }
 
 //// [ES5For-ofTypeCheck9.js]
 var union;
-for (var _i = 0; _i < union.length; _i++) {
-    var v = union[_i];
+for (var _i = 0, union_1 = union; _i < union_1.length; _i++) {
+    var v = union_1[_i];
 }

tests/baselines/reference/ES5for-of32.js

@@ -0,0 +1,23 @@
+//// [ES5for-of32.ts]
+
+var array = [1,2,3];
+var sum = 0;
+
+for (let num of array) {
+    if (sum === 0) {
+        array = [4,5,6]
+    }
+    
+    sum += num;
+}
+
+//// [ES5for-of32.js]
+var array = [1, 2, 3];
+var sum = 0;
+for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+    var num = array_1[_i];
+    if (sum === 0) {
+        array = [4, 5, 6];
+    }
+    sum += num;
+}

tests/baselines/reference/ES5for-of32.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts ===
+
+var array = [1,2,3];
+>array : Symbol(array, Decl(ES5for-of32.ts, 1, 3))
+
+var sum = 0;
+>sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3))
+
+for (let num of array) {
+>num : Symbol(num, Decl(ES5for-of32.ts, 4, 8))
+>array : Symbol(array, Decl(ES5for-of32.ts, 1, 3))
+
+    if (sum === 0) {
+>sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3))
+
+        array = [4,5,6]
+>array : Symbol(array, Decl(ES5for-of32.ts, 1, 3))
+    }
+    
+    sum += num;
+>sum : Symbol(sum, Decl(ES5for-of32.ts, 2, 3))
+>num : Symbol(num, Decl(ES5for-of32.ts, 4, 8))
+}

tests/baselines/reference/ES5for-of32.types

@@ -0,0 +1,36 @@
+=== tests/cases/conformance/statements/for-ofStatements/ES5for-of32.ts ===
+
+var array = [1,2,3];
+>array : number[]
+>[1,2,3] : number[]
+>1 : number
+>2 : number
+>3 : number
+
+var sum = 0;
+>sum : number
+>0 : number
+
+for (let num of array) {
+>num : number
+>array : number[]
+
+    if (sum === 0) {
+>sum === 0 : boolean
+>sum : number
+>0 : number
+
+        array = [4,5,6]
+>array = [4,5,6] : number[]
+>array : number[]
+>[4,5,6] : number[]
+>4 : number
+>5 : number
+>6 : number
+    }
+    
+    sum += num;
+>sum += num : number
+>sum : number
+>num : number
+}

tests/baselines/reference/ParameterList5.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/ParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/compiler/ParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/ParameterList5.ts(1,16): error TS2369: A parameter property is only allowed in a constructor implementation.
 tests/cases/compiler/ParameterList5.ts(1,29): error TS2304: Cannot find name 'C'.
 
@@ -6,7 +6,7 @@ tests/cases/compiler/ParameterList5.ts(1,29): error TS2304: Cannot find name 'C'
 ==== tests/cases/compiler/ParameterList5.ts (3 errors) ====
     function A(): (public B) => C {
                   ~~~~~~~~~~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
                    ~~~~~~~~
 !!! error TS2369: A parameter property is only allowed in a constructor implementation.
                                 ~

tests/baselines/reference/YieldExpression17_es6.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
@@ -8,6 +8,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): err
                   ~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                   ~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
                           ~~~~~
 !!! error TS1163: A 'yield' expression is only allowed in a generator body.

tests/baselines/reference/argumentsObjectIterator01_ES5.js

@@ -11,8 +11,8 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 //// [argumentsObjectIterator01_ES5.js]
 function doubleAndReturnAsArray(x, y, z) {
     var result = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        var arg = arguments[_i];
+    for (var _i = 0, arguments_1 = arguments; _i < arguments_1.length; _i++) {
+        var arg = arguments_1[_i];
         result.push(arg + arg);
     }
     return result;

tests/baselines/reference/assignmentLHSIsValue.errors.txt

@@ -13,6 +13,7 @@ tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(2
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(30,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(31,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(32,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(35,3): error TS7028: Unused label.
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(35,9): error TS1128: Declaration or statement expected.
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(38,2): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(38,6): error TS2364: Invalid left-hand side of assignment expression.
@@ -38,7 +39,7 @@ tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(6
 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(70,1): error TS2364: Invalid left-hand side of assignment expression.
 
 
-==== tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts (38 errors) ====
+==== tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts (39 errors) ====
     // expected error for all the LHS of assignments
     var value;
     
@@ -104,6 +105,8 @@ tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(7
     
     // object literals
     { a: 0} = value;
+      ~
+!!! error TS7028: Unused label.
             ~
 !!! error TS1128: Declaration or statement expected.
     

tests/baselines/reference/asyncArrowFunction10_es6.errors.txt

@@ -1,7 +1,7 @@
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,11): error TS2304: Cannot find name 'async'.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,17): error TS1005: ',' expected.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,20): error TS1005: '=' expected.
-tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,24): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,24): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(4,11): error TS2304: Cannot find name 'await'.
 
 
@@ -15,7 +15,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts
                        ~
 !!! error TS1005: '=' expected.
                            ~~~~~~~~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
        // Legal to use 'await' in a type context.
        var v: await;
               ~~~~~

tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt

@@ -1,6 +1,6 @@
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,24): error TS1005: '(' expected.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,29): error TS1005: '=' expected.
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,33): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,33): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,47): error TS1005: '=>' expected.
 
 
@@ -11,6 +11,6 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1
                                 ~
 !!! error TS1005: '=' expected.
                                     ~~~~~~~~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
                                                   ~
 !!! error TS1005: '=>' expected.

tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt

@@ -1,7 +1,7 @@
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,16): error TS1055: Type '{}' is not a valid async function return type.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(7,16): error TS1055: Type 'any' is not a valid async function return type.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,16): error TS1055: Type 'number' is not a valid async function return type.
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,16): error TS1055: Type 'PromiseLike<void>' is not a valid async function return type.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,16): error TS1055: Type 'PromiseLike' is not a valid async function return type.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,16): error TS1055: Type 'typeof Thenable' is not a valid async function return type.
   Type 'Thenable' is not assignable to type 'PromiseLike<any>'.
     Types of property 'then' are incompatible.
@@ -28,7 +28,7 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1
 !!! error TS1055: Type 'number' is not a valid async function return type.
     async function fn5(): PromiseLike<void> { } // error
                    ~~~
-!!! error TS1055: Type 'PromiseLike<void>' is not a valid async function return type.
+!!! error TS1055: Type 'PromiseLike' is not a valid async function return type.
     async function fn6(): Thenable { } // error
                    ~~~
 !!! error TS1055: Type 'typeof Thenable' is not a valid async function return type.

tests/baselines/reference/asyncGetter_es6.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,3): error TS1042: 'async' modifier cannot be used here.
-tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/async/es6/asyncGetter_es6.ts (2 errors) ====
@@ -8,6 +8,6 @@ tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get
       ~~~~~
 !!! error TS1042: 'async' modifier cannot be used here.
                 ~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
       }
     }

tests/baselines/reference/bestCommonTypeReturnStatement.js

@@ -1,4 +1,5 @@
 //// [bestCommonTypeReturnStatement.ts]
+
 interface IPromise<T> {
     then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
 }

tests/baselines/reference/bestCommonTypeReturnStatement.symbols

@@ -1,34 +1,35 @@
 === tests/cases/compiler/bestCommonTypeReturnStatement.ts ===
+
 interface IPromise<T> {
 >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19))
+>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19))
 
     then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise<any>;
->then : Symbol(then, Decl(bestCommonTypeReturnStatement.ts, 0, 23))
->successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 9))
->promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 1, 27))
->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19))
->errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 51))
->reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 1, 69))
+>then : Symbol(then, Decl(bestCommonTypeReturnStatement.ts, 1, 23))
+>successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 9))
+>promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 2, 27))
+>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19))
+>errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 51))
+>reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 2, 69))
 >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
 }
 
 function f() {
->f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 2, 1))
+>f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 3, 1))
 
     if (true) return b();
->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1))
+>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1))
 
     return d();
->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45))
+>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45))
 }
 
 
 function b(): IPromise<void> { return null; }
->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1))
+>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1))
 >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
 
 function d(): IPromise<any> { return null; }
->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45))
+>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45))
 >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0))
 

tests/baselines/reference/bestCommonTypeReturnStatement.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/bestCommonTypeReturnStatement.ts ===
+
 interface IPromise<T> {
 >IPromise : IPromise<T>
 >T : T

tests/baselines/reference/breakTarget3.js

@@ -1,4 +1,5 @@
 //// [breakTarget3.ts]
+
 target1:
 target2:
 while (true) {

tests/baselines/reference/breakTarget3.symbols

@@ -1,5 +1,6 @@
 === tests/cases/compiler/breakTarget3.ts ===
-target1:
+
+No type information for this code.target1:
 No type information for this code.target2:
 No type information for this code.while (true) {
 No type information for this code.  break target1;

tests/baselines/reference/breakTarget3.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/breakTarget3.ts ===
+
 target1:
 >target1 : any
 

tests/baselines/reference/breakTarget4.js

@@ -1,4 +1,5 @@
 //// [breakTarget4.ts]
+
 target1:
 target2:
 while (true) {

tests/baselines/reference/breakTarget4.symbols

@@ -1,5 +1,6 @@
 === tests/cases/compiler/breakTarget4.ts ===
-target1:
+
+No type information for this code.target1:
 No type information for this code.target2:
 No type information for this code.while (true) {
 No type information for this code.  break target2;

tests/baselines/reference/breakTarget4.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/breakTarget4.ts ===
+
 target1:
 >target1 : any
 

tests/baselines/reference/breakTarget5.errors.txt

@@ -1,7 +1,8 @@
-tests/cases/compiler/breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary.
+tests/cases/compiler/breakTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary.
 
 
 ==== tests/cases/compiler/breakTarget5.ts (1 errors) ====
+    
     target:
     while (true) {
       function f() {

tests/baselines/reference/breakTarget5.js

@@ -1,4 +1,5 @@
 //// [breakTarget5.ts]
+
 target:
 while (true) {
   function f() {

tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js

@@ -1,4 +1,5 @@
 //// [callSignatureWithoutReturnTypeAnnotationInference.ts]
+
 // Call signatures without a return type should infer one from the function body (if present)
 
 // Simple types

tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols

@@ -1,55 +1,56 @@
 === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts ===
+
 // Call signatures without a return type should infer one from the function body (if present)
 
 // Simple types
 function foo(x) {
 >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 3, 13))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 4, 13))
 
     return 1;
 }
 var r = foo(1);
->r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 3))
+>r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 3))
 >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0))
 
 function foo2(x) {
->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14))
+>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14))
 
     return foo(x);
 >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14))
 }
 var r2 = foo2(1);
->r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 3))
->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15))
+>r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 3))
+>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15))
 
 function foo3() {
->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17))
+>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17))
 
     return foo3();
->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17))
+>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17))
 }
 var r3 = foo3();
->r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 3))
->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17))
+>r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 3))
+>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17))
 
 function foo4<T>(x: T) {
->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16))
->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17))
->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14))
+>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16))
+>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17))
+>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14))
 
     return x;
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17))
 }
 var r4 = foo4(1);
->r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 3))
->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16))
+>r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 3))
+>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16))
 
 function foo5(x) {
->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 23, 14))
+>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 24, 14))
 
     if (true) {
         return 1;
@@ -58,17 +59,17 @@ function foo5(x) {
     }
 }
 var r5 = foo5(1);
->r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 3))
->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17))
+>r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 3))
+>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17))
 
 function foo6(x) {
->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 32, 14))
+>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 33, 14))
 
     try {
     }
     catch (e) {
->e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 35, 11))
+>e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 36, 11))
 
         return [];
     }
@@ -77,179 +78,179 @@ function foo6(x) {
     }
 }
 var r6 = foo6(1);
->r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 3))
->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17))
+>r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 3))
+>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17))
 
 function foo7(x) {
->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14))
+>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14))
 
     return typeof x;
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14))
 }
 var r7 = foo7(1);
->r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 3))
->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17))
+>r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 3))
+>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17))
 
 // object types
 function foo8(x: number) {
->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14))
+>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14))
 
     return { x: x };
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 12))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 52, 12))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14))
 }
 var r8 = foo8(1);
->r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 3))
->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17))
+>r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 3))
+>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17))
 
 interface I {
->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17))
+>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17))
 
     foo: string;
->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 55, 13))
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 56, 13))
 }
 function foo9(x: number) {
->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 14))
+>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 14))
 
     var i: I;
->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7))
->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17))
+>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7))
+>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17))
 
     return i;    
->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7))
+>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7))
 }
 var r9 = foo9(1);
->r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 3))
->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1))
+>r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 3))
+>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1))
 
 class C {
->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17))
+>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17))
 
     foo: string;
->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 64, 9))
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 65, 9))
 }
 function foo10(x: number) {
->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1))
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 15))
+>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 15))
 
     var c: C;
->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7))
->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17))
+>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7))
+>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17))
 
     return c;
->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7))
+>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7))
 }
 var r10 = foo10(1);
->r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 3))
->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1))
+>r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 3))
+>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1))
 
 module M {
->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19))
+>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19))
 
     export var x = 1;
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 14))
 
     export class C { foo: string }
->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 21))
->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 20))
+>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 21))
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 20))
 }
 function foo11() {
->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1))
+>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1))
 
     return M;
->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19))
+>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19))
 }
 var r11 = foo11();
->r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 3))
->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1))
+>r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 3))
+>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1))
 
 // merged declarations
 interface I2 {
->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1))
+>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1))
 
     x: number;
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 83, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 84, 14))
 }
 interface I2 {
->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1))
+>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1))
 
     y: number;
->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 14))
+>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 87, 14))
 }
 function foo12() {
->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1))
+>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1))
 
     var i2: I2;
->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7))
->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1))
+>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7))
+>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1))
 
     return i2;
->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7))
+>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7))
 }
 var r12 = foo12();
->r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 3))
->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1))
+>r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 3))
+>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1))
 
 function m1() { return 1; }
->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27))
+>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27))
 
 module m1 { export var y = 2; }
->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27))
->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 22))
+>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27))
+>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 22))
 
 function foo13() {
->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31))
+>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31))
 
     return m1;
->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27))
+>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27))
 }
 var r13 = foo13();
->r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 3))
->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31))
+>r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 3))
+>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31))
 
 class c1 {
->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1))
+>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1))
 
     foo: string;
->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 102, 10))
+>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 103, 10))
 
     constructor(x) { }
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 104, 16))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 16))
 }
 module c1 {
->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1))
+>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1))
 
     export var x = 1;
->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 107, 14))
+>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 14))
 }
 function foo14() {
->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1))
+>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1))
 
     return c1;
->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1))
+>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1))
 }
 var r14 = foo14();
->r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 3))
->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1))
+>r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 3))
+>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1))
 
 enum e1 { A }
->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13))
->A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 9))
+>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13))
+>A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 9))
 
 module e1 { export var y = 1; }
->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13))
->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 22))
+>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13))
+>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 22))
 
 function foo15() {
->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31))
+>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31))
 
     return e1;
->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13))
+>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13))
 }
 var r15 = foo15();
->r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 119, 3))
->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31))
+>r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 120, 3))
+>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31))
 

tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types

@@ -1,4 +1,5 @@
 === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts ===
+
 // Call signatures without a return type should infer one from the function body (if present)
 
 // Simple types

tests/baselines/reference/capturedLetConstInLoop9.js

@@ -75,9 +75,8 @@ function foo() {
                 break l0;
             }
             
-            return 100;
-            
             () => b
+            return 100;
         }
 
         
@@ -207,8 +206,8 @@ function foo() {
             if (b === 2) {
                 return "break-l0";
             }
-            return { value: 100 };
             (function () { return b; });
+            return { value: 100 };
         };
         for (var _d = 0, _e = []; _d < _e.length; _d++) {
             var b = _e[_d];

tests/baselines/reference/capturedLetConstInLoop9.symbols

@@ -142,10 +142,10 @@ function foo() {
                 break l0;
             }
             
-            return 100;
-            
             () => b
 >b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16))
+
+            return 100;
         }
 
         
@@ -171,25 +171,25 @@ function foo() {
 }
 
 function foo2() {
->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9.ts, 89, 1))
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9.ts, 88, 1))
 
     for (let x of []) {
->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
 
         if (x === 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
 
             break;
         }
         else if (x === 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
 
             continue;
         }
         
         while (1 === 1) {
             if (x) {
->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
 
                 break;
             }
@@ -199,17 +199,17 @@ function foo2() {
         }
         
         switch(x) {
->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
 
             case 1: break;
             case 2: continue;
         }
         
         for (let y of []) {
->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 114, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 113, 16))
 
             switch(y) {
->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 114, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 113, 16))
 
                 case 1: break;
                 case 2: continue;
@@ -219,50 +219,50 @@ function foo2() {
 }
 
 class C {
->C : Symbol(C, Decl(capturedLetConstInLoop9.ts, 121, 1))
+>C : Symbol(C, Decl(capturedLetConstInLoop9.ts, 120, 1))
 
     constructor(private N: number) { }
->N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16))
+>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16))
 
     foo() {
->foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 124, 38))
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 123, 38))
 
         for (let i = 0; i < 100; i++) {
->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
 
             let f = () => this.N * i;
->f : Symbol(f, Decl(capturedLetConstInLoop9.ts, 127, 15))
->this.N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16))
->this : Symbol(C, Decl(capturedLetConstInLoop9.ts, 121, 1))
->N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16))
->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
+>f : Symbol(f, Decl(capturedLetConstInLoop9.ts, 126, 15))
+>this.N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16))
+>this : Symbol(C, Decl(capturedLetConstInLoop9.ts, 120, 1))
+>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
         }
     }
 }
 
 function foo3 () {
->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9.ts, 130, 1))
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9.ts, 129, 1))
 
     let x = arguments.length;
->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 133, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 132, 7))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
 >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 
     for (let y of []) {
->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 134, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 133, 12))
 
         let z = arguments.length;
->z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 135, 11))
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 134, 11))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
 >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 
         (function() { return y + z + arguments.length; });
->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 134, 12))
->z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 135, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 133, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 134, 11))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
 >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))

tests/baselines/reference/capturedLetConstInLoop9.types

@@ -197,12 +197,12 @@ function foo() {
 >l0 : any
             }
             
-            return 100;
->100 : number
-            
             () => b
 >() => b : () => any
 >b : any
+
+            return 100;
+>100 : number
         }
 
         

tests/baselines/reference/capturedLetConstInLoop9_ES6.js

@@ -75,10 +75,8 @@ function foo() {
             if (b === 2) {
                 break l0;
             }
-            
-            return 100;
-            
             () => b
+            return 100;
         }
 
         
@@ -198,8 +196,8 @@ function foo() {
             if (b === 2) {
                 break l0;
             }
-            return 100;
             (() => b);
+            return 100;
         }
         (() => a);
     }

tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols

@@ -142,11 +142,10 @@ function foo() {
 
                 break l0;
             }
-            
-            return 100;
-            
             () => b
 >b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16))
+
+            return 100;
         }
 
         
@@ -172,25 +171,25 @@ function foo() {
 }
 
 function foo2() {
->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 90, 1))
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 88, 1))
 
     for (let x of []) {
->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
 
         if (x === 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
 
             break;
         }
         else if (x === 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
 
             continue;
         }
         
         while (1 === 1) {
             if (x) {
->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
 
                 break;
             }
@@ -200,17 +199,17 @@ function foo2() {
         }
         
         switch(x) {
->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
 
             case 1: break;
             case 2: continue;
         }
         
         for (let y of []) {
->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 115, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16))
 
             switch(y) {
->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 115, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16))
 
                 case 1: break;
                 case 2: continue;
@@ -220,50 +219,50 @@ function foo2() {
 }
 
 class C {
->C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 122, 1))
+>C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1))
 
     constructor(private N: number) { }
->N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16))
 
     foo() {
->foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 125, 38))
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 123, 38))
 
         for (let i = 0; i < 100; i++) {
->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
 
             let f = () => this.N * i;
->f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 128, 15))
->this.N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
->this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 122, 1))
->N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
+>f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 126, 15))
+>this.N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16))
+>this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1))
+>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
         }
     }
 }
 
 function foo3 () {
->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 131, 1))
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 129, 1))
 
     let x = arguments.length;
->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 134, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 132, 7))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
 >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 
     for (let y of []) {
->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 135, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12))
 
         let z = arguments.length;
->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 136, 11))
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
 >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 
         (function() { return y + z + arguments.length; });
->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 135, 12))
->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 136, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11))
 >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
 >arguments : Symbol(arguments)
 >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))

tests/baselines/reference/capturedLetConstInLoop9_ES6.types

@@ -197,13 +197,12 @@ function foo() {
                 break l0;
 >l0 : any
             }
-            
-            return 100;
->100 : number
-            
             () => b
 >() => b : () => any
 >b : any
+
+            return 100;
+>100 : number
         }
 
         

tests/baselines/reference/cf.errors.txt

@@ -0,0 +1,72 @@
+tests/cases/compiler/cf.ts(9,13): error TS7027: Unreachable code detected.
+tests/cases/compiler/cf.ts(21,17): error TS7027: Unreachable code detected.
+tests/cases/compiler/cf.ts(32,13): error TS7027: Unreachable code detected.
+tests/cases/compiler/cf.ts(36,13): error TS7027: Unreachable code detected.
+
+
+==== tests/cases/compiler/cf.ts (4 errors) ====
+    function f() {
+        var z;
+        var x=10;
+        var y=3;
+    
+        L1: for (var i=0;i<19;i++) {
+            if (y==7) {
+                continue L1;
+                x=11;
+                ~
+!!! error TS7027: Unreachable code detected.
+            }
+            if (y==3) {
+                y++;
+            }
+            else {
+                y--;
+            }
+            do {
+                y+=2;
+                if (y==20) {
+                    break;
+                    x=12;
+                    ~
+!!! error TS7027: Unreachable code detected.
+                }
+            } while (y<41);
+            y++;
+        }
+        while (y>2) {
+            y=y>>1;
+        }
+        L2: try {
+            L3: if (x<y) {
+                break L2;
+                x=13;
+                ~
+!!! error TS7027: Unreachable code detected.
+            }
+            else {
+                break L3;
+                x=14;
+                ~
+!!! error TS7027: Unreachable code detected.
+            }
+        }
+        catch (e) {
+            x++;
+        }    
+        finally {
+            x+=3;
+        }
+        y++;
+        for (var k=0;k<10;k++) {
+            z;
+            break;
+        }
+        for (k=0;k<10;k++) {
+            if (k==6) {
+                continue;
+            }
+            break;
+        }
+    }
+    

tests/baselines/reference/cf.symbols

@@ -1,111 +0,0 @@
-=== tests/cases/compiler/cf.ts ===
-function f() {
->f : Symbol(f, Decl(cf.ts, 0, 0))
-
-    var z;
->z : Symbol(z, Decl(cf.ts, 1, 7))
-
-    var x=10;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-
-    var y=3;
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-    L1: for (var i=0;i<19;i++) {
->i : Symbol(i, Decl(cf.ts, 5, 16))
->i : Symbol(i, Decl(cf.ts, 5, 16))
->i : Symbol(i, Decl(cf.ts, 5, 16))
-
-        if (y==7) {
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-            continue L1;
-            x=11;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-        }
-        if (y==3) {
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-            y++;
->y : Symbol(y, Decl(cf.ts, 3, 7))
-        }
-        else {
-            y--;
->y : Symbol(y, Decl(cf.ts, 3, 7))
-        }
-        do {
-            y+=2;
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-            if (y==20) {
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-                break;
-                x=12;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-            }
-        } while (y<41);
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-        y++;
->y : Symbol(y, Decl(cf.ts, 3, 7))
-    }
-    while (y>2) {
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-        y=y>>1;
->y : Symbol(y, Decl(cf.ts, 3, 7))
->y : Symbol(y, Decl(cf.ts, 3, 7))
-    }
-    L2: try {
-        L3: if (x<y) {
->x : Symbol(x, Decl(cf.ts, 2, 7))
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-            break L2;
-            x=13;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-        }
-        else {
-            break L3;
-            x=14;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-        }
-    }
-    catch (e) {
->e : Symbol(e, Decl(cf.ts, 38, 11))
-
-        x++;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-    }    
-    finally {
-        x+=3;
->x : Symbol(x, Decl(cf.ts, 2, 7))
-    }
-    y++;
->y : Symbol(y, Decl(cf.ts, 3, 7))
-
-    for (var k=0;k<10;k++) {
->k : Symbol(k, Decl(cf.ts, 45, 12))
->k : Symbol(k, Decl(cf.ts, 45, 12))
->k : Symbol(k, Decl(cf.ts, 45, 12))
-
-        z;
->z : Symbol(z, Decl(cf.ts, 1, 7))
-
-        break;
-    }
-    for (k=0;k<10;k++) {
->k : Symbol(k, Decl(cf.ts, 45, 12))
->k : Symbol(k, Decl(cf.ts, 45, 12))
->k : Symbol(k, Decl(cf.ts, 45, 12))
-
-        if (k==6) {
->k : Symbol(k, Decl(cf.ts, 45, 12))
-
-            continue;
-        }
-        break;
-    }
-}
-

tests/baselines/reference/cf.types

@@ -1,169 +0,0 @@
-=== tests/cases/compiler/cf.ts ===
-function f() {
->f : () => void
-
-    var z;
->z : any
-
-    var x=10;
->x : number
->10 : number
-
-    var y=3;
->y : number
->3 : number
-
-    L1: for (var i=0;i<19;i++) {
->L1 : any
->i : number
->0 : number
->i<19 : boolean
->i : number
->19 : number
->i++ : number
->i : number
-
-        if (y==7) {
->y==7 : boolean
->y : number
->7 : number
-
-            continue L1;
->L1 : any
-
-            x=11;
->x=11 : number
->x : number
->11 : number
-        }
-        if (y==3) {
->y==3 : boolean
->y : number
->3 : number
-
-            y++;
->y++ : number
->y : number
-        }
-        else {
-            y--;
->y-- : number
->y : number
-        }
-        do {
-            y+=2;
->y+=2 : number
->y : number
->2 : number
-
-            if (y==20) {
->y==20 : boolean
->y : number
->20 : number
-
-                break;
-                x=12;
->x=12 : number
->x : number
->12 : number
-            }
-        } while (y<41);
->y<41 : boolean
->y : number
->41 : number
-
-        y++;
->y++ : number
->y : number
-    }
-    while (y>2) {
->y>2 : boolean
->y : number
->2 : number
-
-        y=y>>1;
->y=y>>1 : number
->y : number
->y>>1 : number
->y : number
->1 : number
-    }
-    L2: try {
->L2 : any
-
-        L3: if (x<y) {
->L3 : any
->x<y : boolean
->x : number
->y : number
-
-            break L2;
->L2 : any
-
-            x=13;
->x=13 : number
->x : number
->13 : number
-        }
-        else {
-            break L3;
->L3 : any
-
-            x=14;
->x=14 : number
->x : number
->14 : number
-        }
-    }
-    catch (e) {
->e : any
-
-        x++;
->x++ : number
->x : number
-    }    
-    finally {
-        x+=3;
->x+=3 : number
->x : number
->3 : number
-    }
-    y++;
->y++ : number
->y : number
-
-    for (var k=0;k<10;k++) {
->k : number
->0 : number
->k<10 : boolean
->k : number
->10 : number
->k++ : number
->k : number
-
-        z;
->z : any
-
-        break;
-    }
-    for (k=0;k<10;k++) {
->k=0 : number
->k : number
->0 : number
->k<10 : boolean
->k : number
->10 : number
->k++ : number
->k : number
-
-        if (k==6) {
->k==6 : boolean
->k : number
->6 : number
-
-            continue;
-        }
-        break;
-    }
-}
-

tests/baselines/reference/commentEmitAtEndOfFile1.js

@@ -1,4 +1,5 @@
 //// [commentEmitAtEndOfFile1.ts]
+
 // test
 var f = ''
 // test #2

tests/baselines/reference/commentEmitAtEndOfFile1.symbols

@@ -1,17 +1,18 @@
 === tests/cases/compiler/commentEmitAtEndOfFile1.ts ===
+
 // test
 var f = ''
->f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 1, 3))
+>f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 2, 3))
 
 // test #2
 module foo {
->foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 1, 10))
+>foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 2, 10))
 
         function bar() { }
->bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 3, 12))
+>bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 4, 12))
 }
 // test #3
 module empty {
->empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 5, 1))
+>empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 6, 1))
 }
 // test #4

tests/baselines/reference/commentEmitAtEndOfFile1.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/commentEmitAtEndOfFile1.ts ===
+
 // test
 var f = ''
 >f : string

tests/baselines/reference/commentsAtEndOfFile1.js

@@ -1,4 +1,5 @@
 //// [commentsAtEndOfFile1.ts]
+
 Input:
 ;
 //Testing two

tests/baselines/reference/commentsAtEndOfFile1.symbols

@@ -1,5 +1,6 @@
 === tests/cases/compiler/commentsAtEndOfFile1.ts ===
-Input:
+
+No type information for this code.Input:
 No type information for this code.;
 No type information for this code.//Testing two
 No type information for this code.

tests/baselines/reference/commentsAtEndOfFile1.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/commentsAtEndOfFile1.ts ===
+
 Input:
 >Input : any
 

tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt

@@ -1,80 +1,81 @@
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(11,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(21,5): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(9,9): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(13,9): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(17,9): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(22,5): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(25,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(23,5): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(26,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(33,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(27,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(32,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(35,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(39,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(42,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(50,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(51,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(58,9): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(56,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(59,9): error TS1128: Declaration or statement expected.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(62,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(69,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(60,9): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(64,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(70,15): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(74,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(71,15): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(75,15): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(79,15): error TS1034: 'super' must be followed by an argument list or member access.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(76,15): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(80,15): error TS1034: 'super' must be followed by an argument list or member access.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(85,21): error TS1128: Declaration or statement expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(81,15): error TS1034: 'super' must be followed by an argument list or member access.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(86,21): error TS1128: Declaration or statement expected.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,11): error TS1005: ';' expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,21): error TS1128: Declaration or statement expected.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(88,11): error TS1005: ';' expected.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(91,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(95,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(89,11): error TS1005: ';' expected.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(93,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(96,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(109,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(110,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(123,1): error TS2364: Invalid left-hand side of assignment expression.
 
 
 ==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (74 errors) ====
+    
     // expected error for all the LHS of compound assignments (arithmetic and addition)
     var value;
     

tests/baselines/reference/compoundAssignmentLHSIsValue.js

@@ -1,4 +1,5 @@
 //// [compoundAssignmentLHSIsValue.ts]
+
 // expected error for all the LHS of compound assignments (arithmetic and addition)
 var value;
 

tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt

@@ -13,6 +13,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(38,1): error TS2364: Invalid left-hand side of assignment expression.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(39,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(43,3): error TS7028: Unused label.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(43,10): error TS1128: Declaration or statement expected.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(52,15): error TS1034: 'super' must be followed by an argument list or member access.
@@ -37,7 +38,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
 tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(85,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 
 
-==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (37 errors) ====
+==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (38 errors) ====
     // expected error for all the LHS of compound assignments (arithmetic and addition)
     var value;
     
@@ -111,6 +112,8 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm
     
     // object literals
     { a: 0 } **= value;
+      ~
+!!! error TS7028: Unused label.
              ~~~
 !!! error TS1128: Declaration or statement expected.
     

tests/baselines/reference/computedPropertyNames2_ES5.errors.txt

@@ -1,5 +1,5 @@
-tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(6,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
-tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(8,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(6,9): error TS2378: A 'get' accessor must return a value.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(8,16): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts (2 errors) ====
@@ -10,10 +10,10 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(8,1
         static [methodName]() { }
         get [accessorName]() { }
             ~~~~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
         set [accessorName](v) { }
         static get [accessorName]() { }
                    ~~~~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
         static set [accessorName](v) { }
     }

tests/baselines/reference/computedPropertyNames2_ES6.errors.txt

@@ -1,5 +1,5 @@
-tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(6,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
-tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(8,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(6,9): error TS2378: A 'get' accessor must return a value.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(8,16): error TS2378: A 'get' accessor must return a value.
 
 
 ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts (2 errors) ====
@@ -10,10 +10,10 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(8,1
         static [methodName]() { }
         get [accessorName]() { }
             ~~~~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
         set [accessorName](v) { }
         static get [accessorName]() { }
                    ~~~~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
         static set [accessorName](v) { }
     }

tests/baselines/reference/computedPropertyNames3_ES5.errors.txt

@@ -1,9 +1,9 @@
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
-tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,17): error TS1102: 'delete' cannot be called on an identifier in strict mode.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
-tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 
 
@@ -16,7 +16,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,1
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
         get [delete id]() { }
             ~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
             ~~~~~~~~~~~
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
                     ~~
@@ -26,7 +26,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,1
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
         static get [<String>""]() { }
                    ~~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
                    ~~~~~~~~~~~~
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
         static set [id.toString()](v) { }

tests/baselines/reference/computedPropertyNames3_ES6.errors.txt

@@ -1,9 +1,9 @@
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
-tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,9): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,17): error TS1102: 'delete' cannot be called on an identifier in strict mode.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
-tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,16): error TS2378: A 'get' accessor must return a value.
 tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
 
 
@@ -16,7 +16,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,1
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
         get [delete id]() { }
             ~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
             ~~~~~~~~~~~
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
                     ~~
@@ -26,7 +26,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,1
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
         static get [<String>""]() { }
                    ~~~~~~~~~~~~
-!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
+!!! error TS2378: A 'get' accessor must return a value.
                    ~~~~~~~~~~~~
 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
         static set [id.toString()](v) { }

tests/baselines/reference/conditionalExpressions2.js

@@ -1,4 +1,5 @@
 //// [conditionalExpressions2.ts]
+
 var a = false ? 1 : null;
 var b = false ? undefined : 0;
 var c = false ? 1 : 0;

tests/baselines/reference/conditionalExpressions2.symbols

@@ -1,33 +1,34 @@
 === tests/cases/compiler/conditionalExpressions2.ts ===
+
 var a = false ? 1 : null;
->a : Symbol(a, Decl(conditionalExpressions2.ts, 0, 3))
+>a : Symbol(a, Decl(conditionalExpressions2.ts, 1, 3))
 
 var b = false ? undefined : 0;
->b : Symbol(b, Decl(conditionalExpressions2.ts, 1, 3))
+>b : Symbol(b, Decl(conditionalExpressions2.ts, 2, 3))
 >undefined : Symbol(undefined)
 
 var c = false ? 1 : 0;
->c : Symbol(c, Decl(conditionalExpressions2.ts, 2, 3))
+>c : Symbol(c, Decl(conditionalExpressions2.ts, 3, 3))
 
 var d = false ? false : true;
->d : Symbol(d, Decl(conditionalExpressions2.ts, 3, 3))
+>d : Symbol(d, Decl(conditionalExpressions2.ts, 4, 3))
 
 var e = false ? "foo" : "bar";
->e : Symbol(e, Decl(conditionalExpressions2.ts, 4, 3))
+>e : Symbol(e, Decl(conditionalExpressions2.ts, 5, 3))
 
 var f = false ? null : undefined;
->f : Symbol(f, Decl(conditionalExpressions2.ts, 5, 3))
+>f : Symbol(f, Decl(conditionalExpressions2.ts, 6, 3))
 >undefined : Symbol(undefined)
 
 var g = true ? {g:5} : null;
->g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 3))
->g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 16))
+>g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 3))
+>g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 16))
 
 var h = [{h:5}, null];
->h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 3))
->h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 10))
+>h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 3))
+>h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 10))
 
 function i() { if (true) { return { x: 5 }; } else { return null; } }
->i : Symbol(i, Decl(conditionalExpressions2.ts, 7, 22))
->x : Symbol(x, Decl(conditionalExpressions2.ts, 8, 35))
+>i : Symbol(i, Decl(conditionalExpressions2.ts, 8, 22))
+>x : Symbol(x, Decl(conditionalExpressions2.ts, 9, 35))
 

tests/baselines/reference/conditionalExpressions2.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/conditionalExpressions2.ts ===
+
 var a = false ? 1 : null;
 >a : number
 >false ? 1 : null : number

tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt

@@ -1,8 +1,8 @@
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(1,5): error TS2300: Duplicate identifier 'foo'.
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,10): error TS2300: Duplicate identifier 'foo'.
-tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,10): error TS2300: Duplicate identifier 'foo'.
-tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 
 
 ==== tests/cases/compiler/conflictingTypeAnnotatedVar.ts (5 errors) ====
@@ -13,9 +13,9 @@ tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A funct
              ~~~
 !!! error TS2300: Duplicate identifier 'foo'.
                     ~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
     function foo(): number { }
              ~~~
 !!! error TS2300: Duplicate identifier 'foo'.
                     ~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.

tests/baselines/reference/constDeclarations-scopes.errors.txt

@@ -1,7 +1,9 @@
+tests/cases/compiler/constDeclarations-scopes.ts(13,5): error TS7027: Unreachable code detected.
+tests/cases/compiler/constDeclarations-scopes.ts(22,1): error TS7027: Unreachable code detected.
 tests/cases/compiler/constDeclarations-scopes.ts(28,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'.
 
 
-==== tests/cases/compiler/constDeclarations-scopes.ts (1 errors) ====
+==== tests/cases/compiler/constDeclarations-scopes.ts (3 errors) ====
     
     // global
     const c = "string";
@@ -15,6 +17,8 @@ tests/cases/compiler/constDeclarations-scopes.ts(28,7): error TS2410: All symbol
     }
     else { 
         const c = 0;
+        ~~~~~
+!!! error TS7027: Unreachable code detected.
         n = c;
     }
     
@@ -24,6 +28,8 @@ tests/cases/compiler/constDeclarations-scopes.ts(28,7): error TS2410: All symbol
     }
     
     do { 
+    ~~
+!!! error TS7027: Unreachable code detected.
        const c = 0;
         n = c;
     } while (true);

tests/baselines/reference/constructorReturnsInvalidType.errors.txt

@@ -1,11 +1,16 @@
+tests/cases/compiler/constructorReturnsInvalidType.ts(3,16): error TS2322: Type 'number' is not assignable to type 'X'.
+  Property 'foo' is missing in type 'Number'.
 tests/cases/compiler/constructorReturnsInvalidType.ts(3,16): error TS2409: Return type of constructor signature must be assignable to the instance type of the class
 
 
-==== tests/cases/compiler/constructorReturnsInvalidType.ts (1 errors) ====
+==== tests/cases/compiler/constructorReturnsInvalidType.ts (2 errors) ====
     class X {
         constructor() {
             return 1;
                    ~
+!!! error TS2322: Type 'number' is not assignable to type 'X'.
+!!! error TS2322:   Property 'foo' is missing in type 'Number'.
+                   ~
 !!! error TS2409: Return type of constructor signature must be assignable to the instance type of the class
         }
         foo() { }

tests/baselines/reference/constructorWithAssignableReturnExpression.errors.txt

@@ -1,8 +1,13 @@
+tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignableReturnExpression.ts(12,16): error TS2322: Type 'number' is not assignable to type 'D'.
+  Property 'x' is missing in type 'Number'.
 tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignableReturnExpression.ts(12,16): error TS2409: Return type of constructor signature must be assignable to the instance type of the class
+tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignableReturnExpression.ts(26,16): error TS2322: Type '{ x: number; }' is not assignable to type 'F<T>'.
+  Types of property 'x' are incompatible.
+    Type 'number' is not assignable to type 'T'.
 tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignableReturnExpression.ts(26,16): error TS2409: Return type of constructor signature must be assignable to the instance type of the class
 
 
-==== tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignableReturnExpression.ts (2 errors) ====
+==== tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignableReturnExpression.ts (4 errors) ====
     // a class constructor may return an expression, it must be assignable to the class instance type to be valid
     
     class C {
@@ -16,6 +21,9 @@ tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignabl
         constructor() {
             return 1; // error
                    ~
+!!! error TS2322: Type 'number' is not assignable to type 'D'.
+!!! error TS2322:   Property 'x' is missing in type 'Number'.
+                   ~
 !!! error TS2409: Return type of constructor signature must be assignable to the instance type of the class
         }
     }
@@ -32,6 +40,10 @@ tests/cases/conformance/classes/constructorDeclarations/constructorWithAssignabl
         constructor() {
             return { x: 1 }; // error
                    ~~~~~~~~
+!!! error TS2322: Type '{ x: number; }' is not assignable to type 'F<T>'.
+!!! error TS2322:   Types of property 'x' are incompatible.
+!!! error TS2322:     Type 'number' is not assignable to type 'T'.
+                   ~~~~~~~~
 !!! error TS2409: Return type of constructor signature must be assignable to the instance type of the class
         }
     }

tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt

@@ -1,89 +1,90 @@
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2304: Cannot find name 'module'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,28): error TS1005: ':' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,29): error TS1005: ',' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,18): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,26): error TS2304: Cannot find name 'bfs'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,30): error TS1005: '=' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(31,18): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,26): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,28): error TS2304: Cannot find name 'bfs'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(38,17): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,28): error TS2304: Cannot find name 'bfs'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,41): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,45): error TS1002: Unterminated string literal.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(47,17): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(49,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(53,13): error TS2304: Cannot find name 'console'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(58,5): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(69,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(72,37): error TS1127: Invalid character.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(81,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(89,23): error TS2364: Invalid left-hand side of assignment expression.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(105,29): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(108,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(138,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(141,32): error TS1005: '{' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(143,13): error TS1005: 'try' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,24): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,30): error TS1005: '(' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,31): error TS2304: Cannot find name 'Property'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(166,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(180,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(205,28): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(213,16): error TS2304: Cannot find name 'bool'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(218,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(223,23): error TS2304: Cannot find name 'bool'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(227,13): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(234,14): error TS1005: '{' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,9): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,16): error TS2304: Cannot find name 'method1'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,24): error TS2304: Cannot find name 'val'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,27): error TS1005: ',' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,28): error TS2304: Cannot find name 'number'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,36): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,9): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,16): error TS2304: Cannot find name 'method2'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,26): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(241,5): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(246,25): error TS2339: Property 'method1' does not exist on type 'B'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,9): error TS2390: Constructor implementation is missing.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,21): error TS2369: A parameter property is only allowed in a constructor implementation.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,44): error TS2369: A parameter property is only allowed in a constructor implementation.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,69): error TS1110: Type expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,9): error TS1128: Declaration or statement expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,16): error TS2304: Cannot find name 'Overloads'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,26): error TS2304: Cannot find name 'value'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,31): error TS1005: ',' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,33): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2304: Cannot find name 'module'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2503: Cannot find namespace 'module'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,19): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,35): error TS1005: ')' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,28): error TS1005: ':' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,29): error TS1005: ',' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,18): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,26): error TS2304: Cannot find name 'bfs'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(29,30): error TS1005: '=' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(32,18): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,26): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,28): error TS2304: Cannot find name 'bfs'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(36,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(39,17): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,28): error TS2304: Cannot find name 'bfs'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,41): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,45): error TS1002: Unterminated string literal.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(42,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(48,17): error TS2304: Cannot find name 'console'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(50,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(54,13): error TS2304: Cannot find name 'console'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(59,5): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(70,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(73,37): error TS1127: Invalid character.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(82,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,23): error TS2364: Invalid left-hand side of assignment expression.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(91,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,29): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(107,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(109,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(139,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(142,32): error TS1005: '{' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(144,13): error TS1005: 'try' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,24): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,30): error TS1005: '(' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,31): error TS2304: Cannot find name 'Property'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(167,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(206,28): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(214,16): error TS2304: Cannot find name 'bool'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(219,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(224,23): error TS2304: Cannot find name 'bool'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(228,13): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,14): error TS1005: '{' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,9): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,16): error TS2304: Cannot find name 'method1'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,24): error TS2304: Cannot find name 'val'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,27): error TS1005: ',' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,28): error TS2304: Cannot find name 'number'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,36): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,9): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,16): error TS2304: Cannot find name 'method2'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,26): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(242,5): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(247,25): error TS2339: Property 'method1' does not exist on type 'B'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,9): error TS2390: Constructor implementation is missing.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,21): error TS2369: A parameter property is only allowed in a constructor implementation.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,44): error TS2369: A parameter property is only allowed in a constructor implementation.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,69): error TS1110: Type expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,9): error TS1128: Declaration or statement expected.
 tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,16): error TS2304: Cannot find name 'Overloads'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,27): error TS1135: Argument expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS1005: '(' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,35): error TS2304: Cannot find name 'string'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,43): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,52): error TS2304: Cannot find name 'string'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,60): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,65): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,9): error TS2304: Cannot find name 'public'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS2304: Cannot find name 'DefaultValue'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,29): error TS2304: Cannot find name 'value'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,35): error TS1109: Expression expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,37): error TS2304: Cannot find name 'string'.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected.
-tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,26): error TS2304: Cannot find name 'value'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,31): error TS1005: ',' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,9): error TS1128: Declaration or statement expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,16): error TS2304: Cannot find name 'Overloads'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,27): error TS1135: Argument expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,33): error TS1005: '(' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,35): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,43): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,52): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,60): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,65): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,9): error TS2304: Cannot find name 'public'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS2304: Cannot find name 'DefaultValue'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,29): error TS2304: Cannot find name 'value'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,35): error TS1109: Expression expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,37): error TS2304: Cannot find name 'string'.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,55): error TS1005: ';' expected.
+tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(262,1): error TS1128: Declaration or statement expected.
 
 
 ==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (83 errors) ====
+    
     declare module "fs" {
         export class File {
             constructor(filename: string);

tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js

@@ -1,4 +1,5 @@
 //// [constructorWithIncompleteTypeAnnotation.ts]
+
 declare module "fs" {
     export class File {
         constructor(filename: string);

tests/baselines/reference/continueNotInIterationStatement4.errors.txt

@@ -1,7 +1,8 @@
-tests/cases/compiler/continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary.
+tests/cases/compiler/continueNotInIterationStatement4.ts(5,5): error TS1107: Jump target cannot cross function boundary.
 
 
 ==== tests/cases/compiler/continueNotInIterationStatement4.ts (1 errors) ====
+    
     TWO:
     while (true){
       var x = () => {

tests/baselines/reference/continueNotInIterationStatement4.js

@@ -1,4 +1,5 @@
 //// [continueNotInIterationStatement4.ts]
+
 TWO:
 while (true){
   var x = () => {

tests/baselines/reference/continueTarget3.js

@@ -1,4 +1,5 @@
 //// [continueTarget3.ts]
+
 target1:
 target2:
 while (true) {

tests/baselines/reference/continueTarget3.symbols

@@ -1,5 +1,6 @@
 === tests/cases/compiler/continueTarget3.ts ===
-target1:
+
+No type information for this code.target1:
 No type information for this code.target2:
 No type information for this code.while (true) {
 No type information for this code.  continue target1;

tests/baselines/reference/continueTarget3.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/continueTarget3.ts ===
+
 target1:
 >target1 : any
 

tests/baselines/reference/continueTarget4.js

@@ -1,4 +1,5 @@
 //// [continueTarget4.ts]
+
 target1:
 target2:
 while (true) {

tests/baselines/reference/continueTarget4.symbols

@@ -1,5 +1,6 @@
 === tests/cases/compiler/continueTarget4.ts ===
-target1:
+
+No type information for this code.target1:
 No type information for this code.target2:
 No type information for this code.while (true) {
 No type information for this code.  continue target2;

tests/baselines/reference/continueTarget4.types

@@ -1,4 +1,5 @@
 === tests/cases/compiler/continueTarget4.ts ===
+
 target1:
 >target1 : any
 

tests/baselines/reference/continueTarget5.errors.txt

@@ -1,7 +1,8 @@
-tests/cases/compiler/continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary.
+tests/cases/compiler/continueTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary.
 
 
 ==== tests/cases/compiler/continueTarget5.ts (1 errors) ====
+    
     target:
     while (true) {
       function f() {

tests/baselines/reference/continueTarget5.js

@@ -1,4 +1,5 @@
 //// [continueTarget5.ts]
+
 target:
 while (true) {
   function f() {

tests/baselines/reference/declarationEmitDetachedComment1.js

@@ -0,0 +1,85 @@
+//// [tests/cases/compiler/declarationEmitDetachedComment1.ts] ////
+
+//// [test1.ts]
+
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+
+}
+
+//// [test2.ts]
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+
+}
+
+//// [test3.ts]
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+
+}
+
+
+//// [test1.js]
+/*! Copyright 2015 MyCompany Inc. */
+/**
+ * Hello class
+ */
+var Hello = (function () {
+    function Hello() {
+    }
+    return Hello;
+})();
+//// [test2.js]
+/* A comment at the top of the file. */
+/**
+ * Hi class
+ */
+var Hi = (function () {
+    function Hi() {
+    }
+    return Hi;
+})();
+//// [test3.js]
+// A one-line comment at the top of the file.
+/**
+ * Hola class
+ */
+var Hola = (function () {
+    function Hola() {
+    }
+    return Hola;
+})();
+
+
+//// [test1.d.ts]
+/*! Copyright 2015 MyCompany Inc. */
+/**
+ * Hello class
+ */
+declare class Hello {
+}
+//// [test2.d.ts]
+/**
+ * Hi class
+ */
+declare class Hi {
+}
+//// [test3.d.ts]
+/**
+ * Hola class
+ */
+declare class Hola {
+}

tests/baselines/reference/declarationEmitDetachedComment1.symbols

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/test1.ts ===
+
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+>Hello : Symbol(Hello, Decl(test1.ts, 0, 0))
+
+}
+
+=== tests/cases/compiler/test2.ts ===
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+>Hi : Symbol(Hi, Decl(test2.ts, 0, 0))
+
+}
+
+=== tests/cases/compiler/test3.ts ===
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+>Hola : Symbol(Hola, Decl(test3.ts, 0, 0))
+
+}
+

tests/baselines/reference/declarationEmitDetachedComment1.types

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/test1.ts ===
+
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+>Hello : Hello
+
+}
+
+=== tests/cases/compiler/test2.ts ===
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+>Hi : Hi
+
+}
+
+=== tests/cases/compiler/test3.ts ===
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+>Hola : Hola
+
+}
+

tests/baselines/reference/declarationEmitDetachedComment2.js

@@ -0,0 +1,65 @@
+//// [tests/cases/compiler/declarationEmitDetachedComment2.ts] ////
+
+//// [test1.ts]
+
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+
+}
+
+//// [test2.ts]
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+
+}
+
+//// [test3.ts]
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+
+}
+
+
+//// [test1.js]
+/*! Copyright 2015 MyCompany Inc. */
+var Hello = (function () {
+    function Hello() {
+    }
+    return Hello;
+})();
+//// [test2.js]
+var Hi = (function () {
+    function Hi() {
+    }
+    return Hi;
+})();
+//// [test3.js]
+var Hola = (function () {
+    function Hola() {
+    }
+    return Hola;
+})();
+
+
+//// [test1.d.ts]
+/*! Copyright 2015 MyCompany Inc. */
+declare class Hello {
+}
+//// [test2.d.ts]
+declare class Hi {
+}
+//// [test3.d.ts]
+declare class Hola {
+}

tests/baselines/reference/declarationEmitDetachedComment2.symbols

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/test1.ts ===
+
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+>Hello : Symbol(Hello, Decl(test1.ts, 0, 0))
+
+}
+
+=== tests/cases/compiler/test2.ts ===
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+>Hi : Symbol(Hi, Decl(test2.ts, 0, 0))
+
+}
+
+=== tests/cases/compiler/test3.ts ===
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+>Hola : Symbol(Hola, Decl(test3.ts, 0, 0))
+
+}
+

tests/baselines/reference/declarationEmitDetachedComment2.types

@@ -0,0 +1,34 @@
+=== tests/cases/compiler/test1.ts ===
+
+/*! Copyright 2015 MyCompany Inc. */
+
+/**
+ * Hello class
+ */
+class Hello {
+>Hello : Hello
+
+}
+
+=== tests/cases/compiler/test2.ts ===
+/* A comment at the top of the file. */
+
+/**
+ * Hi class
+ */
+class Hi {
+>Hi : Hi
+
+}
+
+=== tests/cases/compiler/test3.ts ===
+// A one-line comment at the top of the file.
+
+/**
+ * Hola class
+ */
+class Hola {
+>Hola : Hola
+
+}
+

tests/baselines/reference/declarationFiles.errors.txt

@@ -1,15 +1,18 @@
+tests/cases/conformance/types/thisType/declarationFiles.ts(5,20): error TS2526: A 'this' type is available only in a non-static member of a class or interface.
 tests/cases/conformance/types/thisType/declarationFiles.ts(31,5): error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary.
 tests/cases/conformance/types/thisType/declarationFiles.ts(33,5): error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary.
 tests/cases/conformance/types/thisType/declarationFiles.ts(35,5): error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary.
 tests/cases/conformance/types/thisType/declarationFiles.ts(41,5): error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary.
 
 
-==== tests/cases/conformance/types/thisType/declarationFiles.ts (4 errors) ====
+==== tests/cases/conformance/types/thisType/declarationFiles.ts (5 errors) ====
     
     class C1 {
         x: this;
         f(x: this): this { return undefined; }
         constructor(x: this) { }
+                       ~~~~
+!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface.
     }
     
     class C2 {

tests/baselines/reference/doWhileBreakStatements.js

@@ -1,4 +1,5 @@
 //// [doWhileBreakStatements.ts]
+
 do {
     break;
 } while(true)

tests/baselines/reference/doWhileBreakStatements.symbols

@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts ===
+
 do {
     break;
 } while(true)
@@ -34,7 +35,7 @@ do do do break SEVEN; while (true) while (true)  while (true)
 EIGHT:
 do{
     var fn = function () { }
->fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 34, 7))
+>fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 35, 7))
 
     break EIGHT;
 }while(true)

tests/baselines/reference/doWhileBreakStatements.types

@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts ===
+
 do {
     break;
 } while(true)

tests/baselines/reference/doWhileContinueStatements.js

@@ -1,4 +1,5 @@
 //// [doWhileContinueStatements.ts]
+
 do {
     continue;
 } while(true)

tests/baselines/reference/doWhileContinueStatements.symbols

@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts ===
+
 do {
     continue;
 } while(true)
@@ -34,7 +35,7 @@ do do do continue SEVEN; while (true) while (true)  while (true)
 EIGHT:
 do{
     var fn = function () { }
->fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 34, 7))
+>fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 35, 7))
 
     continue EIGHT;
 }while(true)

tests/baselines/reference/doWhileContinueStatements.types

@@ -1,4 +1,5 @@
 === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts ===
+
 do {
     continue;
 } while(true)

tests/baselines/reference/downlevelLetConst16.errors.txt

@@ -1,12 +1,13 @@
-tests/cases/compiler/downlevelLetConst16.ts(151,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
-tests/cases/compiler/downlevelLetConst16.ts(164,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
-tests/cases/compiler/downlevelLetConst16.ts(195,14): error TS2461: Type 'undefined' is not an array type.
-tests/cases/compiler/downlevelLetConst16.ts(202,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
-tests/cases/compiler/downlevelLetConst16.ts(216,16): error TS2461: Type 'undefined' is not an array type.
-tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
+tests/cases/compiler/downlevelLetConst16.ts(152,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
+tests/cases/compiler/downlevelLetConst16.ts(165,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
+tests/cases/compiler/downlevelLetConst16.ts(196,14): error TS2461: Type 'undefined' is not an array type.
+tests/cases/compiler/downlevelLetConst16.ts(203,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
+tests/cases/compiler/downlevelLetConst16.ts(217,16): error TS2461: Type 'undefined' is not an array type.
+tests/cases/compiler/downlevelLetConst16.ts(224,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature.
 
 
 ==== tests/cases/compiler/downlevelLetConst16.ts (6 errors) ====
+    
     'use strict'
     
     declare function use(a: any);

tests/baselines/reference/downlevelLetConst16.js

@@ -1,4 +1,5 @@
 //// [downlevelLetConst16.ts]
+
 'use strict'
 
 declare function use(a: any);